From e4f098997f48fd136df42f8c5c422ce612168cb0 Mon Sep 17 00:00:00 2001 From: Rod Lewis Date: Sun, 26 Jun 2022 21:05:10 +0800 Subject: [PATCH 1/5] add polling --- dist/lib/hooks/useFetch.d.ts | 19 +++- dist/lib/utils/index.d.ts | 1 + dist/lib/utils/poll.d.ts | 8 ++ dist/query-plus.es.js | 53 ++++++++- dist/query-plus.umd.js | 2 +- src/lib/hooks/useFetch.tsx | 30 ++++-- src/lib/utils/index.ts | 1 + src/lib/utils/poll.ts | 35 ++++++ src/lib/workers/fetch_worker.ts | 171 +++++++++++++++++++++--------- src/lib/workers/polling_worker.ts | 35 ++++++ 10 files changed, 292 insertions(+), 63 deletions(-) create mode 100644 dist/lib/utils/poll.d.ts create mode 100644 src/lib/utils/poll.ts create mode 100644 src/lib/workers/polling_worker.ts diff --git a/dist/lib/hooks/useFetch.d.ts b/dist/lib/hooks/useFetch.d.ts index 2d697ff..3f402bb 100644 --- a/dist/lib/hooks/useFetch.d.ts +++ b/dist/lib/hooks/useFetch.d.ts @@ -1,6 +1,6 @@ import { UnknownDataResponseType } from "../utils"; export interface FetchWorkerProps { - fetchOptions?: RequestInit | undefined; + options?: RequestInit | undefined; maxAge?: number; middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType; url: RequestInfo | URL; @@ -9,6 +9,14 @@ export interface FetchWorkerProps { options?: RequestInit | undefined; }; } +export interface PollWorkerProps { + url: RequestInfo | URL; + interval: number; + options?: RequestInit | undefined; + maxAttempts?: number; + existingData?: number; + compareKeys?: string[]; +} /** * useFetch is a React hook that can be initialized with no params. * @example const { data, error, loading, fetchWorker } = useFetch() @@ -25,19 +33,22 @@ export declare function useFetch(): { preload: boolean; error: undefined; update: boolean; - fetchWorker: ({ url, fetchOptions, maxAge, middleware }: FetchWorkerProps) => Promise; + fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise; + pollWorker: ({ url, interval, options, maxAttempts, compareKeys }: PollWorkerProps) => Promise; } | { error: any; loading: boolean; preload: boolean; data: UnknownDataResponseType; update: boolean; - fetchWorker: ({ url, fetchOptions, maxAge, middleware }: FetchWorkerProps) => Promise; + fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise; + pollWorker: ({ url, interval, options, maxAttempts, compareKeys }: PollWorkerProps) => Promise; } | { loading: any; data: UnknownDataResponseType; error?: Error | undefined; preload: boolean; update: boolean; - fetchWorker: ({ url, fetchOptions, maxAge, middleware }: FetchWorkerProps) => Promise; + fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise; + pollWorker: ({ url, interval, options, maxAttempts, compareKeys }: PollWorkerProps) => Promise; }; diff --git a/dist/lib/utils/index.d.ts b/dist/lib/utils/index.d.ts index 50d46ae..9a8a5bb 100644 --- a/dist/lib/utils/index.d.ts +++ b/dist/lib/utils/index.d.ts @@ -1,4 +1,5 @@ export * from "./state_tools"; +export * from "./poll"; export declare const DAY: number; export declare function cleanupWorker(worker: Worker | undefined): void; export declare const dataExpired: (maxAge: number, timestamp?: number | undefined) => boolean; diff --git a/dist/lib/utils/poll.d.ts b/dist/lib/utils/poll.d.ts new file mode 100644 index 0000000..09da044 --- /dev/null +++ b/dist/lib/utils/poll.d.ts @@ -0,0 +1,8 @@ +export interface PollProps { + fn: () => Promise; + validate: (res: unknown) => boolean; + interval: number; + maxAttempts?: number; + attempts?: number; +} +export declare const poll: ({ fn, validate, interval, maxAttempts }: PollProps) => Promise; diff --git a/dist/query-plus.es.js b/dist/query-plus.es.js index ed6a908..5fdcc86 100644 --- a/dist/query-plus.es.js +++ b/dist/query-plus.es.js @@ -18,7 +18,7 @@ var __spreadValues = (a, b) => { }; var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); import { useReducer, useRef, useEffect } from "react"; -const encodedJs = "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"; +const encodedJs = "var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(r,a,l)=>a in r?k(r,a,{enumerable:!0,configurable:!0,writable:!0,value:l}):r[a]=l,f=(r,a)=>{for(var l in a||(a={}))Q.call(a,l)&&B(r,l,a[l]);if(W)for(var l of W(a))v.call(a,l)&&B(r,l,a[l]);return r},G=(r,a)=>j(r,A(a));(function(){"use strict";function r(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function a(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=r(n);return(o,d)=>c.then(i=>d(i.transaction(e,o).objectStore(e)))}let l;function u(){return l||(l=a("keyval-store","keyval")),l}function C(t,e=u()){return e("readonly",n=>r(n.get(t)))}function N(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),r(c.transaction)))}function F(t,e,n=u()){return n("readwrite",c=>new Promise((o,d)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),o(r(c.transaction))}catch(i){d(i)}}}))}function x(t,e=u()){return e("readwrite",n=>(n.delete(t),r(n.transaction)))}const U=(t,e)=>e?t+e<Date.now():!0,S=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,w=(t,e,n={})=>(Object.keys(t).forEach(c=>{let o=e?e+"."+c:c;S(t[c])?w(t[c],o,n):n[o]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>S(e)?w(e):[e]).sort(),D=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},X=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,o=Array.isArray(e)?"array":typeof e;return c!==o?!1:c!=="object"&&c!=="array"?c===o:n&&c==="object"?n.map(d=>t[d]===e[d]).every(d=>d):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=w(t),e=w(e)),JSON.stringify(t)===JSON.stringify(e))},M=t=>new Function(`return ${decodeURI(t)}`)(),L="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",P=typeof window!="undefined"&&window.Blob&&new Blob([atob(L)],{type:"text/javascript;charset=utf-8"});function O(){const t=P&&(window.URL||window.webkitURL).createObjectURL(P);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+L,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const Y=a("usestore-db","usestore-db"),I=t=>x(t,Y),z=t=>C(t,Y),K=(t,e)=>N(t,e,Y),V=(t,e)=>F(t,e,Y),y=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,o=new O;if(e==="cancel"&&(n==null||n.abort(),o==null||o.postMessage({type:"cancel"}),o.terminate()),e==="poll"){let{existingData:d,url:i,options:h,interval:T,maxAttempts:g,compareKeys:m}=t.data;fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p=>{X(d,p,m)?self.postMessage({type:"CACHED",data:p}):(K(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{o==null||o.postMessage({type:e,url:i,options:h,interval:T,maxAttempts:g,existingData:d,compareKeys:m})}),o==null||o.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="fetch"){let{existingData:d,url:i,options:h,maxAge:T,middleware:g,update:m}=t.data;const p=s=>{g&&(s=M(g)(s)),(!d||!X(d,s))&&(self.postMessage({type:"DATA",data:s}),K(i.toString(),{data:s,timestamp:Date.now(),maxAge:T}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let Z=D(h);Z==="DELETE"&&(I(i.toString()),fetch(i,h).then(()=>{m?fetch(m.url,m.options).then(y).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),Z==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw I(i.toString()),new Error("data expired");self.postMessage(X(d,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p).catch(R)),(Z==="PUT"||Z==="POST")&&fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(s=>{m?fetch(m.url,m.options).then(y).then(p).catch(b=>{throw b}):V(i.toString(),b=>{let E=Date.now(),H=S(s)&&S(b==null?void 0:b.data)?f(f({},b.data),s):s;return self.postMessage({type:Z,data:H}),{timestamp:E,maxAge:T,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
"; const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" }); function WorkerWrapper() { const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob); @@ -61,7 +61,7 @@ function useFetch() { const workerRef = useRef(); const fetchWorker = async ({ url, - fetchOptions, + options, maxAge = DAY, middleware }) => { @@ -108,12 +108,56 @@ function useFetch() { worker == null ? void 0 : worker.postMessage({ type: "fetch", url, - fetchOptions, + options, existingData: state.data, middleware: serializedMw, maxAge }); }; + const pollWorker = async ({ + url, + interval = 5e3, + options, + maxAttempts = 100, + compareKeys + }) => { + let worker = workerRef.current; + dispatch({ + type: "loading", + loading: true + }); + worker == null ? void 0 : worker.addEventListener("message", ({ + data: { + type, + data + } + }) => { + if (type === "COMPLETE") + dispatch({ + type: "loading", + loading: false + }); + else if (type === "DATA") + dispatch({ + type: "data", + data + }); + else + dispatch({ + type: "error", + error: new Error(type) + }); + }); + worker == null ? void 0 : worker.postMessage({ + type: "poll", + url, + interval, + maxAttempts, + options, + existingData: state.data, + compareKeys + }); + }; useEffect(() => { workerRef.current = new WorkerWrapper(); return () => { @@ -121,7 +165,8 @@ function useFetch() { }; }, []); return __spreadValues({ - fetchWorker + fetchWorker, + pollWorker }, state); } export { useFetch }; diff --git a/dist/query-plus.umd.js b/dist/query-plus.umd.js index 03662be..0373c80 100644 --- a/dist/query-plus.umd.js +++ b/dist/query-plus.umd.js @@ -1 +1 @@ -(function(e,l){typeof exports=="object"&&typeof module!="undefined"?l(exports,require("react")):typeof define=="function"&&define.amd?define(["exports","react"],l):(e=typeof globalThis!="undefined"?globalThis:e||self,l(e["query-plus"]={},e.React))})(this,function(e,l){"use strict";var I=Object.defineProperty,k=Object.defineProperties;var C=Object.getOwnPropertyDescriptors;var G=Object.getOwnPropertySymbols;var P=Object.prototype.hasOwnProperty,J=Object.prototype.propertyIsEnumerable;var t=(e,l,c)=>l in e?I(e,l,{enumerable:!0,configurable:!0,writable:!0,value:c}):e[l]=c,i=(e,l)=>{for(var c in l||(l={}))P.call(l,c)&&t(e,c,l[c]);if(G)for(var c of G(l))J.call(l,c)&&t(e,c,l[c]);return e},b=(e,l)=>k(e,C(l));const c="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",n=typeof window!="undefined"&&window.Blob&&new Blob([atob(c)],{type:"text/javascript;charset=utf-8"});function y(){const d=n&&(window.URL||window.webkitURL).createObjectURL(n);try{return d?new Worker(d,{}):new Worker("data:application/javascript;base64,"+c,{type:"module"})}finally{d&&(window.URL||window.webkitURL).revokeObjectURL(d)}}const K={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function Y(d,Z){switch(Z.type){case"pre-load":return b(i({},d),{data:Z.data,loading:!1,preload:!0,error:void 0});case"data":return b(i({},d),{data:Z.data,loading:!1,preload:!1,error:void 0});case"error":return b(i({},d),{error:Z.error,loading:!1,preload:!1});case"loading":return b(i({},d),{loading:Z.loading});default:return d}}const s=24*60*60*1e3;function h(d){d==null||d.postMessage({type:"cancel"}),d==null||d.terminate(),d=void 0}const R=d=>encodeURI(d.toString());function X(){const[d,Z]=l.useReducer(Y,K),m=l.useRef(),L=async({url:S,fetchOptions:W,maxAge:T=s,middleware:o})=>{let p=m.current;Z({type:"loading",loading:!0}),p==null||p.addEventListener("message",({data:{type:u,data:a}})=>{switch(u){case"CACHED":case"COMPLETE":Z({type:"loading",loading:!1});break;case"DATA":Z({type:"data",data:a});break;case"PRE_LOAD":Z({type:"pre-load",data:a});break;default:Z({type:"error",error:new Error(u)});break}});let V=o?R(o):void 0;p==null||p.postMessage({type:"fetch",url:S,fetchOptions:W,existingData:d.data,middleware:V,maxAge:T})};return l.useEffect(()=>(m.current=new y,()=>{h(m.current)}),[]),i({fetchWorker:L},d)}e.useFetch=X,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); +(function(Z,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react")):typeof define=="function"&&define.amd?define(["exports","react"],d):(Z=typeof globalThis!="undefined"?globalThis:Z||self,d(Z["query-plus"]={},Z.React))})(this,function(Z,d){"use strict";var u=Object.defineProperty,K=Object.defineProperties;var H=Object.getOwnPropertyDescriptors;var U=Object.getOwnPropertySymbols;var y=Object.prototype.hasOwnProperty,L=Object.prototype.propertyIsEnumerable;var t=(Z,d,a)=>d in Z?u(Z,d,{enumerable:!0,configurable:!0,writable:!0,value:a}):Z[d]=a,c=(Z,d)=>{for(var a in d||(d={}))y.call(d,a)&&t(Z,a,d[a]);if(U)for(var a of U(d))L.call(d,a)&&t(Z,a,d[a]);return Z},m=(Z,d)=>K(Z,H(d));const a="var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(r,a,l)=>a in r?k(r,a,{enumerable:!0,configurable:!0,writable:!0,value:l}):r[a]=l,f=(r,a)=>{for(var l in a||(a={}))Q.call(a,l)&&B(r,l,a[l]);if(W)for(var l of W(a))v.call(a,l)&&B(r,l,a[l]);return r},G=(r,a)=>j(r,A(a));(function(){"use strict";function r(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function a(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=r(n);return(o,d)=>c.then(i=>d(i.transaction(e,o).objectStore(e)))}let l;function u(){return l||(l=a("keyval-store","keyval")),l}function C(t,e=u()){return e("readonly",n=>r(n.get(t)))}function N(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),r(c.transaction)))}function F(t,e,n=u()){return n("readwrite",c=>new Promise((o,d)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),o(r(c.transaction))}catch(i){d(i)}}}))}function x(t,e=u()){return e("readwrite",n=>(n.delete(t),r(n.transaction)))}const U=(t,e)=>e?t+e<Date.now():!0,S=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,w=(t,e,n={})=>(Object.keys(t).forEach(c=>{let o=e?e+"."+c:c;S(t[c])?w(t[c],o,n):n[o]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>S(e)?w(e):[e]).sort(),D=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},X=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,o=Array.isArray(e)?"array":typeof e;return c!==o?!1:c!=="object"&&c!=="array"?c===o:n&&c==="object"?n.map(d=>t[d]===e[d]).every(d=>d):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=w(t),e=w(e)),JSON.stringify(t)===JSON.stringify(e))},M=t=>new Function(`return ${decodeURI(t)}`)(),L="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",P=typeof window!="undefined"&&window.Blob&&new Blob([atob(L)],{type:"text/javascript;charset=utf-8"});function O(){const t=P&&(window.URL||window.webkitURL).createObjectURL(P);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+L,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const Y=a("usestore-db","usestore-db"),I=t=>x(t,Y),z=t=>C(t,Y),K=(t,e)=>N(t,e,Y),V=(t,e)=>F(t,e,Y),y=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,o=new O;if(e==="cancel"&&(n==null||n.abort(),o==null||o.postMessage({type:"cancel"}),o.terminate()),e==="poll"){let{existingData:d,url:i,options:h,interval:T,maxAttempts:g,compareKeys:m}=t.data;fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p=>{X(d,p,m)?self.postMessage({type:"CACHED",data:p}):(K(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{o==null||o.postMessage({type:e,url:i,options:h,interval:T,maxAttempts:g,existingData:d,compareKeys:m})}),o==null||o.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="fetch"){let{existingData:d,url:i,options:h,maxAge:T,middleware:g,update:m}=t.data;const p=s=>{g&&(s=M(g)(s)),(!d||!X(d,s))&&(self.postMessage({type:"DATA",data:s}),K(i.toString(),{data:s,timestamp:Date.now(),maxAge:T}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let Z=D(h);Z==="DELETE"&&(I(i.toString()),fetch(i,h).then(()=>{m?fetch(m.url,m.options).then(y).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),Z==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw I(i.toString()),new Error("data expired");self.postMessage(X(d,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p).catch(R)),(Z==="PUT"||Z==="POST")&&fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(s=>{m?fetch(m.url,m.options).then(y).then(p).catch(b=>{throw b}):V(i.toString(),b=>{let E=Date.now(),H=S(s)&&S(b==null?void 0:b.data)?f(f({},b.data),s):s;return self.postMessage({type:Z,data:H}),{timestamp:E,maxAge:T,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
",N=typeof window!="undefined"&&window.Blob&&new Blob([atob(a)],{type:"text/javascript;charset=utf-8"});function o(){const l=N&&(window.URL||window.webkitURL).createObjectURL(N);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+a,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const S={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function h(l,W){switch(W.type){case"pre-load":return m(c({},l),{data:W.data,loading:!1,preload:!0,error:void 0});case"data":return m(c({},l),{data:W.data,loading:!1,preload:!1,error:void 0});case"error":return m(c({},l),{error:W.error,loading:!1,preload:!1});case"loading":return m(c({},l),{loading:W.loading});default:return l}}const s=24*60*60*1e3;function J(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const F=l=>encodeURI(l.toString());function X(){const[l,W]=d.useReducer(h,S),e=d.useRef(),T=async({url:R,options:n,maxAge:i=s,middleware:G})=>{let V=e.current;W({type:"loading",loading:!0}),V==null||V.addEventListener("message",({data:{type:p,data:Y}})=>{switch(p){case"CACHED":case"COMPLETE":W({type:"loading",loading:!1});break;case"DATA":W({type:"data",data:Y});break;case"PRE_LOAD":W({type:"pre-load",data:Y});break;default:W({type:"error",error:new Error(p)});break}});let b=G?F(G):void 0;V==null||V.postMessage({type:"fetch",url:R,options:n,existingData:l.data,middleware:b,maxAge:i})},k=async({url:R,interval:n=5e3,options:i,maxAttempts:G=100,compareKeys:V})=>{let b=e.current;W({type:"loading",loading:!0}),b==null||b.addEventListener("message",({data:{type:p,data:Y}})=>{W(p==="COMPLETE"?{type:"loading",loading:!1}:p==="DATA"?{type:"data",data:Y}:{type:"error",error:new Error(p)})}),b==null||b.postMessage({type:"poll",url:R,interval:n,maxAttempts:G,options:i,existingData:l.data,compareKeys:V})};return d.useEffect(()=>(e.current=new o,()=>{J(e.current)}),[]),c({fetchWorker:T,pollWorker:k},l)}Z.useFetch=X,Object.defineProperties(Z,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); diff --git a/src/lib/hooks/useFetch.tsx b/src/lib/hooks/useFetch.tsx index d50ff2d..e467b1e 100644 --- a/src/lib/hooks/useFetch.tsx +++ b/src/lib/hooks/useFetch.tsx @@ -1,7 +1,7 @@ import { useRef, useEffect, useReducer } from "react"; import FetchWorker from '../workers/fetch_worker.js?worker&inline' -import { cleanupWorker, DAY, initialState, isObject, reducer, serializeFunction, UnknownDataResponseType } from "../utils"; +import { cleanupWorker, DAY, initialState, reducer, serializeFunction, UnknownDataResponseType } from "../utils"; type WorkerResponseType = MessageEvent<{ @@ -10,7 +10,7 @@ type WorkerResponseType = MessageEvent<{ }> export interface FetchWorkerProps { - fetchOptions?: RequestInit | undefined + options?: RequestInit | undefined maxAge?: number middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType url: RequestInfo | URL @@ -25,6 +25,14 @@ export interface FetchWorkerProps { options?: RequestInit | undefined } } +export interface PollWorkerProps { + url: RequestInfo | URL + interval: number, + options?: RequestInit | undefined + maxAttempts?: number, + existingData?: number, + compareKeys?: string[] +} /** * useFetch is a React hook that can be initialized with no params. * @example const { data, error, loading, fetchWorker } = useFetch() @@ -38,8 +46,8 @@ export interface FetchWorkerProps { export function useFetch() { const [state, dispatch] = useReducer(reducer, initialState); const workerRef = useRef(); - - const fetchWorker = async ({ url, fetchOptions, maxAge = DAY, middleware }: FetchWorkerProps) => { + + const fetchWorker = async ({ url, options, maxAge = DAY, middleware }: FetchWorkerProps) => { let worker = workerRef.current; dispatch({ type: 'loading', loading: true }); @@ -61,7 +69,17 @@ export function useFetch() { } }); let serializedMw = middleware ? serializeFunction(middleware) : undefined - worker?.postMessage({ type: 'fetch', url, fetchOptions, existingData: state.data, middleware: serializedMw, maxAge }); + worker?.postMessage({ type: 'fetch', url, options, existingData: state.data, middleware: serializedMw, maxAge }); + } + const pollWorker = async ({ url, interval = 5000, options, maxAttempts = 100, compareKeys }: PollWorkerProps) => { + let worker = workerRef.current; + dispatch({ type: 'loading', loading: true }) + worker?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { + if(type === 'COMPLETE') dispatch({ type: 'loading', loading: false }); + else if(type === 'DATA') dispatch({ type: 'data', data }); + else dispatch({ type: 'error', error: new Error(type) }); + }) + worker?.postMessage({ type: 'poll', url, interval, maxAttempts, options, existingData: state.data, compareKeys }); } useEffect(() => { @@ -71,6 +89,6 @@ export function useFetch() { } }, []); - return { fetchWorker, ...state! }; + return { fetchWorker, pollWorker, ...state! }; }; diff --git a/src/lib/utils/index.ts b/src/lib/utils/index.ts index 1656d99..5b9a487 100644 --- a/src/lib/utils/index.ts +++ b/src/lib/utils/index.ts @@ -1,4 +1,5 @@ export * from "./state_tools"; +export * from "./poll"; export const DAY = 24 * 60 * 60 * 1000; export function cleanupWorker(worker: Worker | undefined) { diff --git a/src/lib/utils/poll.ts b/src/lib/utils/poll.ts new file mode 100644 index 0000000..c7e9266 --- /dev/null +++ b/src/lib/utils/poll.ts @@ -0,0 +1,35 @@ +export interface PollProps { + fn: () => Promise; + validate: (res: unknown) => boolean; + interval: number; + maxAttempts?: number; + attempts?: number +} + +export const poll: ( + { fn, validate, interval, maxAttempts }: PollProps, +) => Promise = async ({ fn, validate, interval, maxAttempts, attempts=0 }) => { + async function executePoll( + resolve: (value: unknown) => void, + reject: (reason?: any) => void, + ) { + try { + const result = await fn(); + attempts++; + if (!validate(result)) { + return resolve(result); + } else if (maxAttempts && (attempts === maxAttempts)) { + return reject(new Error("Exceeded max attempts")); + } else { + await setTimeout(executePoll, interval, resolve, reject); + } + } catch (error) { + console.error( + `polling Error: ${ + (error as Error)?.message || "connection failed" + }`, + ); + } + } + return new Promise(executePoll); +}; diff --git a/src/lib/workers/fetch_worker.ts b/src/lib/workers/fetch_worker.ts index 720f6ab..9b17bd6 100644 --- a/src/lib/workers/fetch_worker.ts +++ b/src/lib/workers/fetch_worker.ts @@ -5,11 +5,19 @@ import { isMatch, dataExpired, isObject, + type UnknownDataResponseType, } from "../utils"; import type { UseStore } from "idb-keyval"; +import PollWorker from "./polling_worker.js?worker&inline"; -type ValueType = { timestamp: number, maxAge: number, data: any } +type ValueType = { timestamp: number; maxAge: number; data: any }; +type WorkerResponseType = MessageEvent< + { + type: string; + data?: UnknownDataResponseType; + } +>; const DB_NAME = "usestore-db"; const DB_STORE = "usestore-db"; @@ -17,35 +25,84 @@ const store: UseStore = createStore(DB_NAME, DB_STORE); const remove = (key: IDBValidKey) => del(key, store); const getData = (key: IDBValidKey) => get(key, store); const setData = (key: IDBValidKey, value: unknown) => set(key, value, store); -const updateData = (key: IDBValidKey, updater: (oldValue: any) => any) => update(key, updater, store) +const updateData = (key: IDBValidKey, updater: (oldValue: any) => any) => + update(key, updater, store); const handleResponse = (response: Response) => { if (!response.ok || response.status === 404) { - throw new Error( - `HTTP error! Status: ${response.status}`, - ); + throw new Error(`HTTP error! Status: ${response.status}`); } if (response.status === 403) { throw new Error(`Unauthorized!`); } return response.json(); -} +}; const handleError = (error: Error) => { self.postMessage({ type: error.message || "Unknown error", }); -} +}; self.addEventListener( "message", (event) => { const { type } = event.data; let controller: AbortController | undefined = new AbortController(); let signal = controller?.signal; + let pollWorker = new PollWorker(); if (type === "cancel") { controller?.abort(); + pollWorker?.postMessage({ type: "cancel" }); + pollWorker.terminate(); + } + if (type === "poll") { + let { + existingData, + url, + options, + interval, + maxAttempts, + compareKeys, + } = event.data; + fetch(url, options ? { ...options, signal } : { signal }) + .then(handleResponse) + .then( + (data: unknown) => { + if (isMatch(existingData, data, compareKeys)) { + self.postMessage({ type: "CACHED", data }); + } else { + setData(url, { timestamp: Date.now(), data }); + self.postMessage({ type: "DATA", data }); + } + }, + ) + .catch(handleError) + .finally(() => { + pollWorker?.postMessage({ + type, + url, + options, + interval, + maxAttempts, + existingData, + compareKeys, + }); + }); + pollWorker?.addEventListener( + "message", + ({ data }: WorkerResponseType) => { + self.postMessage(data); + }, + ); } if (type === "fetch") { - let { existingData, url, options, maxAge, middleware, update } = event.data; + let { + existingData, + url, + options, + maxAge, + middleware, + update, + } = event.data; const handleData = (data: unknown) => { if (middleware) { let fn = deserializeFunction(middleware); @@ -54,16 +111,23 @@ self.addEventListener( let hasChanged = !existingData || !isMatch(existingData, data); if (hasChanged) { self.postMessage({ type: "DATA", data }); - setData(url.toString(), { - data, - timestamp: Date.now(), - maxAge, - }) - .then(() => { console.info("saved data") }) - .catch(() => { console.info("couldn't access indexedDB to save data") }) + setData( + url.toString(), + { + data, + timestamp: Date.now(), + maxAge, + }, + ) + .then(() => { + console.info("saved data"); + }) + .catch(() => { + console.info("couldn't access indexedDB to save data"); + }); } self.postMessage({ type: "COMPLETE" }); - } + }; let method = methodType(options); if (method === "DELETE") { remove(url.toString()); @@ -73,63 +137,74 @@ self.addEventListener( fetch(update.url, update.options) .then(handleResponse) .then(handleData) - .catch((err) => { throw err }) + .catch((err) => { + throw err; + }); } else { self.postMessage({ type: "COMPLETE" }); } }) - .catch(handleError) + .catch(handleError); } if (method === "GET") { getData(url.toString()) - .then((value: ValueType) => { - if (!value) { - throw new Error("no value found in db"); - } - if (dataExpired(value?.maxAge, value?.timestamp)) { - remove(url.toString()); - throw new Error("data expired"); - } - self.postMessage(isMatch( - existingData, value?.data) - ?{ type: "CACHED" } - : { + .then( + (value: ValueType) => { + if (!value) { + throw new Error("no value found in db"); + } + if (dataExpired(value?.maxAge, value?.timestamp)) { + remove(url.toString()); + throw new Error("data expired"); + } + self.postMessage( + isMatch(existingData, value?.data) ? { type: "CACHED" } : { type: "PRE_LOAD", data: value?.data, - }); - }) + }, + ); + }, + ) .catch((err) => { console.info(err?.message); }); - fetch(url, options ? { ...options, signal } : { signal }) - .then(handleResponse) - .then(handleData) - .catch(handleError); + fetch(url, options ? { ...options, signal } : { signal }).then( + handleResponse, + ).then(handleData).catch(handleError); } if (method === "PUT" || method === "POST") { fetch(url, options ? { ...options, signal } : { signal }) .then(handleResponse) - .then(data => { + .then((data) => { if (update) { fetch(update.url, update.options) .then(handleResponse) .then(handleData) - .catch((err) => { throw err }) + .catch((err) => { + throw err; + }); } else { - updateData(url.toString(), (oldValue: ValueType) => { - let timestamp = Date.now(); - let newData = isObject(data) && isObject(oldValue?.data) ? { ...oldValue.data, ...data } : data; - self.postMessage({ type: method, data: newData }); - return { timestamp, maxAge, data: newData } - }) + updateData( + url.toString(), + (oldValue: ValueType) => { + let timestamp = Date.now(); + let newData = isObject(data) && isObject(oldValue?.data) ? { + ...oldValue.data, + ...data, + } : data; + self.postMessage({ type: method, data: newData }); + return { timestamp, maxAge, data: newData }; + }, + ) .catch(() => { - console.info("update store failed") + console.info("update store failed"); }) - .finally(() => {self.postMessage({ type: "COMPLETE" });}) - + .finally(() => { + self.postMessage({ type: "COMPLETE" }); + }); } }) - .catch(handleError) + .catch(handleError); } } }, diff --git a/src/lib/workers/polling_worker.ts b/src/lib/workers/polling_worker.ts new file mode 100644 index 0000000..8f1cd92 --- /dev/null +++ b/src/lib/workers/polling_worker.ts @@ -0,0 +1,35 @@ +import {isMatch, poll} from "../utils" +self.addEventListener('message', (event) => { + const { type } = event.data; + let controller: AbortController | undefined = new AbortController(); + let signal = controller?.signal; + if (type === 'cancel') { + controller?.abort(); + } + if (type === 'poll') { + const { url, options, interval, maxAttempts, existingData, compareKeys } = event.data; + const validate = (newJson: unknown) => !isMatch(existingData, newJson, compareKeys); + const getData = () => fetch(url, options ? {...options, signal} : {signal}).then( + (response) => { + if (!response.ok || response.status === 404) { + throw new Error(`HTTP error! Status: ${ response.status }`); + } + if (response.status === 403) { + throw new Error(`Unauthorized!`); + } + return response.json(); + } + ) + poll({ + fn: getData, + interval, + maxAttempts, + validate + }) + .then(data => { + self.postMessage({type: 'DATA', data}); + }).catch(error => { + self.postMessage({type: error.message || 'Unknown error'}); + }) + } +}); \ No newline at end of file From 1fbee16381fa3c11268c7c97415f10544b0448c8 Mon Sep 17 00:00:00 2001 From: Rod Lewis Date: Mon, 27 Jun 2022 16:58:01 +0800 Subject: [PATCH 2/5] build --- dist/queryPlus.umd.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dist/queryPlus.umd.js b/dist/queryPlus.umd.js index a771541..cb9dc2e 100644 --- a/dist/queryPlus.umd.js +++ b/dist/queryPlus.umd.js @@ -1 +1 @@ -(function(e,l){typeof exports=="object"&&typeof module!="undefined"?l(exports,require("react")):typeof define=="function"&&define.amd?define(["exports","react"],l):(e=typeof globalThis!="undefined"?globalThis:e||self,l(e.queryPlus={},e.React))})(this,function(e,l){"use strict";var I=Object.defineProperty,k=Object.defineProperties;var C=Object.getOwnPropertyDescriptors;var G=Object.getOwnPropertySymbols;var P=Object.prototype.hasOwnProperty,J=Object.prototype.propertyIsEnumerable;var t=(e,l,c)=>l in e?I(e,l,{enumerable:!0,configurable:!0,writable:!0,value:c}):e[l]=c,i=(e,l)=>{for(var c in l||(l={}))P.call(l,c)&&t(e,c,l[c]);if(G)for(var c of G(l))J.call(l,c)&&t(e,c,l[c]);return e},b=(e,l)=>k(e,C(l));const c="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",n=typeof window!="undefined"&&window.Blob&&new Blob([atob(c)],{type:"text/javascript;charset=utf-8"});function y(){const d=n&&(window.URL||window.webkitURL).createObjectURL(n);try{return d?new Worker(d,{}):new Worker("data:application/javascript;base64,"+c,{type:"module"})}finally{d&&(window.URL||window.webkitURL).revokeObjectURL(d)}}const K={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function Y(d,Z){switch(Z.type){case"pre-load":return b(i({},d),{data:Z.data,loading:!1,preload:!0,error:void 0});case"data":return b(i({},d),{data:Z.data,loading:!1,preload:!1,error:void 0});case"error":return b(i({},d),{error:Z.error,loading:!1,preload:!1});case"loading":return b(i({},d),{loading:Z.loading});default:return d}}const s=24*60*60*1e3;function h(d){d==null||d.postMessage({type:"cancel"}),d==null||d.terminate(),d=void 0}const R=d=>encodeURI(d.toString());function X(){const[d,Z]=l.useReducer(Y,K),m=l.useRef(),L=async({url:S,fetchOptions:W,maxAge:T=s,middleware:o})=>{let p=m.current;Z({type:"loading",loading:!0}),p==null||p.addEventListener("message",({data:{type:u,data:a}})=>{switch(u){case"CACHED":case"COMPLETE":Z({type:"loading",loading:!1});break;case"DATA":Z({type:"data",data:a});break;case"PRE_LOAD":Z({type:"pre-load",data:a});break;default:Z({type:"error",error:new Error(u)});break}});let V=o?R(o):void 0;p==null||p.postMessage({type:"fetch",url:S,fetchOptions:W,existingData:d.data,middleware:V,maxAge:T})};return l.useEffect(()=>(m.current=new y,()=>{h(m.current)}),[]),i({fetchWorker:L},d)}e.useFetch=X,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); +(function(Z,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react")):typeof define=="function"&&define.amd?define(["exports","react"],d):(Z=typeof globalThis!="undefined"?globalThis:Z||self,d(Z.queryPlus={},Z.React))})(this,function(Z,d){"use strict";var u=Object.defineProperty,K=Object.defineProperties;var H=Object.getOwnPropertyDescriptors;var U=Object.getOwnPropertySymbols;var y=Object.prototype.hasOwnProperty,L=Object.prototype.propertyIsEnumerable;var t=(Z,d,a)=>d in Z?u(Z,d,{enumerable:!0,configurable:!0,writable:!0,value:a}):Z[d]=a,p=(Z,d)=>{for(var a in d||(d={}))y.call(d,a)&&t(Z,a,d[a]);if(U)for(var a of U(d))L.call(d,a)&&t(Z,a,d[a]);return Z},m=(Z,d)=>K(Z,H(d));const a="var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(r,a,l)=>a in r?k(r,a,{enumerable:!0,configurable:!0,writable:!0,value:l}):r[a]=l,f=(r,a)=>{for(var l in a||(a={}))Q.call(a,l)&&B(r,l,a[l]);if(W)for(var l of W(a))v.call(a,l)&&B(r,l,a[l]);return r},G=(r,a)=>j(r,A(a));(function(){"use strict";function r(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function a(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=r(n);return(o,d)=>c.then(i=>d(i.transaction(e,o).objectStore(e)))}let l;function u(){return l||(l=a("keyval-store","keyval")),l}function C(t,e=u()){return e("readonly",n=>r(n.get(t)))}function N(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),r(c.transaction)))}function F(t,e,n=u()){return n("readwrite",c=>new Promise((o,d)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),o(r(c.transaction))}catch(i){d(i)}}}))}function x(t,e=u()){return e("readwrite",n=>(n.delete(t),r(n.transaction)))}const U=(t,e)=>e?t+e<Date.now():!0,S=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,w=(t,e,n={})=>(Object.keys(t).forEach(c=>{let o=e?e+"."+c:c;S(t[c])?w(t[c],o,n):n[o]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>S(e)?w(e):[e]).sort(),D=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},X=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,o=Array.isArray(e)?"array":typeof e;return c!==o?!1:c!=="object"&&c!=="array"?c===o:n&&c==="object"?n.map(d=>t[d]===e[d]).every(d=>d):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=w(t),e=w(e)),JSON.stringify(t)===JSON.stringify(e))},M=t=>new Function(`return ${decodeURI(t)}`)(),L="dmFyIG09T2JqZWN0LmRlZmluZVByb3BlcnR5LFQ9T2JqZWN0LmRlZmluZVByb3BlcnRpZXM7dmFyIEQ9T2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcnM7dmFyIGc9T2JqZWN0LmdldE93blByb3BlcnR5U3ltYm9sczt2YXIgTT1PYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LE89T2JqZWN0LnByb3RvdHlwZS5wcm9wZXJ0eUlzRW51bWVyYWJsZTt2YXIgZD0oaSxzLG4pPT5zIGluIGk/bShpLHMse2VudW1lcmFibGU6ITAsY29uZmlndXJhYmxlOiEwLHdyaXRhYmxlOiEwLHZhbHVlOm59KTppW3NdPW4saD0oaSxzKT0+e2Zvcih2YXIgbiBpbiBzfHwocz17fSkpTS5jYWxsKHMsbikmJmQoaSxuLHNbbl0pO2lmKGcpZm9yKHZhciBuIG9mIGcocykpTy5jYWxsKHMsbikmJmQoaSxuLHNbbl0pO3JldHVybiBpfSxwPShpLHMpPT5UKGksRChzKSk7KGZ1bmN0aW9uKCl7InVzZSBzdHJpY3QiO2NvbnN0IGk9YXN5bmMoe2ZuOnQsdmFsaWRhdGU6ZSxpbnRlcnZhbDphLG1heEF0dGVtcHRzOnIsYXR0ZW1wdHM6Yz0wfSk9Pnthc3luYyBmdW5jdGlvbiBmKHUseSl7dHJ5e2NvbnN0IGw9YXdhaXQgdCgpO2lmKGMrKyxlKGwpKXtpZihyJiZjPT09cilyZXR1cm4geShuZXcgRXJyb3IoIkV4Y2VlZGVkIG1heCBhdHRlbXB0cyIpKTthd2FpdCBzZXRUaW1lb3V0KGYsYSx1LHkpfWVsc2UgcmV0dXJuIHUobCl9Y2F0Y2gobCl7Y29uc29sZS5lcnJvcihgcG9sbGluZyBFcnJvcjogJHsobD09bnVsbD92b2lkIDA6bC5tZXNzYWdlKXx8ImNvbm5lY3Rpb24gZmFpbGVkIn1gKX19cmV0dXJuIG5ldyBQcm9taXNlKGYpfSxzPXQ9PnR5cGVvZiB0PT0ib2JqZWN0IiYmIUFycmF5LmlzQXJyYXkodCkmJnQhPT1udWxsLG49KHQsZSxhPXt9KT0+KE9iamVjdC5rZXlzKHQpLmZvckVhY2gocj0+e2xldCBjPWU/ZSsiLiIrcjpyO3ModFtyXSk/bih0W3JdLGMsYSk6YVtjXT1BcnJheS5pc0FycmF5KHRbcl0pP3Rbcl0uc29ydCgpOnRbcl19KSxPYmplY3QuZW50cmllcyhhKS5zb3J0KCkpLEE9dD0+dC5mbGF0TWFwKGU9PnMoZSk/bihlKTpbZV0pLnNvcnQoKSx3PSh0LGUsYSk9PntsZXQgcj1BcnJheS5pc0FycmF5KHQpPyJhcnJheSI6dHlwZW9mIHQsYz1BcnJheS5pc0FycmF5KGUpPyJhcnJheSI6dHlwZW9mIGU7cmV0dXJuIHIhPT1jPyExOnIhPT0ib2JqZWN0IiYmciE9PSJhcnJheSI/cj09PWM6YSYmcj09PSJvYmplY3QiP2EubWFwKGY9PnRbZl09PT1lW2ZdKS5ldmVyeShmPT5mKToocj09PSJhcnJheSImJih0PUEodCksZT1BKGUpKSwhYSYmcj09PSJvYmplY3QiJiYodD1uKHQpLGU9bihlKSksSlNPTi5zdHJpbmdpZnkodCk9PT1KU09OLnN0cmluZ2lmeShlKSl9O3NlbGYuYWRkRXZlbnRMaXN0ZW5lcigibWVzc2FnZSIsdD0+e2NvbnN0e3R5cGU6ZX09dC5kYXRhO2xldCBhPW5ldyBBYm9ydENvbnRyb2xsZXIscj1hPT1udWxsP3ZvaWQgMDphLnNpZ25hbDtpZihlPT09ImNhbmNlbCImJihhPT1udWxsfHxhLmFib3J0KCkpLGU9PT0icG9sbCIpe2NvbnN0e3VybDpjLG9wdGlvbnM6ZixpbnRlcnZhbDp1LG1heEF0dGVtcHRzOnksZXhpc3RpbmdEYXRhOmwsY29tcGFyZUtleXM6RX09dC5kYXRhO2koe2ZuOigpPT5mZXRjaChjLGY/cChoKHt9LGYpLHtzaWduYWw6cn0pOntzaWduYWw6cn0pLnRoZW4obz0+e2lmKCFvLm9rfHxvLnN0YXR1cz09PTQwNCl0aHJvdyBuZXcgRXJyb3IoYEhUVFAgZXJyb3IhIFN0YXR1czogJHtvLnN0YXR1c31gKTtpZihvLnN0YXR1cz09PTQwMyl0aHJvdyBuZXcgRXJyb3IoIlVuYXV0aG9yaXplZCEiKTtyZXR1cm4gby5qc29uKCl9KSxpbnRlcnZhbDp1LG1heEF0dGVtcHRzOnksdmFsaWRhdGU6bz0+IXcobCxvLEUpfSkudGhlbihvPT57c2VsZi5wb3N0TWVzc2FnZSh7dHlwZToiREFUQSIsZGF0YTpvfSl9KS5jYXRjaChvPT57c2VsZi5wb3N0TWVzc2FnZSh7dHlwZTpvLm1lc3NhZ2V8fCJVbmtub3duIGVycm9yIn0pfSl9fSl9KSgpOwo=",P=typeof window!="undefined"&&window.Blob&&new Blob([atob(L)],{type:"text/javascript;charset=utf-8"});function O(){const t=P&&(window.URL||window.webkitURL).createObjectURL(P);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+L,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const Y=a("usestore-db","usestore-db"),I=t=>x(t,Y),z=t=>C(t,Y),K=(t,e)=>N(t,e,Y),V=(t,e)=>F(t,e,Y),y=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,o=new O;if(e==="cancel"&&(n==null||n.abort(),o==null||o.postMessage({type:"cancel"}),o.terminate()),e==="poll"){let{existingData:d,url:i,options:h,interval:T,maxAttempts:g,compareKeys:m}=t.data;fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p=>{X(d,p,m)?self.postMessage({type:"CACHED",data:p}):(K(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{o==null||o.postMessage({type:e,url:i,options:h,interval:T,maxAttempts:g,existingData:d,compareKeys:m})}),o==null||o.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="fetch"){let{existingData:d,url:i,options:h,maxAge:T,middleware:g,update:m}=t.data;const p=s=>{g&&(s=M(g)(s)),(!d||!X(d,s))&&(self.postMessage({type:"DATA",data:s}),K(i.toString(),{data:s,timestamp:Date.now(),maxAge:T}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let Z=D(h);Z==="DELETE"&&(I(i.toString()),fetch(i,h).then(()=>{m?fetch(m.url,m.options).then(y).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),Z==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw I(i.toString()),new Error("data expired");self.postMessage(X(d,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p).catch(R)),(Z==="PUT"||Z==="POST")&&fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(s=>{m?fetch(m.url,m.options).then(y).then(p).catch(b=>{throw b}):V(i.toString(),b=>{let E=Date.now(),H=S(s)&&S(b==null?void 0:b.data)?f(f({},b.data),s):s;return self.postMessage({type:Z,data:H}),{timestamp:E,maxAge:T,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
",N=typeof window!="undefined"&&window.Blob&&new Blob([atob(a)],{type:"text/javascript;charset=utf-8"});function o(){const l=N&&(window.URL||window.webkitURL).createObjectURL(N);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+a,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const S={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function h(l,W){switch(W.type){case"pre-load":return m(p({},l),{data:W.data,loading:!1,preload:!0,error:void 0});case"data":return m(p({},l),{data:W.data,loading:!1,preload:!1,error:void 0});case"error":return m(p({},l),{error:W.error,loading:!1,preload:!1});case"loading":return m(p({},l),{loading:W.loading});default:return l}}const s=24*60*60*1e3;function J(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const F=l=>encodeURI(l.toString());function X(){const[l,W]=d.useReducer(h,S),e=d.useRef(),T=async({url:R,options:n,maxAge:i=s,middleware:G})=>{let V=e.current;W({type:"loading",loading:!0}),V==null||V.addEventListener("message",({data:{type:c,data:Y}})=>{switch(c){case"CACHED":case"COMPLETE":W({type:"loading",loading:!1});break;case"DATA":W({type:"data",data:Y});break;case"PRE_LOAD":W({type:"pre-load",data:Y});break;default:W({type:"error",error:new Error(c)});break}});let b=G?F(G):void 0;V==null||V.postMessage({type:"fetch",url:R,options:n,existingData:l.data,middleware:b,maxAge:i})},k=async({url:R,interval:n=5e3,options:i,maxAttempts:G=100,compareKeys:V})=>{let b=e.current;W({type:"loading",loading:!0}),b==null||b.addEventListener("message",({data:{type:c,data:Y}})=>{W(c==="COMPLETE"?{type:"loading",loading:!1}:c==="DATA"?{type:"data",data:Y}:{type:"error",error:new Error(c)})}),b==null||b.postMessage({type:"poll",url:R,interval:n,maxAttempts:G,options:i,existingData:l.data,compareKeys:V})};return d.useEffect(()=>(e.current=new o,()=>{J(e.current)}),[]),p({fetchWorker:T,pollWorker:k},l)}Z.useFetch=X,Object.defineProperties(Z,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); From 3c242317480aa1ae988b1356a571b4cf4f13a5fb Mon Sep 17 00:00:00 2001 From: Rod Lewis Date: Mon, 27 Jun 2022 19:41:18 +0800 Subject: [PATCH 3/5] add more hooks --- dist/lib/hooks/useFetch.d.ts | 37 ++------------- dist/lib/hooks/usePoll.d.ts | 20 +++++++++ dist/lib/hooks/usePreFetch.d.ts | 2 + dist/lib/index.d.ts | 2 + dist/lib/types.d.ts | 39 ++++++++++++++++ dist/lib/utils/index.d.ts | 7 ++- dist/lib/utils/store_tools.d.ts | 6 +++ dist/queryPlus.es.js | 78 +++++++++++++++++++------------- dist/queryPlus.umd.js | 2 +- src/lib/hooks/useFetch.tsx | 59 +++--------------------- src/lib/hooks/usePoll.tsx | 26 +++++++++++ src/lib/hooks/usePreFetch.tsx | 24 ++++++++++ src/lib/hooks/useStore.tsx | 19 ++++++++ src/lib/index.ts | 4 +- src/lib/types.d.ts | 39 ++++++++++++++++ src/lib/utils/index.ts | 10 +++-- src/lib/utils/store_tools.ts | 20 +++++++++ src/lib/workers/fetch_worker.ts | 48 ++++++++++++-------- src/lib/workers/store_worker.ts | 79 +++++++++++++++++++++++++++++++++ 19 files changed, 375 insertions(+), 146 deletions(-) create mode 100644 dist/lib/hooks/usePoll.d.ts create mode 100644 dist/lib/hooks/usePreFetch.d.ts create mode 100644 dist/lib/types.d.ts create mode 100644 dist/lib/utils/store_tools.d.ts create mode 100644 src/lib/hooks/usePoll.tsx create mode 100644 src/lib/hooks/usePreFetch.tsx create mode 100644 src/lib/hooks/useStore.tsx create mode 100644 src/lib/types.d.ts create mode 100644 src/lib/utils/store_tools.ts create mode 100644 src/lib/workers/store_worker.ts diff --git a/dist/lib/hooks/useFetch.d.ts b/dist/lib/hooks/useFetch.d.ts index 3f402bb..9449fdc 100644 --- a/dist/lib/hooks/useFetch.d.ts +++ b/dist/lib/hooks/useFetch.d.ts @@ -1,32 +1,4 @@ -import { UnknownDataResponseType } from "../utils"; -export interface FetchWorkerProps { - options?: RequestInit | undefined; - maxAge?: number; - middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType; - url: RequestInfo | URL; - update?: { - url: RequestInfo | URL; - options?: RequestInit | undefined; - }; -} -export interface PollWorkerProps { - url: RequestInfo | URL; - interval: number; - options?: RequestInit | undefined; - maxAttempts?: number; - existingData?: number; - compareKeys?: string[]; -} -/** - * useFetch is a React hook that can be initialized with no params. - * @example const { data, error, loading, fetchWorker } = useFetch() - * fetchWorker({ - * url: 'https://swapi.dev/api/people/1/', - * middleware: (d:Record) => { let keys = Object.keys(d); return {[keys[0]]: d[keys[0]], [keys[1]]: d[keys[1]]}} - * }); - * - * - */ +import type { FetchWorkerProps } from "../types"; export declare function useFetch(): { data: any; loading: boolean; @@ -34,21 +6,18 @@ export declare function useFetch(): { error: undefined; update: boolean; fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise; - pollWorker: ({ url, interval, options, maxAttempts, compareKeys }: PollWorkerProps) => Promise; } | { error: any; loading: boolean; preload: boolean; - data: UnknownDataResponseType; + data: import("../utils").UnknownDataResponseType; update: boolean; fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise; - pollWorker: ({ url, interval, options, maxAttempts, compareKeys }: PollWorkerProps) => Promise; } | { loading: any; - data: UnknownDataResponseType; + data: import("../utils").UnknownDataResponseType; error?: Error | undefined; preload: boolean; update: boolean; fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise; - pollWorker: ({ url, interval, options, maxAttempts, compareKeys }: PollWorkerProps) => Promise; }; diff --git a/dist/lib/hooks/usePoll.d.ts b/dist/lib/hooks/usePoll.d.ts new file mode 100644 index 0000000..c29767e --- /dev/null +++ b/dist/lib/hooks/usePoll.d.ts @@ -0,0 +1,20 @@ +import type { PollWorkerProps } from "../types"; +export declare function usePoll(props: PollWorkerProps): { + data: any; + loading: boolean; + preload: boolean; + error: undefined; + update: boolean; +} | { + error: any; + loading: boolean; + preload: boolean; + data: import("../utils").UnknownDataResponseType; + update: boolean; +} | { + loading: any; + data: import("../utils").UnknownDataResponseType; + error?: Error | undefined; + preload: boolean; + update: boolean; +}; diff --git a/dist/lib/hooks/usePreFetch.d.ts b/dist/lib/hooks/usePreFetch.d.ts new file mode 100644 index 0000000..4bf89b2 --- /dev/null +++ b/dist/lib/hooks/usePreFetch.d.ts @@ -0,0 +1,2 @@ +import type { FetchWorkerBaseRequestType } from "../types"; +export declare function usePreFetch(prefetch?: Array): void; diff --git a/dist/lib/index.d.ts b/dist/lib/index.d.ts index e54a83f..9d1c0df 100644 --- a/dist/lib/index.d.ts +++ b/dist/lib/index.d.ts @@ -1 +1,3 @@ export { useFetch } from './hooks/useFetch'; +export { usePoll } from './hooks/usePoll'; +export { usePreFetch } from './hooks/usePreFetch'; diff --git a/dist/lib/types.d.ts b/dist/lib/types.d.ts new file mode 100644 index 0000000..f87e456 --- /dev/null +++ b/dist/lib/types.d.ts @@ -0,0 +1,39 @@ +export type StringAnyTuple = [string, any] +export type ArrayOfStringAnyTuple = Array +export type createArrayOfUpdatesType = (oldRecord: Record, newRecord: Record) => ArrayOfStringAnyTuple + +export type WorkerResponseType = MessageEvent<{ + type: string; + data?: UnknownDataResponseType +}> +export interface FetchWorkerBaseRequestType { + options?: RequestInit | undefined + maxAge?: number + middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType + url: RequestInfo | URL +} + +export interface FetchWorkerProps extends FetchWorkerBaseRequestType { + /* + update will be fetched after the response is received. + This is useful for updating after POST PUT or DELETE, + where the api doesn't return all the data and the GET + endpoint is different. + */ + update?: { + url: RequestInfo | URL, + options?: RequestInit | undefined + } +} +export interface PollWorkerProps { + url: RequestInfo | URL + interval: number, + options?: RequestInit | undefined + maxAttempts?: number, + existingData?: number, + compareKeys?: string[] +} + +export type ValueType = { timestamp: number; maxAge: number; data: any }; + + diff --git a/dist/lib/utils/index.d.ts b/dist/lib/utils/index.d.ts index 9a8a5bb..e8d32f0 100644 --- a/dist/lib/utils/index.d.ts +++ b/dist/lib/utils/index.d.ts @@ -1,4 +1,6 @@ +import type { createArrayOfUpdatesType } from "../types"; export * from "./state_tools"; +export * from "./store_tools"; export * from "./poll"; export declare const DAY: number; export declare function cleanupWorker(worker: Worker | undefined): void; @@ -8,9 +10,6 @@ export declare const flattenObjectToArray: (obj: Record, parent?: s export declare const flattenAndSortArray: (arr: Array) => any[]; export declare const methodType: (options: RequestInit | undefined) => string; export declare const isMatch: (a: unknown, b: unknown, compareKeys?: string[] | undefined) => boolean; -export declare type StringAnyTuple = [string, any]; -export declare type ArrayOfStringAnyTuple = Array; -export declare type createArrayOfUpdatesType = (oldRecord: Record, newRecord: Record) => ArrayOfStringAnyTuple; export declare const createArrayOfUpdates: createArrayOfUpdatesType; -export declare const serializeFunction: (f: Function) => string; +export declare const serializeFunction: (f?: Function | undefined) => string | undefined; export declare const deserializeFunction: (s: string) => any; diff --git a/dist/lib/utils/store_tools.d.ts b/dist/lib/utils/store_tools.d.ts new file mode 100644 index 0000000..3f122dd --- /dev/null +++ b/dist/lib/utils/store_tools.d.ts @@ -0,0 +1,6 @@ +export declare function store(): { + remove: (key: IDBValidKey) => Promise; + getData: (key: IDBValidKey) => Promise; + setData: (key: IDBValidKey, value: unknown) => Promise; + updateData: (key: IDBValidKey, updater: (oldValue: any) => any) => Promise; +}; diff --git a/dist/queryPlus.es.js b/dist/queryPlus.es.js index 5fdcc86..205ba7c 100644 --- a/dist/queryPlus.es.js +++ b/dist/queryPlus.es.js @@ -18,7 +18,8 @@ var __spreadValues = (a, b) => { }; var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); import { useReducer, useRef, useEffect } from "react"; -const encodedJs = "var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(r,a,l)=>a in r?k(r,a,{enumerable:!0,configurable:!0,writable:!0,value:l}):r[a]=l,f=(r,a)=>{for(var l in a||(a={}))Q.call(a,l)&&B(r,l,a[l]);if(W)for(var l of W(a))v.call(a,l)&&B(r,l,a[l]);return r},G=(r,a)=>j(r,A(a));(function(){"use strict";function r(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function a(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=r(n);return(o,d)=>c.then(i=>d(i.transaction(e,o).objectStore(e)))}let l;function u(){return l||(l=a("keyval-store","keyval")),l}function C(t,e=u()){return e("readonly",n=>r(n.get(t)))}function N(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),r(c.transaction)))}function F(t,e,n=u()){return n("readwrite",c=>new Promise((o,d)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),o(r(c.transaction))}catch(i){d(i)}}}))}function x(t,e=u()){return e("readwrite",n=>(n.delete(t),r(n.transaction)))}const U=(t,e)=>e?t+e<Date.now():!0,S=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,w=(t,e,n={})=>(Object.keys(t).forEach(c=>{let o=e?e+"."+c:c;S(t[c])?w(t[c],o,n):n[o]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>S(e)?w(e):[e]).sort(),D=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},X=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,o=Array.isArray(e)?"array":typeof e;return c!==o?!1:c!=="object"&&c!=="array"?c===o:n&&c==="object"?n.map(d=>t[d]===e[d]).every(d=>d):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=w(t),e=w(e)),JSON.stringify(t)===JSON.stringify(e))},M=t=>new Function(`return ${decodeURI(t)}`)(),L="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",P=typeof window!="undefined"&&window.Blob&&new Blob([atob(L)],{type:"text/javascript;charset=utf-8"});function O(){const t=P&&(window.URL||window.webkitURL).createObjectURL(P);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+L,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const Y=a("usestore-db","usestore-db"),I=t=>x(t,Y),z=t=>C(t,Y),K=(t,e)=>N(t,e,Y),V=(t,e)=>F(t,e,Y),y=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,o=new O;if(e==="cancel"&&(n==null||n.abort(),o==null||o.postMessage({type:"cancel"}),o.terminate()),e==="poll"){let{existingData:d,url:i,options:h,interval:T,maxAttempts:g,compareKeys:m}=t.data;fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p=>{X(d,p,m)?self.postMessage({type:"CACHED",data:p}):(K(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{o==null||o.postMessage({type:e,url:i,options:h,interval:T,maxAttempts:g,existingData:d,compareKeys:m})}),o==null||o.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="fetch"){let{existingData:d,url:i,options:h,maxAge:T,middleware:g,update:m}=t.data;const p=s=>{g&&(s=M(g)(s)),(!d||!X(d,s))&&(self.postMessage({type:"DATA",data:s}),K(i.toString(),{data:s,timestamp:Date.now(),maxAge:T}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let Z=D(h);Z==="DELETE"&&(I(i.toString()),fetch(i,h).then(()=>{m?fetch(m.url,m.options).then(y).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),Z==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw I(i.toString()),new Error("data expired");self.postMessage(X(d,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p).catch(R)),(Z==="PUT"||Z==="POST")&&fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(s=>{m?fetch(m.url,m.options).then(y).then(p).catch(b=>{throw b}):V(i.toString(),b=>{let E=Date.now(),H=S(s)&&S(b==null?void 0:b.data)?f(f({},b.data),s):s;return self.postMessage({type:Z,data:H}),{timestamp:E,maxAge:T,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
"; +import "idb-keyval"; +const encodedJs = "var k=Object.defineProperty,A=Object.defineProperties;var j=Object.getOwnPropertyDescriptors;var B=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var D=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,y=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&D(h,l,d[l]);if(B)for(var l of B(d))v.call(d,l)&&D(h,l,d[l]);return h},T=(h,d)=>A(h,j(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(i,a)=>c.then(r=>a(r.transaction(e,i).objectStore(e)))}let l;function u(){return l||(l=d("keyval-store","keyval")),l}function x(t,e=u()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=u()){return n("readwrite",c=>new Promise((i,a)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),i(h(c.transaction))}catch(r){a(r)}}}))}function F(t,e=u()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function U(){const n=d("usestore-db","usestore-db");return{remove:s=>F(s,n),getData:s=>x(s,n),setData:(s,p)=>C(s,p,n),updateData:(s,p)=>N(s,p,n)}}const L=(t,e)=>e?t+e<Date.now():!0,w=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,g=(t,e,n={})=>(Object.keys(t).forEach(c=>{let i=e?e+"."+c:c;w(t[c])?g(t[c],i,n):n[i]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),P=t=>t.flatMap(e=>w(e)?g(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,i=Array.isArray(e)?"array":typeof e;return c!==i?!1:c!=="object"&&c!=="array"?c===i:n&&c==="object"?n.map(a=>t[a]===e[a]).every(a=>a):(c==="array"&&(t=P(t),e=P(e)),!n&&c==="object"&&(t=g(t),e=g(e)),JSON.stringify(t)===JSON.stringify(e))},O=t=>new Function(`return ${decodeURI(t)}`)(),E="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(E)],{type:"text/javascript;charset=utf-8"});function z(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+E,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:X,getData:K,setData:J,updateData:V}=U(),Z=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},Y=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,i=new z;if(e==="cancel"&&(n==null||n.abort(),i==null||i.postMessage({type:"cancel"}),i.terminate()),e==="poll"){let{existingData:a,url:r,options:s,interval:p,maxAttempts:R,compareKeys:f}=t.data;fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m=>{G(a,m,f)?self.postMessage({type:"CACHED",data:m}):(J(r,{timestamp:Date.now(),data:m}),self.postMessage({type:"DATA",data:m}))}).catch(Y).finally(()=>{i==null||i.postMessage({type:e,url:r,options:s,interval:p,maxAttempts:R,existingData:a,compareKeys:f})}),i==null||i.addEventListener("message",({data:m})=>{self.postMessage(m)})}if(e==="pre-fetch"){let{prefetch:a}=t.data;a.forEach(r=>{K(r.url.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(L(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw X(r.url.toString()),new Error("data expired")}).catch(()=>{fetch(r.url.toString(),y({signal:c},r.options)).then(Z).then(s=>{let p=r.middleware?r.middleware(s):s;J(r.url.toString(),{timestamp:Date.now(),data:p,maxAge:r.maxAge})}).catch(()=>{console.info("no data found")})})})}if(e==="fetch"){let{existingData:a,url:r,options:s,maxAge:p,middleware:R,update:f}=t.data;const m=o=>{R&&(o=O(R)(o)),(!a||!G(a,o))&&(self.postMessage({type:"DATA",data:o}),J(r.toString(),{data:o,timestamp:Date.now(),maxAge:p}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let S=M(s);S==="DELETE"&&(X(r.toString()),fetch(r,s).then(()=>{f?fetch(f.url,f.options).then(Z).then(m).catch(o=>{throw o}):self.postMessage({type:"COMPLETE"})}).catch(Y)),S==="GET"&&(K(r.toString()).then(o=>{if(!o)throw new Error("no value found in db");if(L(o==null?void 0:o.maxAge,o==null?void 0:o.timestamp))throw X(r.toString()),new Error("data expired");self.postMessage(G(a,o==null?void 0:o.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:o==null?void 0:o.data})}).catch(o=>{console.info(o==null?void 0:o.message)}),fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m).catch(Y)),(S==="PUT"||S==="POST")&&fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(o=>{f?fetch(f.url,f.options).then(Z).then(m).catch(b=>{throw b}):V(r.toString(),b=>{let H=Date.now(),W=w(o)&&w(b==null?void 0:b.data)?y(y({},b.data),o):o;return self.postMessage({type:S,data:W}),{timestamp:H,maxAge:p,data:W}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(Y)}})})();
"; const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" }); function WorkerWrapper() { const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob); @@ -55,7 +56,7 @@ function cleanupWorker(worker) { worker == null ? void 0 : worker.terminate(); worker = void 0; } -const serializeFunction = (f) => encodeURI(f.toString()); +const serializeFunction = (f) => f ? encodeURI(f.toString()) : void 0; function useFetch() { const [state, dispatch] = useReducer(reducer, initialState); const workerRef = useRef(); @@ -104,29 +105,35 @@ function useFetch() { break; } }); - let serializedMw = middleware ? serializeFunction(middleware) : void 0; worker == null ? void 0 : worker.postMessage({ type: "fetch", url, options, existingData: state.data, - middleware: serializedMw, + middleware: serializeFunction(middleware), maxAge }); }; - const pollWorker = async ({ - url, - interval = 5e3, - options, - maxAttempts = 100, - compareKeys - }) => { - let worker = workerRef.current; + useEffect(() => { + workerRef.current = new WorkerWrapper(); + return () => { + cleanupWorker(workerRef.current); + }; + }, []); + return __spreadValues({ + fetchWorker + }, state); +} +function usePoll(props) { + var _a, _b; + const [state, dispatch] = useReducer(reducer, initialState); + const worker = useRef(new WorkerWrapper()); + if (props && worker.current) { dispatch({ type: "loading", loading: true }); - worker == null ? void 0 : worker.addEventListener("message", ({ + (_a = worker.current) == null ? void 0 : _a.addEventListener("message", ({ data: { type, data @@ -148,25 +155,36 @@ function useFetch() { error: new Error(type) }); }); - worker == null ? void 0 : worker.postMessage({ - type: "poll", - url, - interval, - maxAttempts, - options, - existingData: state.data, - compareKeys - }); - }; + (_b = worker.current) == null ? void 0 : _b.postMessage(__spreadProps(__spreadValues({ + type: "poll" + }, props), { + existingData: state.data + })); + } useEffect(() => { - workerRef.current = new WorkerWrapper(); return () => { - cleanupWorker(workerRef.current); + cleanupWorker(worker.current); + }; + }, []); + return __spreadValues({}, state); +} +function usePreFetch(prefetch) { + const worker = useRef(new WorkerWrapper()); + useEffect(() => { + var _a; + if (prefetch && worker.current) { + (_a = worker.current) == null ? void 0 : _a.postMessage({ + type: "pre-fetch", + prefetch: prefetch.map((p) => __spreadProps(__spreadValues({}, p), { + middleware: serializeFunction(p.middleware) + })) + }); + } + }, [prefetch, worker.current]); + useEffect(() => { + return () => { + cleanupWorker(worker.current); }; }, []); - return __spreadValues({ - fetchWorker, - pollWorker - }, state); } -export { useFetch }; +export { useFetch, usePoll, usePreFetch }; diff --git a/dist/queryPlus.umd.js b/dist/queryPlus.umd.js index cb9dc2e..679c803 100644 --- a/dist/queryPlus.umd.js +++ b/dist/queryPlus.umd.js @@ -1 +1 @@ -(function(Z,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react")):typeof define=="function"&&define.amd?define(["exports","react"],d):(Z=typeof globalThis!="undefined"?globalThis:Z||self,d(Z.queryPlus={},Z.React))})(this,function(Z,d){"use strict";var u=Object.defineProperty,K=Object.defineProperties;var H=Object.getOwnPropertyDescriptors;var U=Object.getOwnPropertySymbols;var y=Object.prototype.hasOwnProperty,L=Object.prototype.propertyIsEnumerable;var t=(Z,d,a)=>d in Z?u(Z,d,{enumerable:!0,configurable:!0,writable:!0,value:a}):Z[d]=a,p=(Z,d)=>{for(var a in d||(d={}))y.call(d,a)&&t(Z,a,d[a]);if(U)for(var a of U(d))L.call(d,a)&&t(Z,a,d[a]);return Z},m=(Z,d)=>K(Z,H(d));const a="var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(r,a,l)=>a in r?k(r,a,{enumerable:!0,configurable:!0,writable:!0,value:l}):r[a]=l,f=(r,a)=>{for(var l in a||(a={}))Q.call(a,l)&&B(r,l,a[l]);if(W)for(var l of W(a))v.call(a,l)&&B(r,l,a[l]);return r},G=(r,a)=>j(r,A(a));(function(){"use strict";function r(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function a(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=r(n);return(o,d)=>c.then(i=>d(i.transaction(e,o).objectStore(e)))}let l;function u(){return l||(l=a("keyval-store","keyval")),l}function C(t,e=u()){return e("readonly",n=>r(n.get(t)))}function N(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),r(c.transaction)))}function F(t,e,n=u()){return n("readwrite",c=>new Promise((o,d)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),o(r(c.transaction))}catch(i){d(i)}}}))}function x(t,e=u()){return e("readwrite",n=>(n.delete(t),r(n.transaction)))}const U=(t,e)=>e?t+e<Date.now():!0,S=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,w=(t,e,n={})=>(Object.keys(t).forEach(c=>{let o=e?e+"."+c:c;S(t[c])?w(t[c],o,n):n[o]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>S(e)?w(e):[e]).sort(),D=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},X=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,o=Array.isArray(e)?"array":typeof e;return c!==o?!1:c!=="object"&&c!=="array"?c===o:n&&c==="object"?n.map(d=>t[d]===e[d]).every(d=>d):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=w(t),e=w(e)),JSON.stringify(t)===JSON.stringify(e))},M=t=>new Function(`return ${decodeURI(t)}`)(),L="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",P=typeof window!="undefined"&&window.Blob&&new Blob([atob(L)],{type:"text/javascript;charset=utf-8"});function O(){const t=P&&(window.URL||window.webkitURL).createObjectURL(P);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+L,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const Y=a("usestore-db","usestore-db"),I=t=>x(t,Y),z=t=>C(t,Y),K=(t,e)=>N(t,e,Y),V=(t,e)=>F(t,e,Y),y=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,o=new O;if(e==="cancel"&&(n==null||n.abort(),o==null||o.postMessage({type:"cancel"}),o.terminate()),e==="poll"){let{existingData:d,url:i,options:h,interval:T,maxAttempts:g,compareKeys:m}=t.data;fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p=>{X(d,p,m)?self.postMessage({type:"CACHED",data:p}):(K(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{o==null||o.postMessage({type:e,url:i,options:h,interval:T,maxAttempts:g,existingData:d,compareKeys:m})}),o==null||o.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="fetch"){let{existingData:d,url:i,options:h,maxAge:T,middleware:g,update:m}=t.data;const p=s=>{g&&(s=M(g)(s)),(!d||!X(d,s))&&(self.postMessage({type:"DATA",data:s}),K(i.toString(),{data:s,timestamp:Date.now(),maxAge:T}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let Z=D(h);Z==="DELETE"&&(I(i.toString()),fetch(i,h).then(()=>{m?fetch(m.url,m.options).then(y).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),Z==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw I(i.toString()),new Error("data expired");self.postMessage(X(d,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(p).catch(R)),(Z==="PUT"||Z==="POST")&&fetch(i,h?G(f({},h),{signal:c}):{signal:c}).then(y).then(s=>{m?fetch(m.url,m.options).then(y).then(p).catch(b=>{throw b}):V(i.toString(),b=>{let E=Date.now(),H=S(s)&&S(b==null?void 0:b.data)?f(f({},b.data),s):s;return self.postMessage({type:Z,data:H}),{timestamp:E,maxAge:T,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
",N=typeof window!="undefined"&&window.Blob&&new Blob([atob(a)],{type:"text/javascript;charset=utf-8"});function o(){const l=N&&(window.URL||window.webkitURL).createObjectURL(N);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+a,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const S={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function h(l,W){switch(W.type){case"pre-load":return m(p({},l),{data:W.data,loading:!1,preload:!0,error:void 0});case"data":return m(p({},l),{data:W.data,loading:!1,preload:!1,error:void 0});case"error":return m(p({},l),{error:W.error,loading:!1,preload:!1});case"loading":return m(p({},l),{loading:W.loading});default:return l}}const s=24*60*60*1e3;function J(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const F=l=>encodeURI(l.toString());function X(){const[l,W]=d.useReducer(h,S),e=d.useRef(),T=async({url:R,options:n,maxAge:i=s,middleware:G})=>{let V=e.current;W({type:"loading",loading:!0}),V==null||V.addEventListener("message",({data:{type:c,data:Y}})=>{switch(c){case"CACHED":case"COMPLETE":W({type:"loading",loading:!1});break;case"DATA":W({type:"data",data:Y});break;case"PRE_LOAD":W({type:"pre-load",data:Y});break;default:W({type:"error",error:new Error(c)});break}});let b=G?F(G):void 0;V==null||V.postMessage({type:"fetch",url:R,options:n,existingData:l.data,middleware:b,maxAge:i})},k=async({url:R,interval:n=5e3,options:i,maxAttempts:G=100,compareKeys:V})=>{let b=e.current;W({type:"loading",loading:!0}),b==null||b.addEventListener("message",({data:{type:c,data:Y}})=>{W(c==="COMPLETE"?{type:"loading",loading:!1}:c==="DATA"?{type:"data",data:Y}:{type:"error",error:new Error(c)})}),b==null||b.postMessage({type:"poll",url:R,interval:n,maxAttempts:G,options:i,existingData:l.data,compareKeys:V})};return d.useEffect(()=>(e.current=new o,()=>{J(e.current)}),[]),p({fetchWorker:T,pollWorker:k},l)}Z.useFetch=X,Object.defineProperties(Z,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); +(function(Z,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react"),require("idb-keyval")):typeof define=="function"&&define.amd?define(["exports","react","idb-keyval"],d):(Z=typeof globalThis!="undefined"?globalThis:Z||self,d(Z.queryPlus={},Z.React))})(this,function(Z,d){"use strict";var F=Object.defineProperty,y=Object.defineProperties;var J=Object.getOwnPropertyDescriptors;var S=Object.getOwnPropertySymbols;var x=Object.prototype.hasOwnProperty,I=Object.prototype.propertyIsEnumerable;var X=(Z,d,W)=>d in Z?F(Z,d,{enumerable:!0,configurable:!0,writable:!0,value:W}):Z[d]=W,G=(Z,d)=>{for(var W in d||(d={}))x.call(d,W)&&X(Z,W,d[W]);if(S)for(var W of S(d))I.call(d,W)&&X(Z,W,d[W]);return Z},c=(Z,d)=>y(Z,J(d));const W="var k=Object.defineProperty,A=Object.defineProperties;var j=Object.getOwnPropertyDescriptors;var B=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var D=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,y=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&D(h,l,d[l]);if(B)for(var l of B(d))v.call(d,l)&&D(h,l,d[l]);return h},T=(h,d)=>A(h,j(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(i,a)=>c.then(r=>a(r.transaction(e,i).objectStore(e)))}let l;function u(){return l||(l=d("keyval-store","keyval")),l}function x(t,e=u()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=u()){return n("readwrite",c=>new Promise((i,a)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),i(h(c.transaction))}catch(r){a(r)}}}))}function F(t,e=u()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function U(){const n=d("usestore-db","usestore-db");return{remove:s=>F(s,n),getData:s=>x(s,n),setData:(s,p)=>C(s,p,n),updateData:(s,p)=>N(s,p,n)}}const L=(t,e)=>e?t+e<Date.now():!0,w=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,g=(t,e,n={})=>(Object.keys(t).forEach(c=>{let i=e?e+"."+c:c;w(t[c])?g(t[c],i,n):n[i]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),P=t=>t.flatMap(e=>w(e)?g(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,i=Array.isArray(e)?"array":typeof e;return c!==i?!1:c!=="object"&&c!=="array"?c===i:n&&c==="object"?n.map(a=>t[a]===e[a]).every(a=>a):(c==="array"&&(t=P(t),e=P(e)),!n&&c==="object"&&(t=g(t),e=g(e)),JSON.stringify(t)===JSON.stringify(e))},O=t=>new Function(`return ${decodeURI(t)}`)(),E="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(E)],{type:"text/javascript;charset=utf-8"});function z(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+E,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:X,getData:K,setData:J,updateData:V}=U(),Z=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},Y=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,i=new z;if(e==="cancel"&&(n==null||n.abort(),i==null||i.postMessage({type:"cancel"}),i.terminate()),e==="poll"){let{existingData:a,url:r,options:s,interval:p,maxAttempts:R,compareKeys:f}=t.data;fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m=>{G(a,m,f)?self.postMessage({type:"CACHED",data:m}):(J(r,{timestamp:Date.now(),data:m}),self.postMessage({type:"DATA",data:m}))}).catch(Y).finally(()=>{i==null||i.postMessage({type:e,url:r,options:s,interval:p,maxAttempts:R,existingData:a,compareKeys:f})}),i==null||i.addEventListener("message",({data:m})=>{self.postMessage(m)})}if(e==="pre-fetch"){let{prefetch:a}=t.data;a.forEach(r=>{K(r.url.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(L(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw X(r.url.toString()),new Error("data expired")}).catch(()=>{fetch(r.url.toString(),y({signal:c},r.options)).then(Z).then(s=>{let p=r.middleware?r.middleware(s):s;J(r.url.toString(),{timestamp:Date.now(),data:p,maxAge:r.maxAge})}).catch(()=>{console.info("no data found")})})})}if(e==="fetch"){let{existingData:a,url:r,options:s,maxAge:p,middleware:R,update:f}=t.data;const m=o=>{R&&(o=O(R)(o)),(!a||!G(a,o))&&(self.postMessage({type:"DATA",data:o}),J(r.toString(),{data:o,timestamp:Date.now(),maxAge:p}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let S=M(s);S==="DELETE"&&(X(r.toString()),fetch(r,s).then(()=>{f?fetch(f.url,f.options).then(Z).then(m).catch(o=>{throw o}):self.postMessage({type:"COMPLETE"})}).catch(Y)),S==="GET"&&(K(r.toString()).then(o=>{if(!o)throw new Error("no value found in db");if(L(o==null?void 0:o.maxAge,o==null?void 0:o.timestamp))throw X(r.toString()),new Error("data expired");self.postMessage(G(a,o==null?void 0:o.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:o==null?void 0:o.data})}).catch(o=>{console.info(o==null?void 0:o.message)}),fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m).catch(Y)),(S==="PUT"||S==="POST")&&fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(o=>{f?fetch(f.url,f.options).then(Z).then(m).catch(b=>{throw b}):V(r.toString(),b=>{let H=Date.now(),W=w(o)&&w(b==null?void 0:b.data)?y(y({},b.data),o):o;return self.postMessage({type:S,data:W}),{timestamp:H,maxAge:p,data:W}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(Y)}})})();
",h=typeof window!="undefined"&&window.Blob&&new Blob([atob(W)],{type:"text/javascript;charset=utf-8"});function a(){const l=h&&(window.URL||window.webkitURL).createObjectURL(h);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+W,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const T={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function t(l,b){switch(b.type){case"pre-load":return c(G({},l),{data:b.data,loading:!1,preload:!0,error:void 0});case"data":return c(G({},l),{data:b.data,loading:!1,preload:!1,error:void 0});case"error":return c(G({},l),{error:b.error,loading:!1,preload:!1});case"loading":return c(G({},l),{loading:b.loading});default:return l}}const k=24*60*60*1e3;function i(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const u=l=>l?encodeURI(l.toString()):void 0;function N(){const[l,b]=d.useReducer(t,T),p=d.useRef(),e=async({url:n,options:Y,maxAge:m=k,middleware:R})=>{let V=p.current;b({type:"loading",loading:!0}),V==null||V.addEventListener("message",({data:{type:o,data:U}})=>{switch(o){case"CACHED":case"COMPLETE":b({type:"loading",loading:!1});break;case"DATA":b({type:"data",data:U});break;case"PRE_LOAD":b({type:"pre-load",data:U});break;default:b({type:"error",error:new Error(o)});break}}),V==null||V.postMessage({type:"fetch",url:n,options:Y,existingData:l.data,middleware:u(R),maxAge:m})};return d.useEffect(()=>(p.current=new a,()=>{i(p.current)}),[]),G({fetchWorker:e},l)}function s(l){var n,Y;const[b,p]=d.useReducer(t,T),e=d.useRef(new a);return l&&e.current&&(p({type:"loading",loading:!0}),(n=e.current)==null||n.addEventListener("message",({data:{type:m,data:R}})=>{p(m==="COMPLETE"?{type:"loading",loading:!1}:m==="DATA"?{type:"data",data:R}:{type:"error",error:new Error(m)})}),(Y=e.current)==null||Y.postMessage(c(G({type:"poll"},l),{existingData:b.data}))),d.useEffect(()=>()=>{i(e.current)},[]),G({},b)}function K(l){const b=d.useRef(new a);d.useEffect(()=>{var p;l&&b.current&&((p=b.current)==null||p.postMessage({type:"pre-fetch",prefetch:l.map(e=>c(G({},e),{middleware:u(e.middleware)}))}))},[l,b.current]),d.useEffect(()=>()=>{i(b.current)},[])}Z.useFetch=N,Z.usePoll=s,Z.usePreFetch=K,Object.defineProperties(Z,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); diff --git a/src/lib/hooks/useFetch.tsx b/src/lib/hooks/useFetch.tsx index e467b1e..ca4ee6a 100644 --- a/src/lib/hooks/useFetch.tsx +++ b/src/lib/hooks/useFetch.tsx @@ -1,56 +1,17 @@ import { useRef, useEffect, useReducer } from "react"; import FetchWorker from '../workers/fetch_worker.js?worker&inline' -import { cleanupWorker, DAY, initialState, reducer, serializeFunction, UnknownDataResponseType } from "../utils"; +import { cleanupWorker, DAY, initialState, reducer, serializeFunction } from "../utils"; +import type { FetchWorkerProps, WorkerResponseType } from "../types"; -type WorkerResponseType = MessageEvent<{ - type: string; - data?: UnknownDataResponseType -}> -export interface FetchWorkerProps { - options?: RequestInit | undefined - maxAge?: number - middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType - url: RequestInfo | URL - /* - update will be fetched after the response is received. - This is useful for updating after POST PUT or DELETE, - where the api doesn't return all the data and the GET - endpoint is different. - */ - update?: { - url: RequestInfo | URL, - options?: RequestInit | undefined - } -} -export interface PollWorkerProps { - url: RequestInfo | URL - interval: number, - options?: RequestInit | undefined - maxAttempts?: number, - existingData?: number, - compareKeys?: string[] -} -/** - * useFetch is a React hook that can be initialized with no params. - * @example const { data, error, loading, fetchWorker } = useFetch() - * fetchWorker({ - * url: 'https://swapi.dev/api/people/1/', - * middleware: (d:Record) => { let keys = Object.keys(d); return {[keys[0]]: d[keys[0]], [keys[1]]: d[keys[1]]}} - * }); - * - * - */ export function useFetch() { const [state, dispatch] = useReducer(reducer, initialState); const workerRef = useRef(); - const fetchWorker = async ({ url, options, maxAge = DAY, middleware }: FetchWorkerProps) => { let worker = workerRef.current; dispatch({ type: 'loading', loading: true }); - worker?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { switch (type) { case 'CACHED': @@ -68,18 +29,8 @@ export function useFetch() { break; } }); - let serializedMw = middleware ? serializeFunction(middleware) : undefined - worker?.postMessage({ type: 'fetch', url, options, existingData: state.data, middleware: serializedMw, maxAge }); - } - const pollWorker = async ({ url, interval = 5000, options, maxAttempts = 100, compareKeys }: PollWorkerProps) => { - let worker = workerRef.current; - dispatch({ type: 'loading', loading: true }) - worker?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { - if(type === 'COMPLETE') dispatch({ type: 'loading', loading: false }); - else if(type === 'DATA') dispatch({ type: 'data', data }); - else dispatch({ type: 'error', error: new Error(type) }); - }) - worker?.postMessage({ type: 'poll', url, interval, maxAttempts, options, existingData: state.data, compareKeys }); + + worker?.postMessage({ type: 'fetch', url, options, existingData: state.data, middleware: serializeFunction(middleware), maxAge }); } useEffect(() => { @@ -89,6 +40,6 @@ export function useFetch() { } }, []); - return { fetchWorker, pollWorker, ...state! }; + return { fetchWorker, ...state! }; }; diff --git a/src/lib/hooks/usePoll.tsx b/src/lib/hooks/usePoll.tsx new file mode 100644 index 0000000..7e44f2f --- /dev/null +++ b/src/lib/hooks/usePoll.tsx @@ -0,0 +1,26 @@ +import { useRef, useEffect, useReducer } from "react"; + +import FetchWorker from '../workers/fetch_worker.js?worker&inline' +import { cleanupWorker, initialState, reducer } from "../utils"; + +import type { WorkerResponseType, PollWorkerProps } from "../types"; + +export function usePoll(props: PollWorkerProps) { + const [state, dispatch] = useReducer(reducer, initialState); + const worker = useRef(new FetchWorker()); + if(props && worker.current) { + dispatch({ type: 'loading', loading: true }) + worker.current?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { + if(type === 'COMPLETE') dispatch({ type: 'loading', loading: false }); + else if(type === 'DATA') dispatch({ type: 'data', data }); + else dispatch({ type: 'error', error: new Error(type) }); + }) + worker.current?.postMessage({ type: 'poll', ...props, existingData: state.data }); + } + useEffect(() => { + return () => { + cleanupWorker(worker.current); + } + }, []); + return { ...state! }; +}; diff --git a/src/lib/hooks/usePreFetch.tsx b/src/lib/hooks/usePreFetch.tsx new file mode 100644 index 0000000..223a720 --- /dev/null +++ b/src/lib/hooks/usePreFetch.tsx @@ -0,0 +1,24 @@ +import { useRef, useEffect } from "react"; + +import FetchWorker from '../workers/fetch_worker.js?worker&inline' +import { cleanupWorker, serializeFunction } from "../utils"; + +import type { FetchWorkerBaseRequestType } from "../types"; + + +export function usePreFetch(prefetch?: Array) { + const worker = useRef(new FetchWorker()); + useEffect(() => { + if(prefetch && worker.current) { + worker.current?.postMessage({ type: 'pre-fetch', prefetch: prefetch.map(p => ({...p, middleware: serializeFunction(p.middleware)})) }); + } + }, [prefetch, worker.current]); + + useEffect(() => { + // worker.current = new FetchWorker() + return () => { + cleanupWorker(worker.current); + } + }, []); +}; + diff --git a/src/lib/hooks/useStore.tsx b/src/lib/hooks/useStore.tsx new file mode 100644 index 0000000..c2743ce --- /dev/null +++ b/src/lib/hooks/useStore.tsx @@ -0,0 +1,19 @@ +import { useRef, useEffect, useState } from "react"; + +import StoreWorker from '../workers/store_worker.js?worker&inline' +import { cleanupWorker } from "../utils"; + +import type { WorkerResponseType } from "../types"; + +export function useData(key: string) { + const [data, setData] = useState() + const worker = useRef(new StoreWorker()); + // build the postMessage functions + + useEffect(() => { + return () => { + cleanupWorker(worker.current); + } + }, []); + return [data]; +}; diff --git a/src/lib/index.ts b/src/lib/index.ts index 546d122..3128e79 100644 --- a/src/lib/index.ts +++ b/src/lib/index.ts @@ -1 +1,3 @@ -export {useFetch} from './hooks/useFetch'; \ No newline at end of file +export {useFetch} from './hooks/useFetch'; +export {usePoll} from './hooks/usePoll'; +export {usePreFetch} from './hooks/usePreFetch'; \ No newline at end of file diff --git a/src/lib/types.d.ts b/src/lib/types.d.ts new file mode 100644 index 0000000..f87e456 --- /dev/null +++ b/src/lib/types.d.ts @@ -0,0 +1,39 @@ +export type StringAnyTuple = [string, any] +export type ArrayOfStringAnyTuple = Array +export type createArrayOfUpdatesType = (oldRecord: Record, newRecord: Record) => ArrayOfStringAnyTuple + +export type WorkerResponseType = MessageEvent<{ + type: string; + data?: UnknownDataResponseType +}> +export interface FetchWorkerBaseRequestType { + options?: RequestInit | undefined + maxAge?: number + middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType + url: RequestInfo | URL +} + +export interface FetchWorkerProps extends FetchWorkerBaseRequestType { + /* + update will be fetched after the response is received. + This is useful for updating after POST PUT or DELETE, + where the api doesn't return all the data and the GET + endpoint is different. + */ + update?: { + url: RequestInfo | URL, + options?: RequestInit | undefined + } +} +export interface PollWorkerProps { + url: RequestInfo | URL + interval: number, + options?: RequestInit | undefined + maxAttempts?: number, + existingData?: number, + compareKeys?: string[] +} + +export type ValueType = { timestamp: number; maxAge: number; data: any }; + + diff --git a/src/lib/utils/index.ts b/src/lib/utils/index.ts index 5b9a487..1937155 100644 --- a/src/lib/utils/index.ts +++ b/src/lib/utils/index.ts @@ -1,5 +1,9 @@ +import type { createArrayOfUpdatesType, ArrayOfStringAnyTuple, StringAnyTuple } from "../types"; + export * from "./state_tools"; +export * from "./store_tools"; export * from "./poll"; + export const DAY = 24 * 60 * 60 * 1000; export function cleanupWorker(worker: Worker | undefined) { @@ -72,9 +76,7 @@ export const isMatch = ( }; -export type StringAnyTuple = [string, any] -export type ArrayOfStringAnyTuple = Array -export type createArrayOfUpdatesType = (oldRecord: Record, newRecord: Record) => ArrayOfStringAnyTuple + // compare records two entries deep and return an array of tuples export const createArrayOfUpdates:createArrayOfUpdatesType = (oldRecord, newRecord) => { let changeRegister: ArrayOfStringAnyTuple = Object.entries(oldRecord) @@ -94,5 +96,5 @@ export const createArrayOfUpdates:createArrayOfUpdatesType = (oldRecord, newReco return changeRegister; } -export const serializeFunction = (f: Function) => encodeURI(f.toString()); +export const serializeFunction = (f?: Function) => f ? encodeURI(f.toString()) : undefined; export const deserializeFunction = (s: string) => new Function(`return ${decodeURI(s)}`)(); \ No newline at end of file diff --git a/src/lib/utils/store_tools.ts b/src/lib/utils/store_tools.ts new file mode 100644 index 0000000..8c56994 --- /dev/null +++ b/src/lib/utils/store_tools.ts @@ -0,0 +1,20 @@ +import { del, get, set, update, createStore } from "idb-keyval"; + +import type { UseStore } from "idb-keyval"; + + +export function store () { + const DB_NAME = "usestore-db"; + const DB_STORE = "usestore-db"; + const store: UseStore = createStore(DB_NAME, DB_STORE); + const remove = (key: IDBValidKey) => del(key, store); + const getData = (key: IDBValidKey) => get(key, store); + const setData = (key: IDBValidKey, value: unknown) => set(key, value, store); + const updateData = (key: IDBValidKey, updater: (oldValue: any) => any) => update(key, updater, store); + return { + remove, + getData, + setData, + updateData, + }; +} \ No newline at end of file diff --git a/src/lib/workers/fetch_worker.ts b/src/lib/workers/fetch_worker.ts index 9b17bd6..d110c13 100644 --- a/src/lib/workers/fetch_worker.ts +++ b/src/lib/workers/fetch_worker.ts @@ -1,32 +1,18 @@ -import { del, get, set, update, createStore } from "idb-keyval"; import { deserializeFunction, methodType, isMatch, dataExpired, isObject, - type UnknownDataResponseType, + store, } from "../utils"; -import type { UseStore } from "idb-keyval"; import PollWorker from "./polling_worker.js?worker&inline"; -type ValueType = { timestamp: number; maxAge: number; data: any }; -type WorkerResponseType = MessageEvent< - { - type: string; - data?: UnknownDataResponseType; - } ->; +import type { WorkerResponseType, ValueType, FetchWorkerBaseRequestType } from "../types"; + +const { remove, getData, setData, updateData } = store(); -const DB_NAME = "usestore-db"; -const DB_STORE = "usestore-db"; -const store: UseStore = createStore(DB_NAME, DB_STORE); -const remove = (key: IDBValidKey) => del(key, store); -const getData = (key: IDBValidKey) => get(key, store); -const setData = (key: IDBValidKey, value: unknown) => set(key, value, store); -const updateData = (key: IDBValidKey, updater: (oldValue: any) => any) => - update(key, updater, store); const handleResponse = (response: Response) => { if (!response.ok || response.status === 404) { throw new Error(`HTTP error! Status: ${response.status}`); @@ -94,6 +80,32 @@ self.addEventListener( ); } + if (type === "pre-fetch") { + let { prefetch } = event.data; + prefetch.forEach((d: FetchWorkerBaseRequestType) => { + getData(d.url.toString()) + .then( + (value: ValueType) => { + if (!value) { + throw new Error("no value found in db"); + } + if (dataExpired(value?.maxAge, value?.timestamp)) { + remove(d.url.toString()); + throw new Error("data expired"); + } + }, + ) + .catch(() => { + fetch(d.url.toString(), { signal, ...d.options! }).then( + handleResponse, + ).then(data => { + let x = d.middleware ? d.middleware(data) : data; + setData(d.url.toString(), { timestamp: Date.now(), data: x, maxAge: d.maxAge! }); + }).catch(() => { console.info("no data found") }); + }); + }) + } + if (type === "fetch") { let { existingData, diff --git a/src/lib/workers/store_worker.ts b/src/lib/workers/store_worker.ts new file mode 100644 index 0000000..9f4e1ed --- /dev/null +++ b/src/lib/workers/store_worker.ts @@ -0,0 +1,79 @@ +import { dataExpired, store } from "../utils"; + +const { remove, getData, setData, updateData } = store(); + +self.addEventListener( + "message", + (event) => { + let { + type, + url, + maxAge, + newData + } = event.data; + if(type === "get") { + getData(url).then(data => { + if(dataExpired(data, maxAge)) { + self.postMessage({ + type: "expired", + url, + }); + } else { + self.postMessage({ + type: "get-success", + url, + data, + }); + } + }).catch((error) => { + self.postMessage({ + type: "error", + error, + url, + }); + }) + } + if(type === "delete") { + remove(url).then(() => { + self.postMessage({ + type: "delete-success", + url, + }); + }).catch((error) => { + self.postMessage({ + type: "error", + error, + url, + }); + }) + } + if(type === "set") { + setData(url, newData).then(() => { + self.postMessage({ + type: "set-success", + url, + }); + }).catch((error) => { + self.postMessage({ + type: "error", + error, + url, + }); + }) + } + if(type === "update") { + updateData(url, newData).then(() => { + self.postMessage({ + type: "update-success", + url, + }); + }).catch((error) => { + self.postMessage({ + type: "error", + error, + url, + }); + }) + } + }, +); From 6eb505b191fa3513e45eb99ea48708ab34873011 Mon Sep 17 00:00:00 2001 From: Rod Lewis Date: Mon, 27 Jun 2022 20:51:28 +0800 Subject: [PATCH 4/5] fix preFetch --- dist/lib/types.d.ts | 3 ++ dist/lib/utils/index.d.ts | 2 +- dist/queryPlus.es.js | 71 +++++++++++++++++---------------- dist/queryPlus.umd.js | 2 +- src/lib/hooks/usePoll.tsx | 21 +++++----- src/lib/hooks/usePreFetch.tsx | 2 +- src/lib/types.d.ts | 3 ++ src/lib/utils/index.ts | 2 +- src/lib/workers/fetch_worker.ts | 38 ++++++------------ 9 files changed, 71 insertions(+), 73 deletions(-) diff --git a/dist/lib/types.d.ts b/dist/lib/types.d.ts index f87e456..57fb1a9 100644 --- a/dist/lib/types.d.ts +++ b/dist/lib/types.d.ts @@ -12,6 +12,9 @@ export interface FetchWorkerBaseRequestType { middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType url: RequestInfo | URL } +export interface FetchWorkerRequestType extends FetchWorkerBaseRequestType { + middleware?: string +} export interface FetchWorkerProps extends FetchWorkerBaseRequestType { /* diff --git a/dist/lib/utils/index.d.ts b/dist/lib/utils/index.d.ts index e8d32f0..90b50c4 100644 --- a/dist/lib/utils/index.d.ts +++ b/dist/lib/utils/index.d.ts @@ -12,4 +12,4 @@ export declare const methodType: (options: RequestInit | undefined) => string; export declare const isMatch: (a: unknown, b: unknown, compareKeys?: string[] | undefined) => boolean; export declare const createArrayOfUpdates: createArrayOfUpdatesType; export declare const serializeFunction: (f?: Function | undefined) => string | undefined; -export declare const deserializeFunction: (s: string) => any; +export declare const deserializeFunction: (s?: string | undefined) => any; diff --git a/dist/queryPlus.es.js b/dist/queryPlus.es.js index 205ba7c..772e9f0 100644 --- a/dist/queryPlus.es.js +++ b/dist/queryPlus.es.js @@ -19,7 +19,7 @@ var __spreadValues = (a, b) => { var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); import { useReducer, useRef, useEffect } from "react"; import "idb-keyval"; -const encodedJs = "var k=Object.defineProperty,A=Object.defineProperties;var j=Object.getOwnPropertyDescriptors;var B=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var D=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,y=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&D(h,l,d[l]);if(B)for(var l of B(d))v.call(d,l)&&D(h,l,d[l]);return h},T=(h,d)=>A(h,j(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(i,a)=>c.then(r=>a(r.transaction(e,i).objectStore(e)))}let l;function u(){return l||(l=d("keyval-store","keyval")),l}function x(t,e=u()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=u()){return n("readwrite",c=>new Promise((i,a)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),i(h(c.transaction))}catch(r){a(r)}}}))}function F(t,e=u()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function U(){const n=d("usestore-db","usestore-db");return{remove:s=>F(s,n),getData:s=>x(s,n),setData:(s,p)=>C(s,p,n),updateData:(s,p)=>N(s,p,n)}}const L=(t,e)=>e?t+e<Date.now():!0,w=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,g=(t,e,n={})=>(Object.keys(t).forEach(c=>{let i=e?e+"."+c:c;w(t[c])?g(t[c],i,n):n[i]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),P=t=>t.flatMap(e=>w(e)?g(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,i=Array.isArray(e)?"array":typeof e;return c!==i?!1:c!=="object"&&c!=="array"?c===i:n&&c==="object"?n.map(a=>t[a]===e[a]).every(a=>a):(c==="array"&&(t=P(t),e=P(e)),!n&&c==="object"&&(t=g(t),e=g(e)),JSON.stringify(t)===JSON.stringify(e))},O=t=>new Function(`return ${decodeURI(t)}`)(),E="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(E)],{type:"text/javascript;charset=utf-8"});function z(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+E,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:X,getData:K,setData:J,updateData:V}=U(),Z=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},Y=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,i=new z;if(e==="cancel"&&(n==null||n.abort(),i==null||i.postMessage({type:"cancel"}),i.terminate()),e==="poll"){let{existingData:a,url:r,options:s,interval:p,maxAttempts:R,compareKeys:f}=t.data;fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m=>{G(a,m,f)?self.postMessage({type:"CACHED",data:m}):(J(r,{timestamp:Date.now(),data:m}),self.postMessage({type:"DATA",data:m}))}).catch(Y).finally(()=>{i==null||i.postMessage({type:e,url:r,options:s,interval:p,maxAttempts:R,existingData:a,compareKeys:f})}),i==null||i.addEventListener("message",({data:m})=>{self.postMessage(m)})}if(e==="pre-fetch"){let{prefetch:a}=t.data;a.forEach(r=>{K(r.url.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(L(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw X(r.url.toString()),new Error("data expired")}).catch(()=>{fetch(r.url.toString(),y({signal:c},r.options)).then(Z).then(s=>{let p=r.middleware?r.middleware(s):s;J(r.url.toString(),{timestamp:Date.now(),data:p,maxAge:r.maxAge})}).catch(()=>{console.info("no data found")})})})}if(e==="fetch"){let{existingData:a,url:r,options:s,maxAge:p,middleware:R,update:f}=t.data;const m=o=>{R&&(o=O(R)(o)),(!a||!G(a,o))&&(self.postMessage({type:"DATA",data:o}),J(r.toString(),{data:o,timestamp:Date.now(),maxAge:p}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let S=M(s);S==="DELETE"&&(X(r.toString()),fetch(r,s).then(()=>{f?fetch(f.url,f.options).then(Z).then(m).catch(o=>{throw o}):self.postMessage({type:"COMPLETE"})}).catch(Y)),S==="GET"&&(K(r.toString()).then(o=>{if(!o)throw new Error("no value found in db");if(L(o==null?void 0:o.maxAge,o==null?void 0:o.timestamp))throw X(r.toString()),new Error("data expired");self.postMessage(G(a,o==null?void 0:o.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:o==null?void 0:o.data})}).catch(o=>{console.info(o==null?void 0:o.message)}),fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m).catch(Y)),(S==="PUT"||S==="POST")&&fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(o=>{f?fetch(f.url,f.options).then(Z).then(m).catch(b=>{throw b}):V(r.toString(),b=>{let H=Date.now(),W=w(o)&&w(b==null?void 0:b.data)?y(y({},b.data),o):o;return self.postMessage({type:S,data:W}),{timestamp:H,maxAge:p,data:W}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(Y)}})})();
"; +const encodedJs = "var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,Z=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&B(h,l,d[l]);if(W)for(var l of W(d))v.call(d,l)&&B(h,l,d[l]);return h},T=(h,d)=>j(h,A(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(a,r)=>c.then(i=>r(i.transaction(e,a).objectStore(e)))}let l;function w(){return l||(l=d("keyval-store","keyval")),l}function D(t,e=w()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=w()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=w()){return n("readwrite",c=>new Promise((a,r)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),a(h(c.transaction))}catch(i){r(i)}}}))}function F(t,e=w()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function x(){const n=d("usestore-db","usestore-db");return{remove:o=>F(o,n),getData:o=>D(o,n),setData:(o,f)=>C(o,f,n),updateData:(o,f)=>N(o,f,n)}}const U=(t,e)=>e?t+e<Date.now():!0,g=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,Y=(t,e,n={})=>(Object.keys(t).forEach(c=>{let a=e?e+"."+c:c;g(t[c])?Y(t[c],a,n):n[a]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>g(e)?Y(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,a=Array.isArray(e)?"array":typeof e;return c!==a?!1:c!=="object"&&c!=="array"?c===a:n&&c==="object"?n.map(r=>t[r]===e[r]).every(r=>r):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=Y(t),e=Y(e)),JSON.stringify(t)===JSON.stringify(e))},L=t=>t?new Function(`return ${decodeURI(t)}`)():e=>e,P="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(P)],{type:"text/javascript;charset=utf-8"});function O(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+P,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:E,getData:z,setData:X,updateData:V}=x(),S=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,a=new O;if(e==="cancel"&&(n==null||n.abort(),a==null||a.postMessage({type:"cancel"}),a.terminate()),e==="poll"){let{existingData:r,url:i,options:o,interval:f,maxAttempts:u,compareKeys:m}=t.data;fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p=>{G(r,p,m)?self.postMessage({type:"CACHED",data:p}):(X(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{a==null||a.postMessage({type:e,url:i,options:o,interval:f,maxAttempts:u,existingData:r,compareKeys:m})}),a==null||a.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="pre-fetch"){let{prefetch:r}=t.data;r.forEach(({middleware:i,url:o,options:f,maxAge:u})=>{let m=L(i);fetch(o.toString(),Z({signal:c},f)).then(S).then(p=>{X(o.toString(),{timestamp:Date.now(),data:m(p),maxAge:u}).then(()=>{console.log(`saved prefetch ${o}`)}).catch(b=>{console.log(`error saving prefetch ${o}`,b)})}).catch(()=>{console.info("no data found")})})}if(e==="fetch"){let{existingData:r,url:i,options:o,maxAge:f,middleware:u,update:m}=t.data;const p=s=>{s=L(u)(s),(!r||!G(r,s))&&(self.postMessage({type:"DATA",data:s}),X(i.toString(),{data:s,timestamp:Date.now(),maxAge:f}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let b=M(o);b==="DELETE"&&(E(i.toString()),fetch(i,o).then(()=>{m?fetch(m.url,m.options).then(S).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),b==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw E(i.toString()),new Error("data expired");self.postMessage(G(r,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p).catch(R)),(b==="PUT"||b==="POST")&&fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(s=>{m?fetch(m.url,m.options).then(S).then(p).catch(y=>{throw y}):V(i.toString(),y=>{let K=Date.now(),H=g(s)&&g(y==null?void 0:y.data)?Z(Z({},y.data),s):s;return self.postMessage({type:b,data:H}),{timestamp:K,maxAge:f,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
"; const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" }); function WorkerWrapper() { const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob); @@ -125,42 +125,44 @@ function useFetch() { }, state); } function usePoll(props) { - var _a, _b; const [state, dispatch] = useReducer(reducer, initialState); const worker = useRef(new WorkerWrapper()); - if (props && worker.current) { - dispatch({ - type: "loading", - loading: true - }); - (_a = worker.current) == null ? void 0 : _a.addEventListener("message", ({ - data: { - type, - data - } - }) => { - if (type === "COMPLETE") - dispatch({ - type: "loading", - loading: false - }); - else if (type === "DATA") - dispatch({ - type: "data", + useEffect(() => { + var _a, _b; + if (props && worker.current) { + dispatch({ + type: "loading", + loading: true + }); + (_a = worker.current) == null ? void 0 : _a.addEventListener("message", ({ + data: { + type, data - }); - else - dispatch({ - type: "error", - error: new Error(type) - }); - }); - (_b = worker.current) == null ? void 0 : _b.postMessage(__spreadProps(__spreadValues({ - type: "poll" - }, props), { - existingData: state.data - })); - } + } + }) => { + if (type === "COMPLETE") + dispatch({ + type: "loading", + loading: false + }); + else if (type === "DATA") + dispatch({ + type: "data", + data + }); + else + dispatch({ + type: "error", + error: new Error(type) + }); + }); + (_b = worker.current) == null ? void 0 : _b.postMessage(__spreadProps(__spreadValues({ + type: "poll" + }, props), { + existingData: state.data + })); + } + }, [props, worker.current]); useEffect(() => { return () => { cleanupWorker(worker.current); @@ -182,6 +184,7 @@ function usePreFetch(prefetch) { } }, [prefetch, worker.current]); useEffect(() => { + worker.current = new WorkerWrapper(); return () => { cleanupWorker(worker.current); }; diff --git a/dist/queryPlus.umd.js b/dist/queryPlus.umd.js index 679c803..8c75df8 100644 --- a/dist/queryPlus.umd.js +++ b/dist/queryPlus.umd.js @@ -1 +1 @@ -(function(Z,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react"),require("idb-keyval")):typeof define=="function"&&define.amd?define(["exports","react","idb-keyval"],d):(Z=typeof globalThis!="undefined"?globalThis:Z||self,d(Z.queryPlus={},Z.React))})(this,function(Z,d){"use strict";var F=Object.defineProperty,y=Object.defineProperties;var J=Object.getOwnPropertyDescriptors;var S=Object.getOwnPropertySymbols;var x=Object.prototype.hasOwnProperty,I=Object.prototype.propertyIsEnumerable;var X=(Z,d,W)=>d in Z?F(Z,d,{enumerable:!0,configurable:!0,writable:!0,value:W}):Z[d]=W,G=(Z,d)=>{for(var W in d||(d={}))x.call(d,W)&&X(Z,W,d[W]);if(S)for(var W of S(d))I.call(d,W)&&X(Z,W,d[W]);return Z},c=(Z,d)=>y(Z,J(d));const W="var k=Object.defineProperty,A=Object.defineProperties;var j=Object.getOwnPropertyDescriptors;var B=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var D=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,y=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&D(h,l,d[l]);if(B)for(var l of B(d))v.call(d,l)&&D(h,l,d[l]);return h},T=(h,d)=>A(h,j(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(i,a)=>c.then(r=>a(r.transaction(e,i).objectStore(e)))}let l;function u(){return l||(l=d("keyval-store","keyval")),l}function x(t,e=u()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=u()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=u()){return n("readwrite",c=>new Promise((i,a)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),i(h(c.transaction))}catch(r){a(r)}}}))}function F(t,e=u()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function U(){const n=d("usestore-db","usestore-db");return{remove:s=>F(s,n),getData:s=>x(s,n),setData:(s,p)=>C(s,p,n),updateData:(s,p)=>N(s,p,n)}}const L=(t,e)=>e?t+e<Date.now():!0,w=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,g=(t,e,n={})=>(Object.keys(t).forEach(c=>{let i=e?e+"."+c:c;w(t[c])?g(t[c],i,n):n[i]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),P=t=>t.flatMap(e=>w(e)?g(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,i=Array.isArray(e)?"array":typeof e;return c!==i?!1:c!=="object"&&c!=="array"?c===i:n&&c==="object"?n.map(a=>t[a]===e[a]).every(a=>a):(c==="array"&&(t=P(t),e=P(e)),!n&&c==="object"&&(t=g(t),e=g(e)),JSON.stringify(t)===JSON.stringify(e))},O=t=>new Function(`return ${decodeURI(t)}`)(),E="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(E)],{type:"text/javascript;charset=utf-8"});function z(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+E,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:X,getData:K,setData:J,updateData:V}=U(),Z=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},Y=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,i=new z;if(e==="cancel"&&(n==null||n.abort(),i==null||i.postMessage({type:"cancel"}),i.terminate()),e==="poll"){let{existingData:a,url:r,options:s,interval:p,maxAttempts:R,compareKeys:f}=t.data;fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m=>{G(a,m,f)?self.postMessage({type:"CACHED",data:m}):(J(r,{timestamp:Date.now(),data:m}),self.postMessage({type:"DATA",data:m}))}).catch(Y).finally(()=>{i==null||i.postMessage({type:e,url:r,options:s,interval:p,maxAttempts:R,existingData:a,compareKeys:f})}),i==null||i.addEventListener("message",({data:m})=>{self.postMessage(m)})}if(e==="pre-fetch"){let{prefetch:a}=t.data;a.forEach(r=>{K(r.url.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(L(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw X(r.url.toString()),new Error("data expired")}).catch(()=>{fetch(r.url.toString(),y({signal:c},r.options)).then(Z).then(s=>{let p=r.middleware?r.middleware(s):s;J(r.url.toString(),{timestamp:Date.now(),data:p,maxAge:r.maxAge})}).catch(()=>{console.info("no data found")})})})}if(e==="fetch"){let{existingData:a,url:r,options:s,maxAge:p,middleware:R,update:f}=t.data;const m=o=>{R&&(o=O(R)(o)),(!a||!G(a,o))&&(self.postMessage({type:"DATA",data:o}),J(r.toString(),{data:o,timestamp:Date.now(),maxAge:p}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let S=M(s);S==="DELETE"&&(X(r.toString()),fetch(r,s).then(()=>{f?fetch(f.url,f.options).then(Z).then(m).catch(o=>{throw o}):self.postMessage({type:"COMPLETE"})}).catch(Y)),S==="GET"&&(K(r.toString()).then(o=>{if(!o)throw new Error("no value found in db");if(L(o==null?void 0:o.maxAge,o==null?void 0:o.timestamp))throw X(r.toString()),new Error("data expired");self.postMessage(G(a,o==null?void 0:o.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:o==null?void 0:o.data})}).catch(o=>{console.info(o==null?void 0:o.message)}),fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(m).catch(Y)),(S==="PUT"||S==="POST")&&fetch(r,s?T(y({},s),{signal:c}):{signal:c}).then(Z).then(o=>{f?fetch(f.url,f.options).then(Z).then(m).catch(b=>{throw b}):V(r.toString(),b=>{let H=Date.now(),W=w(o)&&w(b==null?void 0:b.data)?y(y({},b.data),o):o;return self.postMessage({type:S,data:W}),{timestamp:H,maxAge:p,data:W}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(Y)}})})();
",h=typeof window!="undefined"&&window.Blob&&new Blob([atob(W)],{type:"text/javascript;charset=utf-8"});function a(){const l=h&&(window.URL||window.webkitURL).createObjectURL(h);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+W,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const T={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function t(l,b){switch(b.type){case"pre-load":return c(G({},l),{data:b.data,loading:!1,preload:!0,error:void 0});case"data":return c(G({},l),{data:b.data,loading:!1,preload:!1,error:void 0});case"error":return c(G({},l),{error:b.error,loading:!1,preload:!1});case"loading":return c(G({},l),{loading:b.loading});default:return l}}const k=24*60*60*1e3;function i(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const u=l=>l?encodeURI(l.toString()):void 0;function N(){const[l,b]=d.useReducer(t,T),p=d.useRef(),e=async({url:n,options:Y,maxAge:m=k,middleware:R})=>{let V=p.current;b({type:"loading",loading:!0}),V==null||V.addEventListener("message",({data:{type:o,data:U}})=>{switch(o){case"CACHED":case"COMPLETE":b({type:"loading",loading:!1});break;case"DATA":b({type:"data",data:U});break;case"PRE_LOAD":b({type:"pre-load",data:U});break;default:b({type:"error",error:new Error(o)});break}}),V==null||V.postMessage({type:"fetch",url:n,options:Y,existingData:l.data,middleware:u(R),maxAge:m})};return d.useEffect(()=>(p.current=new a,()=>{i(p.current)}),[]),G({fetchWorker:e},l)}function s(l){var n,Y;const[b,p]=d.useReducer(t,T),e=d.useRef(new a);return l&&e.current&&(p({type:"loading",loading:!0}),(n=e.current)==null||n.addEventListener("message",({data:{type:m,data:R}})=>{p(m==="COMPLETE"?{type:"loading",loading:!1}:m==="DATA"?{type:"data",data:R}:{type:"error",error:new Error(m)})}),(Y=e.current)==null||Y.postMessage(c(G({type:"poll"},l),{existingData:b.data}))),d.useEffect(()=>()=>{i(e.current)},[]),G({},b)}function K(l){const b=d.useRef(new a);d.useEffect(()=>{var p;l&&b.current&&((p=b.current)==null||p.postMessage({type:"pre-fetch",prefetch:l.map(e=>c(G({},e),{middleware:u(e.middleware)}))}))},[l,b.current]),d.useEffect(()=>()=>{i(b.current)},[])}Z.useFetch=N,Z.usePoll=s,Z.usePreFetch=K,Object.defineProperties(Z,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); +(function(W,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react"),require("idb-keyval")):typeof define=="function"&&define.amd?define(["exports","react","idb-keyval"],d):(W=typeof globalThis!="undefined"?globalThis:W||self,d(W.queryPlus={},W.React))})(this,function(W,d){"use strict";var K=Object.defineProperty,H=Object.defineProperties;var F=Object.getOwnPropertyDescriptors;var S=Object.getOwnPropertySymbols;var w=Object.prototype.hasOwnProperty,y=Object.prototype.propertyIsEnumerable;var u=(W,d,b)=>d in W?K(W,d,{enumerable:!0,configurable:!0,writable:!0,value:b}):W[d]=b,c=(W,d)=>{for(var b in d||(d={}))w.call(d,b)&&u(W,b,d[b]);if(S)for(var b of S(d))y.call(d,b)&&u(W,b,d[b]);return W},a=(W,d)=>H(W,F(d));const b="var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,Z=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&B(h,l,d[l]);if(W)for(var l of W(d))v.call(d,l)&&B(h,l,d[l]);return h},T=(h,d)=>j(h,A(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(a,r)=>c.then(i=>r(i.transaction(e,a).objectStore(e)))}let l;function w(){return l||(l=d("keyval-store","keyval")),l}function D(t,e=w()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=w()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=w()){return n("readwrite",c=>new Promise((a,r)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),a(h(c.transaction))}catch(i){r(i)}}}))}function F(t,e=w()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function x(){const n=d("usestore-db","usestore-db");return{remove:o=>F(o,n),getData:o=>D(o,n),setData:(o,f)=>C(o,f,n),updateData:(o,f)=>N(o,f,n)}}const U=(t,e)=>e?t+e<Date.now():!0,g=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,Y=(t,e,n={})=>(Object.keys(t).forEach(c=>{let a=e?e+"."+c:c;g(t[c])?Y(t[c],a,n):n[a]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>g(e)?Y(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,a=Array.isArray(e)?"array":typeof e;return c!==a?!1:c!=="object"&&c!=="array"?c===a:n&&c==="object"?n.map(r=>t[r]===e[r]).every(r=>r):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=Y(t),e=Y(e)),JSON.stringify(t)===JSON.stringify(e))},L=t=>t?new Function(`return ${decodeURI(t)}`)():e=>e,P="dmFyIG09T2JqZWN0LmRlZmluZVByb3BlcnR5LFQ9T2JqZWN0LmRlZmluZVByb3BlcnRpZXM7dmFyIEQ9T2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcnM7dmFyIGc9T2JqZWN0LmdldE93blByb3BlcnR5U3ltYm9sczt2YXIgTT1PYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LE89T2JqZWN0LnByb3RvdHlwZS5wcm9wZXJ0eUlzRW51bWVyYWJsZTt2YXIgZD0oaSxzLG4pPT5zIGluIGk/bShpLHMse2VudW1lcmFibGU6ITAsY29uZmlndXJhYmxlOiEwLHdyaXRhYmxlOiEwLHZhbHVlOm59KTppW3NdPW4saD0oaSxzKT0+e2Zvcih2YXIgbiBpbiBzfHwocz17fSkpTS5jYWxsKHMsbikmJmQoaSxuLHNbbl0pO2lmKGcpZm9yKHZhciBuIG9mIGcocykpTy5jYWxsKHMsbikmJmQoaSxuLHNbbl0pO3JldHVybiBpfSxwPShpLHMpPT5UKGksRChzKSk7KGZ1bmN0aW9uKCl7InVzZSBzdHJpY3QiO2NvbnN0IGk9YXN5bmMoe2ZuOnQsdmFsaWRhdGU6ZSxpbnRlcnZhbDphLG1heEF0dGVtcHRzOnIsYXR0ZW1wdHM6Yz0wfSk9Pnthc3luYyBmdW5jdGlvbiBmKHUseSl7dHJ5e2NvbnN0IGw9YXdhaXQgdCgpO2lmKGMrKyxlKGwpKXtpZihyJiZjPT09cilyZXR1cm4geShuZXcgRXJyb3IoIkV4Y2VlZGVkIG1heCBhdHRlbXB0cyIpKTthd2FpdCBzZXRUaW1lb3V0KGYsYSx1LHkpfWVsc2UgcmV0dXJuIHUobCl9Y2F0Y2gobCl7Y29uc29sZS5lcnJvcihgcG9sbGluZyBFcnJvcjogJHsobD09bnVsbD92b2lkIDA6bC5tZXNzYWdlKXx8ImNvbm5lY3Rpb24gZmFpbGVkIn1gKX19cmV0dXJuIG5ldyBQcm9taXNlKGYpfSxzPXQ9PnR5cGVvZiB0PT0ib2JqZWN0IiYmIUFycmF5LmlzQXJyYXkodCkmJnQhPT1udWxsLG49KHQsZSxhPXt9KT0+KE9iamVjdC5rZXlzKHQpLmZvckVhY2gocj0+e2xldCBjPWU/ZSsiLiIrcjpyO3ModFtyXSk/bih0W3JdLGMsYSk6YVtjXT1BcnJheS5pc0FycmF5KHRbcl0pP3Rbcl0uc29ydCgpOnRbcl19KSxPYmplY3QuZW50cmllcyhhKS5zb3J0KCkpLEE9dD0+dC5mbGF0TWFwKGU9PnMoZSk/bihlKTpbZV0pLnNvcnQoKSx3PSh0LGUsYSk9PntsZXQgcj1BcnJheS5pc0FycmF5KHQpPyJhcnJheSI6dHlwZW9mIHQsYz1BcnJheS5pc0FycmF5KGUpPyJhcnJheSI6dHlwZW9mIGU7cmV0dXJuIHIhPT1jPyExOnIhPT0ib2JqZWN0IiYmciE9PSJhcnJheSI/cj09PWM6YSYmcj09PSJvYmplY3QiP2EubWFwKGY9PnRbZl09PT1lW2ZdKS5ldmVyeShmPT5mKToocj09PSJhcnJheSImJih0PUEodCksZT1BKGUpKSwhYSYmcj09PSJvYmplY3QiJiYodD1uKHQpLGU9bihlKSksSlNPTi5zdHJpbmdpZnkodCk9PT1KU09OLnN0cmluZ2lmeShlKSl9O3NlbGYuYWRkRXZlbnRMaXN0ZW5lcigibWVzc2FnZSIsdD0+e2NvbnN0e3R5cGU6ZX09dC5kYXRhO2xldCBhPW5ldyBBYm9ydENvbnRyb2xsZXIscj1hPT1udWxsP3ZvaWQgMDphLnNpZ25hbDtpZihlPT09ImNhbmNlbCImJihhPT1udWxsfHxhLmFib3J0KCkpLGU9PT0icG9sbCIpe2NvbnN0e3VybDpjLG9wdGlvbnM6ZixpbnRlcnZhbDp1LG1heEF0dGVtcHRzOnksZXhpc3RpbmdEYXRhOmwsY29tcGFyZUtleXM6RX09dC5kYXRhO2koe2ZuOigpPT5mZXRjaChjLGY/cChoKHt9LGYpLHtzaWduYWw6cn0pOntzaWduYWw6cn0pLnRoZW4obz0+e2lmKCFvLm9rfHxvLnN0YXR1cz09PTQwNCl0aHJvdyBuZXcgRXJyb3IoYEhUVFAgZXJyb3IhIFN0YXR1czogJHtvLnN0YXR1c31gKTtpZihvLnN0YXR1cz09PTQwMyl0aHJvdyBuZXcgRXJyb3IoIlVuYXV0aG9yaXplZCEiKTtyZXR1cm4gby5qc29uKCl9KSxpbnRlcnZhbDp1LG1heEF0dGVtcHRzOnksdmFsaWRhdGU6bz0+IXcobCxvLEUpfSkudGhlbihvPT57c2VsZi5wb3N0TWVzc2FnZSh7dHlwZToiREFUQSIsZGF0YTpvfSl9KS5jYXRjaChvPT57c2VsZi5wb3N0TWVzc2FnZSh7dHlwZTpvLm1lc3NhZ2V8fCJVbmtub3duIGVycm9yIn0pfSl9fSl9KSgpOwo=",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(P)],{type:"text/javascript;charset=utf-8"});function O(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+P,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:E,getData:z,setData:X,updateData:V}=x(),S=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,a=new O;if(e==="cancel"&&(n==null||n.abort(),a==null||a.postMessage({type:"cancel"}),a.terminate()),e==="poll"){let{existingData:r,url:i,options:o,interval:f,maxAttempts:u,compareKeys:m}=t.data;fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p=>{G(r,p,m)?self.postMessage({type:"CACHED",data:p}):(X(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{a==null||a.postMessage({type:e,url:i,options:o,interval:f,maxAttempts:u,existingData:r,compareKeys:m})}),a==null||a.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="pre-fetch"){let{prefetch:r}=t.data;r.forEach(({middleware:i,url:o,options:f,maxAge:u})=>{let m=L(i);fetch(o.toString(),Z({signal:c},f)).then(S).then(p=>{X(o.toString(),{timestamp:Date.now(),data:m(p),maxAge:u}).then(()=>{console.log(`saved prefetch ${o}`)}).catch(b=>{console.log(`error saving prefetch ${o}`,b)})}).catch(()=>{console.info("no data found")})})}if(e==="fetch"){let{existingData:r,url:i,options:o,maxAge:f,middleware:u,update:m}=t.data;const p=s=>{s=L(u)(s),(!r||!G(r,s))&&(self.postMessage({type:"DATA",data:s}),X(i.toString(),{data:s,timestamp:Date.now(),maxAge:f}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let b=M(o);b==="DELETE"&&(E(i.toString()),fetch(i,o).then(()=>{m?fetch(m.url,m.options).then(S).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),b==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw E(i.toString()),new Error("data expired");self.postMessage(G(r,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p).catch(R)),(b==="PUT"||b==="POST")&&fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(s=>{m?fetch(m.url,m.options).then(S).then(p).catch(y=>{throw y}):V(i.toString(),y=>{let K=Date.now(),H=g(s)&&g(y==null?void 0:y.data)?Z(Z({},y.data),s):s;return self.postMessage({type:b,data:H}),{timestamp:K,maxAge:f,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
",R=typeof window!="undefined"&&window.Blob&&new Blob([atob(b)],{type:"text/javascript;charset=utf-8"});function m(){const l=R&&(window.URL||window.webkitURL).createObjectURL(R);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+b,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const t={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function s(l,Z){switch(Z.type){case"pre-load":return a(c({},l),{data:Z.data,loading:!1,preload:!0,error:void 0});case"data":return a(c({},l),{data:Z.data,loading:!1,preload:!1,error:void 0});case"error":return a(c({},l),{error:Z.error,loading:!1,preload:!1});case"loading":return a(c({},l),{loading:Z.loading});default:return l}}const T=24*60*60*1e3;function i(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const N=l=>l?encodeURI(l.toString()):void 0;function k(){const[l,Z]=d.useReducer(s,t),V=d.useRef(),e=async({url:G,options:Y,maxAge:p=T,middleware:h})=>{let n=V.current;Z({type:"loading",loading:!0}),n==null||n.addEventListener("message",({data:{type:o,data:U}})=>{switch(o){case"CACHED":case"COMPLETE":Z({type:"loading",loading:!1});break;case"DATA":Z({type:"data",data:U});break;case"PRE_LOAD":Z({type:"pre-load",data:U});break;default:Z({type:"error",error:new Error(o)});break}}),n==null||n.postMessage({type:"fetch",url:G,options:Y,existingData:l.data,middleware:N(h),maxAge:p})};return d.useEffect(()=>(V.current=new m,()=>{i(V.current)}),[]),c({fetchWorker:e},l)}function J(l){const[Z,V]=d.useReducer(s,t),e=d.useRef(new m);return d.useEffect(()=>{var G,Y;l&&e.current&&(V({type:"loading",loading:!0}),(G=e.current)==null||G.addEventListener("message",({data:{type:p,data:h}})=>{V(p==="COMPLETE"?{type:"loading",loading:!1}:p==="DATA"?{type:"data",data:h}:{type:"error",error:new Error(p)})}),(Y=e.current)==null||Y.postMessage(a(c({type:"poll"},l),{existingData:Z.data})))},[l,e.current]),d.useEffect(()=>()=>{i(e.current)},[]),c({},Z)}function X(l){const Z=d.useRef(new m);d.useEffect(()=>{var V;l&&Z.current&&((V=Z.current)==null||V.postMessage({type:"pre-fetch",prefetch:l.map(e=>a(c({},e),{middleware:N(e.middleware)}))}))},[l,Z.current]),d.useEffect(()=>(Z.current=new m,()=>{i(Z.current)}),[])}W.useFetch=k,W.usePoll=J,W.usePreFetch=X,Object.defineProperties(W,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); diff --git a/src/lib/hooks/usePoll.tsx b/src/lib/hooks/usePoll.tsx index 7e44f2f..dce4f8e 100644 --- a/src/lib/hooks/usePoll.tsx +++ b/src/lib/hooks/usePoll.tsx @@ -8,15 +8,18 @@ import type { WorkerResponseType, PollWorkerProps } from "../types"; export function usePoll(props: PollWorkerProps) { const [state, dispatch] = useReducer(reducer, initialState); const worker = useRef(new FetchWorker()); - if(props && worker.current) { - dispatch({ type: 'loading', loading: true }) - worker.current?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { - if(type === 'COMPLETE') dispatch({ type: 'loading', loading: false }); - else if(type === 'DATA') dispatch({ type: 'data', data }); - else dispatch({ type: 'error', error: new Error(type) }); - }) - worker.current?.postMessage({ type: 'poll', ...props, existingData: state.data }); - } + + useEffect(() => { + if(props && worker.current) { + dispatch({ type: 'loading', loading: true }) + worker.current?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { + if(type === 'COMPLETE') dispatch({ type: 'loading', loading: false }); + else if(type === 'DATA') dispatch({ type: 'data', data }); + else dispatch({ type: 'error', error: new Error(type) }); + }) + worker.current?.postMessage({ type: 'poll', ...props, existingData: state.data }); + } + }, [props, worker.current]); useEffect(() => { return () => { cleanupWorker(worker.current); diff --git a/src/lib/hooks/usePreFetch.tsx b/src/lib/hooks/usePreFetch.tsx index 223a720..e34b3d9 100644 --- a/src/lib/hooks/usePreFetch.tsx +++ b/src/lib/hooks/usePreFetch.tsx @@ -15,7 +15,7 @@ export function usePreFetch(prefetch?: Array) { }, [prefetch, worker.current]); useEffect(() => { - // worker.current = new FetchWorker() + worker.current = new FetchWorker() return () => { cleanupWorker(worker.current); } diff --git a/src/lib/types.d.ts b/src/lib/types.d.ts index f87e456..57fb1a9 100644 --- a/src/lib/types.d.ts +++ b/src/lib/types.d.ts @@ -12,6 +12,9 @@ export interface FetchWorkerBaseRequestType { middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType url: RequestInfo | URL } +export interface FetchWorkerRequestType extends FetchWorkerBaseRequestType { + middleware?: string +} export interface FetchWorkerProps extends FetchWorkerBaseRequestType { /* diff --git a/src/lib/utils/index.ts b/src/lib/utils/index.ts index 1937155..0ac111b 100644 --- a/src/lib/utils/index.ts +++ b/src/lib/utils/index.ts @@ -97,4 +97,4 @@ export const createArrayOfUpdates:createArrayOfUpdatesType = (oldRecord, newReco } export const serializeFunction = (f?: Function) => f ? encodeURI(f.toString()) : undefined; -export const deserializeFunction = (s: string) => new Function(`return ${decodeURI(s)}`)(); \ No newline at end of file +export const deserializeFunction = (s?: string) => s ? new Function(`return ${decodeURI(s)}`)() : (d:unknown) => d; \ No newline at end of file diff --git a/src/lib/workers/fetch_worker.ts b/src/lib/workers/fetch_worker.ts index d110c13..7ded2fe 100644 --- a/src/lib/workers/fetch_worker.ts +++ b/src/lib/workers/fetch_worker.ts @@ -9,7 +9,7 @@ import { import PollWorker from "./polling_worker.js?worker&inline"; -import type { WorkerResponseType, ValueType, FetchWorkerBaseRequestType } from "../types"; +import type { WorkerResponseType, ValueType, FetchWorkerRequestType } from "../types"; const { remove, getData, setData, updateData } = store(); @@ -82,27 +82,15 @@ self.addEventListener( if (type === "pre-fetch") { let { prefetch } = event.data; - prefetch.forEach((d: FetchWorkerBaseRequestType) => { - getData(d.url.toString()) - .then( - (value: ValueType) => { - if (!value) { - throw new Error("no value found in db"); - } - if (dataExpired(value?.maxAge, value?.timestamp)) { - remove(d.url.toString()); - throw new Error("data expired"); - } - }, - ) - .catch(() => { - fetch(d.url.toString(), { signal, ...d.options! }).then( - handleResponse, - ).then(data => { - let x = d.middleware ? d.middleware(data) : data; - setData(d.url.toString(), { timestamp: Date.now(), data: x, maxAge: d.maxAge! }); - }).catch(() => { console.info("no data found") }); - }); + prefetch.forEach(({middleware, url, options, maxAge}:FetchWorkerRequestType) => { + let fn = deserializeFunction(middleware); + fetch(url.toString(), { signal, ...options! }).then( + handleResponse, + ).then(data => { + setData(url.toString(), { timestamp: Date.now(), data: fn(data), maxAge: maxAge }) + .then(() => {console.log(`saved prefetch ${url}`)}) + .catch(err => {console.log(`error saving prefetch ${url}`, err)}); + }).catch(() => { console.info("no data found") }); }) } @@ -116,10 +104,8 @@ self.addEventListener( update, } = event.data; const handleData = (data: unknown) => { - if (middleware) { - let fn = deserializeFunction(middleware); - data = fn(data); - } + let fn = deserializeFunction(middleware); + data = fn(data); let hasChanged = !existingData || !isMatch(existingData, data); if (hasChanged) { self.postMessage({ type: "DATA", data }); From fce4fbab7bffd6c3c2ae8e177b5873b746f8463a Mon Sep 17 00:00:00 2001 From: Rod Lewis Date: Mon, 27 Jun 2022 20:56:58 +0800 Subject: [PATCH 5/5] usePreFetch hook --- dist/lib/hooks/usePoll.d.ts | 20 -------- dist/lib/index.d.ts | 1 - dist/lib/utils/index.d.ts | 1 - dist/lib/utils/poll.d.ts | 8 ---- dist/queryPlus.es.js | 50 +------------------ dist/queryPlus.umd.js | 2 +- src/lib/hooks/usePoll.tsx | 29 ------------ src/lib/hooks/useStore.tsx | 19 -------- src/lib/index.ts | 1 - src/lib/utils/index.ts | 1 - src/lib/utils/poll.ts | 35 -------------- src/lib/workers/fetch_worker.ts | 49 +------------------ src/lib/workers/polling_worker.ts | 35 -------------- src/lib/workers/store_worker.ts | 79 ------------------------------- 14 files changed, 5 insertions(+), 325 deletions(-) delete mode 100644 dist/lib/hooks/usePoll.d.ts delete mode 100644 dist/lib/utils/poll.d.ts delete mode 100644 src/lib/hooks/usePoll.tsx delete mode 100644 src/lib/hooks/useStore.tsx delete mode 100644 src/lib/utils/poll.ts delete mode 100644 src/lib/workers/polling_worker.ts delete mode 100644 src/lib/workers/store_worker.ts diff --git a/dist/lib/hooks/usePoll.d.ts b/dist/lib/hooks/usePoll.d.ts deleted file mode 100644 index c29767e..0000000 --- a/dist/lib/hooks/usePoll.d.ts +++ /dev/null @@ -1,20 +0,0 @@ -import type { PollWorkerProps } from "../types"; -export declare function usePoll(props: PollWorkerProps): { - data: any; - loading: boolean; - preload: boolean; - error: undefined; - update: boolean; -} | { - error: any; - loading: boolean; - preload: boolean; - data: import("../utils").UnknownDataResponseType; - update: boolean; -} | { - loading: any; - data: import("../utils").UnknownDataResponseType; - error?: Error | undefined; - preload: boolean; - update: boolean; -}; diff --git a/dist/lib/index.d.ts b/dist/lib/index.d.ts index 9d1c0df..4008f9a 100644 --- a/dist/lib/index.d.ts +++ b/dist/lib/index.d.ts @@ -1,3 +1,2 @@ export { useFetch } from './hooks/useFetch'; -export { usePoll } from './hooks/usePoll'; export { usePreFetch } from './hooks/usePreFetch'; diff --git a/dist/lib/utils/index.d.ts b/dist/lib/utils/index.d.ts index 90b50c4..01ce239 100644 --- a/dist/lib/utils/index.d.ts +++ b/dist/lib/utils/index.d.ts @@ -1,7 +1,6 @@ import type { createArrayOfUpdatesType } from "../types"; export * from "./state_tools"; export * from "./store_tools"; -export * from "./poll"; export declare const DAY: number; export declare function cleanupWorker(worker: Worker | undefined): void; export declare const dataExpired: (maxAge: number, timestamp?: number | undefined) => boolean; diff --git a/dist/lib/utils/poll.d.ts b/dist/lib/utils/poll.d.ts deleted file mode 100644 index 09da044..0000000 --- a/dist/lib/utils/poll.d.ts +++ /dev/null @@ -1,8 +0,0 @@ -export interface PollProps { - fn: () => Promise; - validate: (res: unknown) => boolean; - interval: number; - maxAttempts?: number; - attempts?: number; -} -export declare const poll: ({ fn, validate, interval, maxAttempts }: PollProps) => Promise; diff --git a/dist/queryPlus.es.js b/dist/queryPlus.es.js index 772e9f0..d523df6 100644 --- a/dist/queryPlus.es.js +++ b/dist/queryPlus.es.js @@ -19,7 +19,7 @@ var __spreadValues = (a, b) => { var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); import { useReducer, useRef, useEffect } from "react"; import "idb-keyval"; -const encodedJs = "var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,Z=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&B(h,l,d[l]);if(W)for(var l of W(d))v.call(d,l)&&B(h,l,d[l]);return h},T=(h,d)=>j(h,A(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(a,r)=>c.then(i=>r(i.transaction(e,a).objectStore(e)))}let l;function w(){return l||(l=d("keyval-store","keyval")),l}function D(t,e=w()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=w()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=w()){return n("readwrite",c=>new Promise((a,r)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),a(h(c.transaction))}catch(i){r(i)}}}))}function F(t,e=w()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function x(){const n=d("usestore-db","usestore-db");return{remove:o=>F(o,n),getData:o=>D(o,n),setData:(o,f)=>C(o,f,n),updateData:(o,f)=>N(o,f,n)}}const U=(t,e)=>e?t+e<Date.now():!0,g=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,Y=(t,e,n={})=>(Object.keys(t).forEach(c=>{let a=e?e+"."+c:c;g(t[c])?Y(t[c],a,n):n[a]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>g(e)?Y(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,a=Array.isArray(e)?"array":typeof e;return c!==a?!1:c!=="object"&&c!=="array"?c===a:n&&c==="object"?n.map(r=>t[r]===e[r]).every(r=>r):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=Y(t),e=Y(e)),JSON.stringify(t)===JSON.stringify(e))},L=t=>t?new Function(`return ${decodeURI(t)}`)():e=>e,P="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(P)],{type:"text/javascript;charset=utf-8"});function O(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+P,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:E,getData:z,setData:X,updateData:V}=x(),S=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,a=new O;if(e==="cancel"&&(n==null||n.abort(),a==null||a.postMessage({type:"cancel"}),a.terminate()),e==="poll"){let{existingData:r,url:i,options:o,interval:f,maxAttempts:u,compareKeys:m}=t.data;fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p=>{G(r,p,m)?self.postMessage({type:"CACHED",data:p}):(X(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{a==null||a.postMessage({type:e,url:i,options:o,interval:f,maxAttempts:u,existingData:r,compareKeys:m})}),a==null||a.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="pre-fetch"){let{prefetch:r}=t.data;r.forEach(({middleware:i,url:o,options:f,maxAge:u})=>{let m=L(i);fetch(o.toString(),Z({signal:c},f)).then(S).then(p=>{X(o.toString(),{timestamp:Date.now(),data:m(p),maxAge:u}).then(()=>{console.log(`saved prefetch ${o}`)}).catch(b=>{console.log(`error saving prefetch ${o}`,b)})}).catch(()=>{console.info("no data found")})})}if(e==="fetch"){let{existingData:r,url:i,options:o,maxAge:f,middleware:u,update:m}=t.data;const p=s=>{s=L(u)(s),(!r||!G(r,s))&&(self.postMessage({type:"DATA",data:s}),X(i.toString(),{data:s,timestamp:Date.now(),maxAge:f}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let b=M(o);b==="DELETE"&&(E(i.toString()),fetch(i,o).then(()=>{m?fetch(m.url,m.options).then(S).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),b==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw E(i.toString()),new Error("data expired");self.postMessage(G(r,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p).catch(R)),(b==="PUT"||b==="POST")&&fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(s=>{m?fetch(m.url,m.options).then(S).then(p).catch(y=>{throw y}):V(i.toString(),y=>{let K=Date.now(),H=g(s)&&g(y==null?void 0:y.data)?Z(Z({},y.data),s):s;return self.postMessage({type:b,data:H}),{timestamp:K,maxAge:f,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
"; +const encodedJs = "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"; const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" }); function WorkerWrapper() { const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob); @@ -124,52 +124,6 @@ function useFetch() { fetchWorker }, state); } -function usePoll(props) { - const [state, dispatch] = useReducer(reducer, initialState); - const worker = useRef(new WorkerWrapper()); - useEffect(() => { - var _a, _b; - if (props && worker.current) { - dispatch({ - type: "loading", - loading: true - }); - (_a = worker.current) == null ? void 0 : _a.addEventListener("message", ({ - data: { - type, - data - } - }) => { - if (type === "COMPLETE") - dispatch({ - type: "loading", - loading: false - }); - else if (type === "DATA") - dispatch({ - type: "data", - data - }); - else - dispatch({ - type: "error", - error: new Error(type) - }); - }); - (_b = worker.current) == null ? void 0 : _b.postMessage(__spreadProps(__spreadValues({ - type: "poll" - }, props), { - existingData: state.data - })); - } - }, [props, worker.current]); - useEffect(() => { - return () => { - cleanupWorker(worker.current); - }; - }, []); - return __spreadValues({}, state); -} function usePreFetch(prefetch) { const worker = useRef(new WorkerWrapper()); useEffect(() => { @@ -190,4 +144,4 @@ function usePreFetch(prefetch) { }; }, []); } -export { useFetch, usePoll, usePreFetch }; +export { useFetch, usePreFetch }; diff --git a/dist/queryPlus.umd.js b/dist/queryPlus.umd.js index 8c75df8..7f8d72e 100644 --- a/dist/queryPlus.umd.js +++ b/dist/queryPlus.umd.js @@ -1 +1 @@ -(function(W,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react"),require("idb-keyval")):typeof define=="function"&&define.amd?define(["exports","react","idb-keyval"],d):(W=typeof globalThis!="undefined"?globalThis:W||self,d(W.queryPlus={},W.React))})(this,function(W,d){"use strict";var K=Object.defineProperty,H=Object.defineProperties;var F=Object.getOwnPropertyDescriptors;var S=Object.getOwnPropertySymbols;var w=Object.prototype.hasOwnProperty,y=Object.prototype.propertyIsEnumerable;var u=(W,d,b)=>d in W?K(W,d,{enumerable:!0,configurable:!0,writable:!0,value:b}):W[d]=b,c=(W,d)=>{for(var b in d||(d={}))w.call(d,b)&&u(W,b,d[b]);if(S)for(var b of S(d))y.call(d,b)&&u(W,b,d[b]);return W},a=(W,d)=>H(W,F(d));const b="var k=Object.defineProperty,j=Object.defineProperties;var A=Object.getOwnPropertyDescriptors;var W=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,v=Object.prototype.propertyIsEnumerable;var B=(h,d,l)=>d in h?k(h,d,{enumerable:!0,configurable:!0,writable:!0,value:l}):h[d]=l,Z=(h,d)=>{for(var l in d||(d={}))Q.call(d,l)&&B(h,l,d[l]);if(W)for(var l of W(d))v.call(d,l)&&B(h,l,d[l]);return h},T=(h,d)=>j(h,A(d));(function(){"use strict";function h(t){return new Promise((e,n)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>n(t.error)})}function d(t,e){const n=indexedDB.open(t);n.onupgradeneeded=()=>n.result.createObjectStore(e);const c=h(n);return(a,r)=>c.then(i=>r(i.transaction(e,a).objectStore(e)))}let l;function w(){return l||(l=d("keyval-store","keyval")),l}function D(t,e=w()){return e("readonly",n=>h(n.get(t)))}function C(t,e,n=w()){return n("readwrite",c=>(c.put(e,t),h(c.transaction)))}function N(t,e,n=w()){return n("readwrite",c=>new Promise((a,r)=>{c.get(t).onsuccess=function(){try{c.put(e(this.result),t),a(h(c.transaction))}catch(i){r(i)}}}))}function F(t,e=w()){return e("readwrite",n=>(n.delete(t),h(n.transaction)))}function x(){const n=d("usestore-db","usestore-db");return{remove:o=>F(o,n),getData:o=>D(o,n),setData:(o,f)=>C(o,f,n),updateData:(o,f)=>N(o,f,n)}}const U=(t,e)=>e?t+e<Date.now():!0,g=t=>typeof t=="object"&&!Array.isArray(t)&&t!==null,Y=(t,e,n={})=>(Object.keys(t).forEach(c=>{let a=e?e+"."+c:c;g(t[c])?Y(t[c],a,n):n[a]=Array.isArray(t[c])?t[c].sort():t[c]}),Object.entries(n).sort()),J=t=>t.flatMap(e=>g(e)?Y(e):[e]).sort(),M=t=>{var e,n;return(n=(e=t==null?void 0:t.method)==null?void 0:e.toUpperCase())!=null?n:"GET"},G=(t,e,n)=>{let c=Array.isArray(t)?"array":typeof t,a=Array.isArray(e)?"array":typeof e;return c!==a?!1:c!=="object"&&c!=="array"?c===a:n&&c==="object"?n.map(r=>t[r]===e[r]).every(r=>r):(c==="array"&&(t=J(t),e=J(e)),!n&&c==="object"&&(t=Y(t),e=Y(e)),JSON.stringify(t)===JSON.stringify(e))},L=t=>t?new Function(`return ${decodeURI(t)}`)():e=>e,P="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",I=typeof window!="undefined"&&window.Blob&&new Blob([atob(P)],{type:"text/javascript;charset=utf-8"});function O(){const t=I&&(window.URL||window.webkitURL).createObjectURL(I);try{return t?new Worker(t,{}):new Worker("data:application/javascript;base64,"+P,{type:"module"})}finally{t&&(window.URL||window.webkitURL).revokeObjectURL(t)}}const{remove:E,getData:z,setData:X,updateData:V}=x(),S=t=>{if(!t.ok||t.status===404)throw new Error(`HTTP error! Status: ${t.status}`);if(t.status===403)throw new Error("Unauthorized!");return t.json()},R=t=>{self.postMessage({type:t.message||"Unknown error"})};self.addEventListener("message",t=>{const{type:e}=t.data;let n=new AbortController,c=n==null?void 0:n.signal,a=new O;if(e==="cancel"&&(n==null||n.abort(),a==null||a.postMessage({type:"cancel"}),a.terminate()),e==="poll"){let{existingData:r,url:i,options:o,interval:f,maxAttempts:u,compareKeys:m}=t.data;fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p=>{G(r,p,m)?self.postMessage({type:"CACHED",data:p}):(X(i,{timestamp:Date.now(),data:p}),self.postMessage({type:"DATA",data:p}))}).catch(R).finally(()=>{a==null||a.postMessage({type:e,url:i,options:o,interval:f,maxAttempts:u,existingData:r,compareKeys:m})}),a==null||a.addEventListener("message",({data:p})=>{self.postMessage(p)})}if(e==="pre-fetch"){let{prefetch:r}=t.data;r.forEach(({middleware:i,url:o,options:f,maxAge:u})=>{let m=L(i);fetch(o.toString(),Z({signal:c},f)).then(S).then(p=>{X(o.toString(),{timestamp:Date.now(),data:m(p),maxAge:u}).then(()=>{console.log(`saved prefetch ${o}`)}).catch(b=>{console.log(`error saving prefetch ${o}`,b)})}).catch(()=>{console.info("no data found")})})}if(e==="fetch"){let{existingData:r,url:i,options:o,maxAge:f,middleware:u,update:m}=t.data;const p=s=>{s=L(u)(s),(!r||!G(r,s))&&(self.postMessage({type:"DATA",data:s}),X(i.toString(),{data:s,timestamp:Date.now(),maxAge:f}).then(()=>{console.info("saved data")}).catch(()=>{console.info("couldn't access indexedDB to save data")})),self.postMessage({type:"COMPLETE"})};let b=M(o);b==="DELETE"&&(E(i.toString()),fetch(i,o).then(()=>{m?fetch(m.url,m.options).then(S).then(p).catch(s=>{throw s}):self.postMessage({type:"COMPLETE"})}).catch(R)),b==="GET"&&(z(i.toString()).then(s=>{if(!s)throw new Error("no value found in db");if(U(s==null?void 0:s.maxAge,s==null?void 0:s.timestamp))throw E(i.toString()),new Error("data expired");self.postMessage(G(r,s==null?void 0:s.data)?{type:"CACHED"}:{type:"PRE_LOAD",data:s==null?void 0:s.data})}).catch(s=>{console.info(s==null?void 0:s.message)}),fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(p).catch(R)),(b==="PUT"||b==="POST")&&fetch(i,o?T(Z({},o),{signal:c}):{signal:c}).then(S).then(s=>{m?fetch(m.url,m.options).then(S).then(p).catch(y=>{throw y}):V(i.toString(),y=>{let K=Date.now(),H=g(s)&&g(y==null?void 0:y.data)?Z(Z({},y.data),s):s;return self.postMessage({type:b,data:H}),{timestamp:K,maxAge:f,data:H}}).catch(()=>{console.info("update store failed")}).finally(()=>{self.postMessage({type:"COMPLETE"})})}).catch(R)}})})();
",R=typeof window!="undefined"&&window.Blob&&new Blob([atob(b)],{type:"text/javascript;charset=utf-8"});function m(){const l=R&&(window.URL||window.webkitURL).createObjectURL(R);try{return l?new Worker(l,{}):new Worker("data:application/javascript;base64,"+b,{type:"module"})}finally{l&&(window.URL||window.webkitURL).revokeObjectURL(l)}}const t={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function s(l,Z){switch(Z.type){case"pre-load":return a(c({},l),{data:Z.data,loading:!1,preload:!0,error:void 0});case"data":return a(c({},l),{data:Z.data,loading:!1,preload:!1,error:void 0});case"error":return a(c({},l),{error:Z.error,loading:!1,preload:!1});case"loading":return a(c({},l),{loading:Z.loading});default:return l}}const T=24*60*60*1e3;function i(l){l==null||l.postMessage({type:"cancel"}),l==null||l.terminate(),l=void 0}const N=l=>l?encodeURI(l.toString()):void 0;function k(){const[l,Z]=d.useReducer(s,t),V=d.useRef(),e=async({url:G,options:Y,maxAge:p=T,middleware:h})=>{let n=V.current;Z({type:"loading",loading:!0}),n==null||n.addEventListener("message",({data:{type:o,data:U}})=>{switch(o){case"CACHED":case"COMPLETE":Z({type:"loading",loading:!1});break;case"DATA":Z({type:"data",data:U});break;case"PRE_LOAD":Z({type:"pre-load",data:U});break;default:Z({type:"error",error:new Error(o)});break}}),n==null||n.postMessage({type:"fetch",url:G,options:Y,existingData:l.data,middleware:N(h),maxAge:p})};return d.useEffect(()=>(V.current=new m,()=>{i(V.current)}),[]),c({fetchWorker:e},l)}function J(l){const[Z,V]=d.useReducer(s,t),e=d.useRef(new m);return d.useEffect(()=>{var G,Y;l&&e.current&&(V({type:"loading",loading:!0}),(G=e.current)==null||G.addEventListener("message",({data:{type:p,data:h}})=>{V(p==="COMPLETE"?{type:"loading",loading:!1}:p==="DATA"?{type:"data",data:h}:{type:"error",error:new Error(p)})}),(Y=e.current)==null||Y.postMessage(a(c({type:"poll"},l),{existingData:Z.data})))},[l,e.current]),d.useEffect(()=>()=>{i(e.current)},[]),c({},Z)}function X(l){const Z=d.useRef(new m);d.useEffect(()=>{var V;l&&Z.current&&((V=Z.current)==null||V.postMessage({type:"pre-fetch",prefetch:l.map(e=>a(c({},e),{middleware:N(e.middleware)}))}))},[l,Z.current]),d.useEffect(()=>(Z.current=new m,()=>{i(Z.current)}),[])}W.useFetch=k,W.usePoll=J,W.usePreFetch=X,Object.defineProperties(W,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); +(function(l,d){typeof exports=="object"&&typeof module!="undefined"?d(exports,require("react"),require("idb-keyval")):typeof define=="function"&&define.amd?define(["exports","react","idb-keyval"],d):(l=typeof globalThis!="undefined"?globalThis:l||self,d(l.queryPlus={},l.React))})(this,function(l,d){"use strict";var J=Object.defineProperty,V=Object.defineProperties;var N=Object.getOwnPropertyDescriptors;var Y=Object.getOwnPropertySymbols;var r=Object.prototype.hasOwnProperty,C=Object.prototype.propertyIsEnumerable;var s=(l,d,b)=>d in l?J(l,d,{enumerable:!0,configurable:!0,writable:!0,value:b}):l[d]=b,m=(l,d)=>{for(var b in d||(d={}))r.call(d,b)&&s(l,b,d[b]);if(Y)for(var b of Y(d))C.call(d,b)&&s(l,b,d[b]);return l},n=(l,d)=>V(l,N(d));const b="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",u=typeof window!="undefined"&&window.Blob&&new Blob([atob(b)],{type:"text/javascript;charset=utf-8"});function p(){const e=u&&(window.URL||window.webkitURL).createObjectURL(u);try{return e?new Worker(e,{}):new Worker("data:application/javascript;base64,"+b,{type:"module"})}finally{e&&(window.URL||window.webkitURL).revokeObjectURL(e)}}const h={data:void 0,error:void 0,loading:!1,preload:!1,update:!0};function y(e,c){switch(c.type){case"pre-load":return n(m({},e),{data:c.data,loading:!1,preload:!0,error:void 0});case"data":return n(m({},e),{data:c.data,loading:!1,preload:!1,error:void 0});case"error":return n(m({},e),{error:c.error,loading:!1,preload:!1});case"loading":return n(m({},e),{loading:c.loading});default:return e}}const R=24*60*60*1e3;function G(e){e==null||e.postMessage({type:"cancel"}),e==null||e.terminate(),e=void 0}const K=e=>e?encodeURI(e.toString()):void 0;function T(){const[e,c]=d.useReducer(y,h),Z=d.useRef(),i=async({url:k,options:S,maxAge:W=R,middleware:I})=>{let o=Z.current;c({type:"loading",loading:!0}),o==null||o.addEventListener("message",({data:{type:a,data:t}})=>{switch(a){case"CACHED":case"COMPLETE":c({type:"loading",loading:!1});break;case"DATA":c({type:"data",data:t});break;case"PRE_LOAD":c({type:"pre-load",data:t});break;default:c({type:"error",error:new Error(a)});break}}),o==null||o.postMessage({type:"fetch",url:k,options:S,existingData:e.data,middleware:K(I),maxAge:W})};return d.useEffect(()=>(Z.current=new p,()=>{G(Z.current)}),[]),m({fetchWorker:i},e)}function X(e){const c=d.useRef(new p);d.useEffect(()=>{var Z;e&&c.current&&((Z=c.current)==null||Z.postMessage({type:"pre-fetch",prefetch:e.map(i=>n(m({},i),{middleware:K(i.middleware)}))}))},[e,c.current]),d.useEffect(()=>(c.current=new p,()=>{G(c.current)}),[])}l.useFetch=T,l.usePreFetch=X,Object.defineProperties(l,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}); diff --git a/src/lib/hooks/usePoll.tsx b/src/lib/hooks/usePoll.tsx deleted file mode 100644 index dce4f8e..0000000 --- a/src/lib/hooks/usePoll.tsx +++ /dev/null @@ -1,29 +0,0 @@ -import { useRef, useEffect, useReducer } from "react"; - -import FetchWorker from '../workers/fetch_worker.js?worker&inline' -import { cleanupWorker, initialState, reducer } from "../utils"; - -import type { WorkerResponseType, PollWorkerProps } from "../types"; - -export function usePoll(props: PollWorkerProps) { - const [state, dispatch] = useReducer(reducer, initialState); - const worker = useRef(new FetchWorker()); - - useEffect(() => { - if(props && worker.current) { - dispatch({ type: 'loading', loading: true }) - worker.current?.addEventListener('message', ({ data: { type, data } }: WorkerResponseType) => { - if(type === 'COMPLETE') dispatch({ type: 'loading', loading: false }); - else if(type === 'DATA') dispatch({ type: 'data', data }); - else dispatch({ type: 'error', error: new Error(type) }); - }) - worker.current?.postMessage({ type: 'poll', ...props, existingData: state.data }); - } - }, [props, worker.current]); - useEffect(() => { - return () => { - cleanupWorker(worker.current); - } - }, []); - return { ...state! }; -}; diff --git a/src/lib/hooks/useStore.tsx b/src/lib/hooks/useStore.tsx deleted file mode 100644 index c2743ce..0000000 --- a/src/lib/hooks/useStore.tsx +++ /dev/null @@ -1,19 +0,0 @@ -import { useRef, useEffect, useState } from "react"; - -import StoreWorker from '../workers/store_worker.js?worker&inline' -import { cleanupWorker } from "../utils"; - -import type { WorkerResponseType } from "../types"; - -export function useData(key: string) { - const [data, setData] = useState() - const worker = useRef(new StoreWorker()); - // build the postMessage functions - - useEffect(() => { - return () => { - cleanupWorker(worker.current); - } - }, []); - return [data]; -}; diff --git a/src/lib/index.ts b/src/lib/index.ts index 3128e79..2c8a84d 100644 --- a/src/lib/index.ts +++ b/src/lib/index.ts @@ -1,3 +1,2 @@ export {useFetch} from './hooks/useFetch'; -export {usePoll} from './hooks/usePoll'; export {usePreFetch} from './hooks/usePreFetch'; \ No newline at end of file diff --git a/src/lib/utils/index.ts b/src/lib/utils/index.ts index 0ac111b..83b0afc 100644 --- a/src/lib/utils/index.ts +++ b/src/lib/utils/index.ts @@ -2,7 +2,6 @@ import type { createArrayOfUpdatesType, ArrayOfStringAnyTuple, StringAnyTuple } export * from "./state_tools"; export * from "./store_tools"; -export * from "./poll"; export const DAY = 24 * 60 * 60 * 1000; diff --git a/src/lib/utils/poll.ts b/src/lib/utils/poll.ts deleted file mode 100644 index c7e9266..0000000 --- a/src/lib/utils/poll.ts +++ /dev/null @@ -1,35 +0,0 @@ -export interface PollProps { - fn: () => Promise; - validate: (res: unknown) => boolean; - interval: number; - maxAttempts?: number; - attempts?: number -} - -export const poll: ( - { fn, validate, interval, maxAttempts }: PollProps, -) => Promise = async ({ fn, validate, interval, maxAttempts, attempts=0 }) => { - async function executePoll( - resolve: (value: unknown) => void, - reject: (reason?: any) => void, - ) { - try { - const result = await fn(); - attempts++; - if (!validate(result)) { - return resolve(result); - } else if (maxAttempts && (attempts === maxAttempts)) { - return reject(new Error("Exceeded max attempts")); - } else { - await setTimeout(executePoll, interval, resolve, reject); - } - } catch (error) { - console.error( - `polling Error: ${ - (error as Error)?.message || "connection failed" - }`, - ); - } - } - return new Promise(executePoll); -}; diff --git a/src/lib/workers/fetch_worker.ts b/src/lib/workers/fetch_worker.ts index 7ded2fe..145b749 100644 --- a/src/lib/workers/fetch_worker.ts +++ b/src/lib/workers/fetch_worker.ts @@ -7,9 +7,7 @@ import { store, } from "../utils"; -import PollWorker from "./polling_worker.js?worker&inline"; - -import type { WorkerResponseType, ValueType, FetchWorkerRequestType } from "../types"; +import type { ValueType, FetchWorkerRequestType } from "../types"; const { remove, getData, setData, updateData } = store(); @@ -33,53 +31,10 @@ self.addEventListener( const { type } = event.data; let controller: AbortController | undefined = new AbortController(); let signal = controller?.signal; - let pollWorker = new PollWorker(); + if (type === "cancel") { controller?.abort(); - pollWorker?.postMessage({ type: "cancel" }); - pollWorker.terminate(); - } - if (type === "poll") { - let { - existingData, - url, - options, - interval, - maxAttempts, - compareKeys, - } = event.data; - fetch(url, options ? { ...options, signal } : { signal }) - .then(handleResponse) - .then( - (data: unknown) => { - if (isMatch(existingData, data, compareKeys)) { - self.postMessage({ type: "CACHED", data }); - } else { - setData(url, { timestamp: Date.now(), data }); - self.postMessage({ type: "DATA", data }); - } - }, - ) - .catch(handleError) - .finally(() => { - pollWorker?.postMessage({ - type, - url, - options, - interval, - maxAttempts, - existingData, - compareKeys, - }); - }); - pollWorker?.addEventListener( - "message", - ({ data }: WorkerResponseType) => { - self.postMessage(data); - }, - ); } - if (type === "pre-fetch") { let { prefetch } = event.data; prefetch.forEach(({middleware, url, options, maxAge}:FetchWorkerRequestType) => { diff --git a/src/lib/workers/polling_worker.ts b/src/lib/workers/polling_worker.ts deleted file mode 100644 index 8f1cd92..0000000 --- a/src/lib/workers/polling_worker.ts +++ /dev/null @@ -1,35 +0,0 @@ -import {isMatch, poll} from "../utils" -self.addEventListener('message', (event) => { - const { type } = event.data; - let controller: AbortController | undefined = new AbortController(); - let signal = controller?.signal; - if (type === 'cancel') { - controller?.abort(); - } - if (type === 'poll') { - const { url, options, interval, maxAttempts, existingData, compareKeys } = event.data; - const validate = (newJson: unknown) => !isMatch(existingData, newJson, compareKeys); - const getData = () => fetch(url, options ? {...options, signal} : {signal}).then( - (response) => { - if (!response.ok || response.status === 404) { - throw new Error(`HTTP error! Status: ${ response.status }`); - } - if (response.status === 403) { - throw new Error(`Unauthorized!`); - } - return response.json(); - } - ) - poll({ - fn: getData, - interval, - maxAttempts, - validate - }) - .then(data => { - self.postMessage({type: 'DATA', data}); - }).catch(error => { - self.postMessage({type: error.message || 'Unknown error'}); - }) - } -}); \ No newline at end of file diff --git a/src/lib/workers/store_worker.ts b/src/lib/workers/store_worker.ts deleted file mode 100644 index 9f4e1ed..0000000 --- a/src/lib/workers/store_worker.ts +++ /dev/null @@ -1,79 +0,0 @@ -import { dataExpired, store } from "../utils"; - -const { remove, getData, setData, updateData } = store(); - -self.addEventListener( - "message", - (event) => { - let { - type, - url, - maxAge, - newData - } = event.data; - if(type === "get") { - getData(url).then(data => { - if(dataExpired(data, maxAge)) { - self.postMessage({ - type: "expired", - url, - }); - } else { - self.postMessage({ - type: "get-success", - url, - data, - }); - } - }).catch((error) => { - self.postMessage({ - type: "error", - error, - url, - }); - }) - } - if(type === "delete") { - remove(url).then(() => { - self.postMessage({ - type: "delete-success", - url, - }); - }).catch((error) => { - self.postMessage({ - type: "error", - error, - url, - }); - }) - } - if(type === "set") { - setData(url, newData).then(() => { - self.postMessage({ - type: "set-success", - url, - }); - }).catch((error) => { - self.postMessage({ - type: "error", - error, - url, - }); - }) - } - if(type === "update") { - updateData(url, newData).then(() => { - self.postMessage({ - type: "update-success", - url, - }); - }).catch((error) => { - self.postMessage({ - type: "error", - error, - url, - }); - }) - } - }, -);