Merge pull request #2 from StudentOfJS/prefetch

Prefetch

dist/lib/hooks/useFetch.d.ts

@@ -1,43 +1,23 @@
-import { UnknownDataResponseType } from "../utils";
-export interface FetchWorkerProps {
-    fetchOptions?: RequestInit | undefined;
-    maxAge?: number;
-    middleware?: (data: UnknownDataResponseType) => UnknownDataResponseType;
-    url: RequestInfo | URL;
-    update?: {
-        url: RequestInfo | URL;
-        options?: RequestInit | undefined;
-    };
-}
-/**
- * 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<string, any>) => { 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;
     preload: boolean;
     error: undefined;
     update: boolean;
-    fetchWorker: ({ url, fetchOptions, maxAge, middleware }: FetchWorkerProps) => Promise<void>;
+    fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise<void>;
 } | {
     error: any;
     loading: boolean;
     preload: boolean;
-    data: UnknownDataResponseType;
+    data: import("../utils").UnknownDataResponseType;
     update: boolean;
-    fetchWorker: ({ url, fetchOptions, maxAge, middleware }: FetchWorkerProps) => Promise<void>;
+    fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise<void>;
 } | {
     loading: any;
-    data: UnknownDataResponseType;
+    data: import("../utils").UnknownDataResponseType;
     error?: Error | undefined;
     preload: boolean;
     update: boolean;
-    fetchWorker: ({ url, fetchOptions, maxAge, middleware }: FetchWorkerProps) => Promise<void>;
+    fetchWorker: ({ url, options, maxAge, middleware }: FetchWorkerProps) => Promise<void>;
 };

dist/lib/hooks/usePreFetch.d.ts

@@ -0,0 +1,2 @@
+import type { FetchWorkerBaseRequestType } from "../types";
+export declare function usePreFetch(prefetch?: Array<FetchWorkerBaseRequestType>): void;

dist/lib/index.d.ts

@@ -1 +1,2 @@
 export { useFetch } from './hooks/useFetch';
+export { usePreFetch } from './hooks/usePreFetch';

dist/lib/types.d.ts

@@ -0,0 +1,42 @@
+export type StringAnyTuple = [string, any]
+export type ArrayOfStringAnyTuple = Array<StringAnyTuple>
+export type createArrayOfUpdatesType = (oldRecord: Record<string, any>, newRecord: Record<string, any>) => 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 FetchWorkerRequestType extends FetchWorkerBaseRequestType {
+    middleware?: string
+}
+
+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 };
+
+

dist/lib/utils/index.d.ts

@@ -1,4 +1,6 @@
+import type { createArrayOfUpdatesType } from "../types";
 export * from "./state_tools";
+export * from "./store_tools";
 export declare const DAY: number;
 export declare function cleanupWorker(worker: Worker | undefined): void;
 export declare const dataExpired: (maxAge: number, timestamp?: number | undefined) => boolean;
@@ -7,9 +9,6 @@ export declare const flattenObjectToArray: (obj: Record<string, any>, parent?: s
 export declare const flattenAndSortArray: (arr: Array<any>) => 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<StringAnyTuple>;
-export declare type createArrayOfUpdatesType = (oldRecord: Record<string, any>, newRecord: Record<string, any>) => ArrayOfStringAnyTuple;
 export declare const createArrayOfUpdates: createArrayOfUpdatesType;
-export declare const serializeFunction: (f: Function) => string;
-export declare const deserializeFunction: (s: string) => any;
+export declare const serializeFunction: (f?: Function | undefined) => string | undefined;
+export declare const deserializeFunction: (s?: string | undefined) => any;

dist/lib/utils/store_tools.d.ts

@@ -0,0 +1,6 @@
+export declare function store(): {
+    remove: (key: IDBValidKey) => Promise<void>;
+    getData: (key: IDBValidKey) => Promise<any>;
+    setData: (key: IDBValidKey, value: unknown) => Promise<void>;
+    updateData: (key: IDBValidKey, updater: (oldValue: any) => any) => Promise<void>;
+};

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 = "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";
+import "idb-keyval";
+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);
@@ -55,13 +56,13 @@ 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();
   const fetchWorker = async ({
     url,
-    fetchOptions,
+    options,
     maxAge = DAY,
     middleware
   }) => {
@@ -104,13 +105,12 @@ function useFetch() {
           break;
       }
     });
-    let serializedMw = middleware ? serializeFunction(middleware) : void 0;
     worker == null ? void 0 : worker.postMessage({
       type: "fetch",
       url,
-      fetchOptions,
+      options,
       existingData: state.data,
-      middleware: serializedMw,
+      middleware: serializeFunction(middleware),
       maxAge
     });
   };
@@ -124,4 +124,24 @@ function useFetch() {
     fetchWorker
   }, state);
 }
-export { useFetch };
+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(() => {
+    worker.current = new WorkerWrapper();
+    return () => {
+      cleanupWorker(worker.current);
+    };
+  }, []);
+}
+export { useFetch, usePreFetch };