@dr.pogodin/react-global-state 0.15.1 → 0.16.0

package/build/module/useAsyncCollection.js

@@ -1,56 +1,219 @@
 /**
- * Loads and uses an item in an async collection.
+ * Loads and uses item(s) in an async collection.
  */
 
-import { useAsyncData } from "./useAsyncData";
+import { useEffect, useRef } from 'react';
+import { v4 as uuid } from 'uuid';
+import { getGlobalState } from "./GlobalStateProvider";
+import { DEFAULT_MAXAGE, load, newAsyncDataEnvelope } from "./useAsyncData";
+import useGlobalState from "./useGlobalState";
+import { isDebugMode } from "./utils";
 
 /**
- * Resolves and stores at the given `path` of global state elements of
- * an asynchronous data collection. In other words, it is an auxiliar wrapper
- * around {@link useAsyncData}, which uses a loader which resolves to different
- * data, based on ID argument passed in, and stores data fetched for different
- * IDs in the state.
- * @param id ID of the collection item to load & use.
- * @param path The global state path where entire collection should be
- *  stored.
- * @param loader A loader function, which takes an
- * ID of data to load, and resolves to the corresponding data.
- * @param options Additional options.
- * @param options.deps An array of dependencies, which trigger
- * data reload when changed. Given dependency changes are watched shallowly
- * (similarly to the standard React's
- * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).
- * @param options.noSSR If `true`, this hook won't load data during
- * server-side rendering.
- * @param options.garbageCollectAge The maximum age of data
- * (in milliseconds), after which they are dropped from the state when the last
- * component referencing them via `useAsyncData()` hook unmounts. Defaults to
- * `maxage` option value.
- * @param options.maxage The maximum age of
- * data (in milliseconds) acceptable to the hook's caller. If loaded data are
- * older than this value, `null` is returned instead. Defaults to 5 minutes.
- * @param options.refreshAge The maximum age of data
- * (in milliseconds), after which their refreshment will be triggered when
- * any component referencing them via `useAsyncData()` hook (re-)renders.
- * Defaults to `maxage` value.
- * @return Returns an object with three fields: `data` holds the actual result of
- * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`
- * is a boolean flag, which is `true` if data are being loaded (the hook is
- * waiting for `loader` function resolution); `timestamp` (in milliseconds)
- * is Unix timestamp of related data currently loaded into the global state.
- *
- * Note that loaded data, if any, are stored at the given `path` of global state
- * along with related meta-information, using slightly different state segment
- * structure (see {@link AsyncDataEnvelope}). That segment of the global state
- * can be accessed, and even modified using other hooks,
- * _e.g._ {@link useGlobalState}, but doing so you may interfere with related
- * `useAsyncData()` hooks logic.
+ * Resolves and stores at the given `path` of the global state elements of
+ * an asynchronous data collection.
  */
 
-function useAsyncCollection(id, path, loader) {
+// TODO: This is largely similar to useAsyncData() logic, just more generic.
+// Perhaps, a bunch of logic blocks can be split into stand-alone functions,
+// and reused in both hooks.
+function useAsyncCollection(idOrIds, path, loader) {
+  var _options$maxage, _options$refreshAge, _options$garbageColle;
   let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  const itemPath = path ? `${path}.${id}` : id;
-  return useAsyncData(itemPath, oldData => loader(id, oldData), options);
+  const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+  const maxage = (_options$maxage = options.maxage) !== null && _options$maxage !== void 0 ? _options$maxage : DEFAULT_MAXAGE;
+  const refreshAge = (_options$refreshAge = options.refreshAge) !== null && _options$refreshAge !== void 0 ? _options$refreshAge : maxage;
+  const garbageCollectAge = (_options$garbageColle = options.garbageCollectAge) !== null && _options$garbageColle !== void 0 ? _options$garbageColle : maxage;
+
+  // To avoid unnecessary work if consumer passes down the same IDs
+  // in an unstable order.
+  // TODO: Should we also filter out any duplicates? Or just assume consumer
+  // knows what he is doing, and won't place duplicates into IDs array?e
+  ids.sort();
+  const globalState = getGlobalState();
+  const {
+    current: heap
+  } = useRef({});
+  heap.globalState = globalState;
+  heap.ids = ids;
+  heap.path = path;
+  heap.loader = loader;
+  if (!heap.reload) {
+    heap.reload = async customLoader => {
+      const localLoader = customLoader || heap.loader;
+      if (!localLoader || !heap.globalState || !heap.ids) {
+        throw Error('Internal error');
+      }
+      for (let i = 0; i < heap.ids.length; ++i) {
+        const id = heap.ids[i];
+        const itemPath = heap.path ? `${heap.path}.${id}` : `${id}`;
+
+        // eslint-disable-next-line no-await-in-loop
+        await load(itemPath, (oldData, meta) => localLoader(id, oldData, meta), heap.globalState);
+      }
+    };
+  }
+  if (!Array.isArray(idOrIds)) {
+    heap.reloadD = customLoader => heap.reload(customLoader && function (id) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return customLoader(...args);
+    });
+  }
+
+  // Server-side logic.
+  if (globalState.ssrContext && !options.noSSR) {
+    const operationId = `S${uuid()}`;
+    for (let i = 0; i < ids.length; ++i) {
+      const id = ids[i];
+      const itemPath = path ? `${path}.${id}` : `${id}`;
+      const state = globalState.get(itemPath, {
+        initialValue: newAsyncDataEnvelope()
+      });
+      if (!state.timestamp && !state.operationId) {
+        globalState.ssrContext.pending.push(load(itemPath, function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          return loader(id, ...args);
+        }, globalState, {
+          data: state.data,
+          timestamp: state.timestamp
+        }, operationId));
+      }
+    }
+
+    // Client-side logic.
+  } else {
+    // Reference-counting & garbage collection.
+
+    // TODO: Violation of rules of hooks is fine here,
+    // but perhaps it can be refactored to avoid the need for it.
+    useEffect(() => {
+      // eslint-disable-line react-hooks/rules-of-hooks
+      for (let i = 0; i < ids.length; ++i) {
+        const id = ids[i];
+        const itemPath = path ? `${path}.${id}` : `${id}`;
+        const state = globalState.get(itemPath, {
+          initialValue: newAsyncDataEnvelope()
+        });
+        const numRefsPath = itemPath ? `${itemPath}.numRefs` : 'numRefs';
+        globalState.set(numRefsPath, state.numRefs + 1);
+      }
+      return () => {
+        for (let i = 0; i < ids.length; ++i) {
+          const id = ids[i];
+          const itemPath = path ? `${path}.${id}` : `${id}`;
+          const state2 = globalState.get(itemPath);
+          if (state2.numRefs === 1 && garbageCollectAge < Date.now() - state2.timestamp) {
+            if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
+              /* eslint-disable no-console */
+              console.log(`ReactGlobalState - useAsyncCollection garbage collected at path ${itemPath || ''}`);
+              /* eslint-enable no-console */
+            }
+            globalState.dropDependencies(itemPath || '');
+            globalState.set(itemPath, {
+              ...state2,
+              data: null,
+              numRefs: 0,
+              timestamp: 0
+            });
+          } else {
+            const numRefsPath = itemPath ? `${itemPath}.numRefs` : 'numRefs';
+            globalState.set(numRefsPath, state2.numRefs - 1);
+          }
+        }
+      };
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [garbageCollectAge, globalState, path, ...ids]);
+
+    // NOTE: a bunch of Rules of Hooks ignored belows because in our very
+    // special case the otherwise wrong behavior is actually what we need.
+
+    // Data loading and refreshing.
+    const loadTriggeredForIds = new Set();
+    useEffect(() => {
+      // eslint-disable-line react-hooks/rules-of-hooks
+      (async () => {
+        for (let i = 0; i < ids.length; ++i) {
+          const id = ids[i];
+          const itemPath = path ? `${path}.${id}` : `${id}`;
+          const state2 = globalState.get(itemPath);
+          const {
+            deps
+          } = options;
+          if (deps && globalState.hasChangedDependencies(itemPath, deps) || refreshAge < Date.now() - state2.timestamp && (!state2.operationId || state2.operationId.charAt(0) === 'S')) {
+            if (!deps) globalState.dropDependencies(itemPath);
+            loadTriggeredForIds.add(id);
+            // eslint-disable-next-line no-await-in-loop
+            await load(itemPath, function () {
+              for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = arguments[_key3];
+              }
+              return loader(id, ...args);
+            }, globalState, {
+              data: state2.data,
+              timestamp: state2.timestamp
+            });
+          }
+        }
+      })();
+    });
+    useEffect(() => {
+      // eslint-disable-line react-hooks/rules-of-hooks
+      (async () => {
+        const {
+          deps
+        } = options;
+        for (let i = 0; i < ids.length; ++i) {
+          const id = ids[i];
+          const itemPath = path ? `${path}.${id}` : `${id}`;
+          if (deps && globalState.hasChangedDependencies(itemPath || '', deps) && !loadTriggeredForIds.has(id)) {
+            // eslint-disable-next-line no-await-in-loop
+            await load(itemPath, (oldData, meta) => loader(id, oldData, meta), globalState);
+          }
+        }
+      })();
+
+      // Here we need to default to empty array, so that this hook is re-evaluated
+      // only when dependencies specified in options change, and it should not be
+      // re-evaluated at all if no `deps` option is used.
+    }, options.deps || []); // eslint-disable-line react-hooks/exhaustive-deps
+  }
+  const [localState] = useGlobalState(path, {});
+  if (!Array.isArray(idOrIds)) {
+    var _e$timestamp, _e$data;
+    const e = localState[idOrIds];
+    const timestamp = (_e$timestamp = e === null || e === void 0 ? void 0 : e.timestamp) !== null && _e$timestamp !== void 0 ? _e$timestamp : 0;
+    return {
+      data: maxage < Date.now() - timestamp ? null : (_e$data = e === null || e === void 0 ? void 0 : e.data) !== null && _e$data !== void 0 ? _e$data : null,
+      loading: !!(e !== null && e !== void 0 && e.operationId),
+      reload: heap.reloadD,
+      timestamp
+    };
+  }
+  const res = {
+    items: {},
+    loading: false,
+    reload: heap.reload,
+    timestamp: Number.MAX_VALUE
+  };
+  for (let i = 0; i < ids.length; ++i) {
+    var _e$timestamp2, _e$data2;
+    const id = ids[i];
+    const e = localState[id];
+    const loading = !!(e !== null && e !== void 0 && e.operationId);
+    const timestamp = (_e$timestamp2 = e === null || e === void 0 ? void 0 : e.timestamp) !== null && _e$timestamp2 !== void 0 ? _e$timestamp2 : 0;
+    res.items[id] = {
+      data: maxage < Date.now() - timestamp ? null : (_e$data2 = e === null || e === void 0 ? void 0 : e.data) !== null && _e$data2 !== void 0 ? _e$data2 : null,
+      loading,
+      timestamp
+    };
+    res.loading || (res.loading = loading);
+    if (res.timestamp > timestamp) res.timestamp = timestamp;
+  }
+  return res;
 }
 export default useAsyncCollection;
 //# sourceMappingURL=useAsyncCollection.js.map

package/build/module/useAsyncCollection.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAsyncCollection.js","names":["useAsyncData","useAsyncCollection","id","path","loader","options","arguments","length","undefined","itemPath","oldData"],"sources":["../../src/useAsyncCollection.ts"],"sourcesContent":["/**\n * Loads and uses an item in an async collection.\n */\n\nimport {\n  type DataInEnvelopeAtPathT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n  useAsyncData,\n} from './useAsyncData';\n\nimport { type ForceT, type LockT, type TypeLock } from './utils';\n\nexport type AsyncCollectionLoaderT<DataT> =\n  (id: string, oldData: null | DataT) => DataT | Promise<DataT>;\n\n/**\n * Resolves and stores at the given `path` of global state elements of\n * an asynchronous data collection. In other words, it is an auxiliar wrapper\n * around {@link useAsyncData}, which uses a loader which resolves to different\n * data, based on ID argument passed in, and stores data fetched for different\n * IDs in the state.\n * @param id ID of the collection item to load & use.\n * @param path The global state path where entire collection should be\n *  stored.\n * @param loader A loader function, which takes an\n * ID of data to load, and resolves to the corresponding data.\n * @param options Additional options.\n * @param options.deps An array of dependencies, which trigger\n * data reload when changed. Given dependency changes are watched shallowly\n * (similarly to the standard React's\n * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).\n * @param options.noSSR If `true`, this hook won't load data during\n * server-side rendering.\n * @param options.garbageCollectAge The maximum age of data\n * (in milliseconds), after which they are dropped from the state when the last\n * component referencing them via `useAsyncData()` hook unmounts. Defaults to\n * `maxage` option value.\n * @param options.maxage The maximum age of\n * data (in milliseconds) acceptable to the hook's caller. If loaded data are\n * older than this value, `null` is returned instead. Defaults to 5 minutes.\n * @param options.refreshAge The maximum age of data\n * (in milliseconds), after which their refreshment will be triggered when\n * any component referencing them via `useAsyncData()` hook (re-)renders.\n * Defaults to `maxage` value.\n * @return Returns an object with three fields: `data` holds the actual result of\n * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`\n * is a boolean flag, which is `true` if data are being loaded (the hook is\n * waiting for `loader` function resolution); `timestamp` (in milliseconds)\n * is Unix timestamp of related data currently loaded into the global state.\n *\n * Note that loaded data, if any, are stored at the given `path` of global state\n * along with related meta-information, using slightly different state segment\n * structure (see {@link AsyncDataEnvelope}). That segment of the global state\n * can be accessed, and even modified using other hooks,\n * _e.g._ {@link useGlobalState}, but doing so you may interfere with related\n * `useAsyncData()` hooks logic.\n */\n\nfunction useAsyncCollection<\n  StateT,\n  PathT extends null | string | undefined,\n  IdT extends string,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> =\n  DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>,\n>(\n  id: IdT,\n  path: PathT,\n  loader: AsyncCollectionLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncCollection<\n  Forced extends ForceT | LockT = LockT,\n  DataT = unknown,\n>(\n  id: string,\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncCollection<DataT>(\n  id: string,\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const itemPath = path ? `${path}.${id}` : id;\n  return useAsyncData<ForceT, DataT>(\n    itemPath,\n    (oldData: null | DataT) => loader(id, oldData),\n    options,\n  );\n}\n\nexport default useAsyncCollection;\n\nexport interface UseAsyncCollectionI<StateT> {\n  <PathT extends null | string | undefined, IdT extends string>(\n    id: IdT,\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    id: string,\n    path: null | string | undefined,\n    loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"AAAA;AACA;AACA;;AAEA,SAIEA,YAAY;;AAQd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AA0BA,SAASC,kBAAkBA,CACzBC,EAAU,EACVC,IAA+B,EAC/BC,MAAqC,EAEZ;EAAA,IADzBC,OAA6B,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAElC,MAAMG,QAAQ,GAAGN,IAAI,GAAG,GAAGA,IAAI,IAAID,EAAE,EAAE,GAAGA,EAAE;EAC5C,OAAOF,YAAY,CACjBS,QAAQ,EACPC,OAAqB,IAAKN,MAAM,CAACF,EAAE,EAAEQ,OAAO,CAAC,EAC9CL,OACF,CAAC;AACH;AAEA,eAAeJ,kBAAkB","ignoreList":[]}
+{"version":3,"file":"useAsyncCollection.js","names":["useEffect","useRef","v4","uuid","getGlobalState","DEFAULT_MAXAGE","load","newAsyncDataEnvelope","useGlobalState","isDebugMode","useAsyncCollection","idOrIds","path","loader","_options$maxage","_options$refreshAge","_options$garbageColle","options","arguments","length","undefined","ids","Array","isArray","maxage","refreshAge","garbageCollectAge","sort","globalState","current","heap","reload","customLoader","localLoader","Error","i","id","itemPath","oldData","meta","reloadD","_len","args","_key","ssrContext","noSSR","operationId","state","get","initialValue","timestamp","pending","push","_len2","_key2","data","numRefsPath","set","numRefs","state2","Date","now","process","env","NODE_ENV","console","log","dropDependencies","loadTriggeredForIds","Set","deps","hasChangedDependencies","charAt","add","_len3","_key3","has","localState","_e$timestamp","_e$data","e","loading","res","items","Number","MAX_VALUE","_e$timestamp2","_e$data2"],"sources":["../../src/useAsyncCollection.ts"],"sourcesContent":["/**\n * Loads and uses item(s) in an async collection.\n */\n\nimport { useEffect, useRef } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport GlobalState from './GlobalState';\nimport { getGlobalState } from './GlobalStateProvider';\n\nimport {\n  type AsyncDataEnvelopeT,\n  type AsyncDataReloaderT,\n  type DataInEnvelopeAtPathT,\n  type OperationIdT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n  DEFAULT_MAXAGE,\n  load,\n  newAsyncDataEnvelope,\n} from './useAsyncData';\n\nimport useGlobalState from './useGlobalState';\n\nimport {\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  isDebugMode,\n} from './utils';\n\nexport type AsyncCollectionLoaderT<\n  DataT,\n  IdT extends number | string = number | string,\n> =\n  (id: IdT, oldData: null | DataT, meta: {\n    isAborted: () => boolean;\n    oldDataTimestamp: number;\n  }) => DataT | Promise<DataT | null> | null;\n\nexport type AsyncCollectionReloaderT<\n  DataT,\n  IdT extends number | string = number | string,\n>\n  = (loader?: AsyncCollectionLoaderT<DataT, IdT>) => Promise<void>;\n\ntype CollectionItemT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  timestamp: number;\n};\n\nexport type UseAsyncCollectionResT<\n  DataT,\n  IdT extends number | string = number | string,\n> = {\n  items: {\n    [id in IdT]: CollectionItemT<DataT>;\n  }\n  loading: boolean;\n  reload: AsyncCollectionReloaderT<DataT, IdT>;\n  timestamp: number;\n};\n\ntype HeapT<\n  DataT,\n  IdT extends number | string,\n> = {\n  // Note: these heap fields are necessary to make reload() a stable function.\n  globalState?: GlobalState<unknown>;\n  ids?: IdT[];\n  path?: null | string;\n  loader?: AsyncCollectionLoaderT<DataT, IdT>;\n  reload?: AsyncCollectionReloaderT<DataT, IdT>;\n  reloadD?: AsyncDataReloaderT<DataT>;\n};\n\n/**\n * Resolves and stores at the given `path` of the global state elements of\n * an asynchronous data collection.\n */\n\nfunction useAsyncCollection<\n  StateT,\n  PathT extends null | string | undefined,\n  IdT extends number | string,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> =\n  DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>,\n>(\n  id: IdT,\n  path: PathT,\n  loader: AsyncCollectionLoaderT<DataT, IdT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncCollection<\n  Forced extends ForceT | LockT = LockT,\n  DataT = unknown,\n  IdT extends number | string = number | string,\n>(\n  id: IdT,\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncCollection<\n  StateT,\n  PathT extends null | string | undefined,\n  IdT extends number | string,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> =\n  DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>,\n>(\n  id: IdT[],\n  path: PathT,\n  loader: AsyncCollectionLoaderT<DataT, IdT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncCollectionResT<DataT, IdT>;\n\nfunction useAsyncCollection<\n  Forced extends ForceT | LockT = LockT,\n  DataT = unknown,\n  IdT extends number | string = number | string,\n>(\n  id: IdT[],\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncCollectionResT<DataT, IdT>;\n\n// TODO: This is largely similar to useAsyncData() logic, just more generic.\n// Perhaps, a bunch of logic blocks can be split into stand-alone functions,\n// and reused in both hooks.\nfunction useAsyncCollection<\n  DataT,\n  IdT extends number | string,\n>(\n  idOrIds: IdT | IdT[],\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<DataT, IdT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> | UseAsyncCollectionResT<DataT, IdT> {\n  const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];\n\n  const maxage: number = options.maxage ?? DEFAULT_MAXAGE;\n  const refreshAge: number = options.refreshAge ?? maxage;\n  const garbageCollectAge: number = options.garbageCollectAge ?? maxage;\n\n  // To avoid unnecessary work if consumer passes down the same IDs\n  // in an unstable order.\n  // TODO: Should we also filter out any duplicates? Or just assume consumer\n  // knows what he is doing, and won't place duplicates into IDs array?e\n  ids.sort();\n\n  const globalState = getGlobalState();\n\n  const { current: heap } = useRef<HeapT<DataT, IdT>>({});\n\n  heap.globalState = globalState;\n  heap.ids = ids;\n  heap.path = path;\n  heap.loader = loader;\n\n  if (!heap.reload) {\n    heap.reload = async (customLoader?: AsyncCollectionLoaderT<DataT, IdT>) => {\n      const localLoader = customLoader || heap.loader;\n      if (!localLoader || !heap.globalState || !heap.ids) {\n        throw Error('Internal error');\n      }\n\n      for (let i = 0; i < heap.ids.length; ++i) {\n        const id = heap.ids[i]!;\n        const itemPath = heap.path ? `${heap.path}.${id}` : `${id}`;\n\n        // eslint-disable-next-line no-await-in-loop\n        await load(\n          itemPath,\n          (oldData: DataT | null, meta) => localLoader(id, oldData, meta),\n          heap.globalState,\n        );\n      }\n    };\n  }\n\n  if (!Array.isArray(idOrIds)) {\n    heap.reloadD = (customLoader) => heap.reload!(\n      customLoader && ((id, ...args) => customLoader(...args)),\n    );\n  }\n\n  // Server-side logic.\n  if (globalState.ssrContext && !options.noSSR) {\n    const operationId: OperationIdT = `S${uuid()}`;\n    for (let i = 0; i < ids.length; ++i) {\n      const id = ids[i]!;\n      const itemPath = path ? `${path}.${id}` : `${id}`;\n      const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(itemPath, {\n        initialValue: newAsyncDataEnvelope<DataT>(),\n      });\n      if (!state.timestamp && !state.operationId) {\n        globalState.ssrContext.pending.push(\n          load(itemPath, (...args) => loader(id, ...args), globalState, {\n            data: state.data,\n            timestamp: state.timestamp,\n          }, operationId),\n        );\n      }\n    }\n\n  // Client-side logic.\n  } else {\n    // Reference-counting & garbage collection.\n\n    // TODO: Violation of rules of hooks is fine here,\n    // but perhaps it can be refactored to avoid the need for it.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      for (let i = 0; i < ids.length; ++i) {\n        const id = ids[i];\n        const itemPath = path ? `${path}.${id}` : `${id}`;\n        const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(\n          itemPath,\n          { initialValue: newAsyncDataEnvelope() },\n        );\n\n        const numRefsPath = itemPath ? `${itemPath}.numRefs` : 'numRefs';\n        globalState.set<ForceT, number>(numRefsPath, state.numRefs + 1);\n      }\n\n      return () => {\n        for (let i = 0; i < ids.length; ++i) {\n          const id = ids[i];\n          const itemPath = path ? `${path}.${id}` : `${id}`;\n          const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n          ForceT, AsyncDataEnvelopeT<DataT>\n          >(itemPath);\n          if (\n            state2.numRefs === 1\n            && garbageCollectAge < Date.now() - state2.timestamp\n          ) {\n            if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n              /* eslint-disable no-console */\n              console.log(\n                `ReactGlobalState - useAsyncCollection garbage collected at path ${\n                  itemPath || ''\n                }`,\n              );\n              /* eslint-enable no-console */\n            }\n            globalState.dropDependencies(itemPath || '');\n            globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(itemPath, {\n              ...state2,\n              data: null,\n              numRefs: 0,\n              timestamp: 0,\n            });\n          } else {\n            const numRefsPath = itemPath ? `${itemPath}.numRefs` : 'numRefs';\n            globalState.set<ForceT, number>(numRefsPath, state2.numRefs - 1);\n          }\n        }\n      };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [garbageCollectAge, globalState, path, ...ids]);\n\n    // NOTE: a bunch of Rules of Hooks ignored belows because in our very\n    // special case the otherwise wrong behavior is actually what we need.\n\n    // Data loading and refreshing.\n    const loadTriggeredForIds = new Set<IdT>();\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      (async () => {\n        for (let i = 0; i < ids.length; ++i) {\n          const id = ids[i]!;\n          const itemPath = path ? `${path}.${id}` : `${id}`;\n          const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n          ForceT, AsyncDataEnvelopeT<DataT>>(itemPath);\n\n          const { deps } = options;\n          if (\n            (deps && globalState.hasChangedDependencies(itemPath, deps))\n            || (\n              refreshAge < Date.now() - state2.timestamp\n              && (!state2.operationId || state2.operationId.charAt(0) === 'S')\n            )\n          ) {\n            if (!deps) globalState.dropDependencies(itemPath);\n            loadTriggeredForIds.add(id);\n            // eslint-disable-next-line no-await-in-loop\n            await load(itemPath, (...args) => loader(id, ...args), globalState, {\n              data: state2.data,\n              timestamp: state2.timestamp,\n            });\n          }\n        }\n      })();\n    });\n\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      (async () => {\n        const { deps } = options;\n        for (let i = 0; i < ids.length; ++i) {\n          const id = ids[i]!;\n          const itemPath = path ? `${path}.${id}` : `${id}`;\n          if (\n            deps\n            && globalState.hasChangedDependencies(itemPath || '', deps)\n            && !loadTriggeredForIds.has(id)\n          ) {\n            // eslint-disable-next-line no-await-in-loop\n            await load(\n              itemPath,\n              (oldData: null | DataT, meta) => loader(id, oldData, meta),\n              globalState,\n            );\n          }\n        }\n      })();\n\n    // Here we need to default to empty array, so that this hook is re-evaluated\n    // only when dependencies specified in options change, and it should not be\n    // re-evaluated at all if no `deps` option is used.\n    }, options.deps || []); // eslint-disable-line react-hooks/exhaustive-deps\n  }\n\n  const [localState] = useGlobalState<\n  ForceT, { [id: string]: AsyncDataEnvelopeT<DataT> }\n  >(path, {});\n\n  if (!Array.isArray(idOrIds)) {\n    const e = localState[idOrIds];\n    const timestamp = e?.timestamp ?? 0;\n    return {\n      data: maxage < Date.now() - timestamp ? null : (e?.data ?? null),\n      loading: !!e?.operationId,\n      reload: heap.reloadD!,\n      timestamp,\n    };\n  }\n\n  const res: UseAsyncCollectionResT<DataT, IdT> = {\n    items: {} as Record<IdT, CollectionItemT<DataT>>,\n    loading: false,\n    reload: heap.reload,\n    timestamp: Number.MAX_VALUE,\n  };\n\n  for (let i = 0; i < ids.length; ++i) {\n    const id = ids[i]!;\n    const e = localState[id];\n    const loading = !!e?.operationId;\n    const timestamp = e?.timestamp ?? 0;\n\n    res.items[id] = {\n      data: maxage < Date.now() - timestamp ? null : (e?.data ?? null),\n      loading,\n      timestamp,\n    };\n    res.loading ||= loading;\n    if (res.timestamp > timestamp) res.timestamp = timestamp;\n  }\n\n  return res;\n}\n\nexport default useAsyncCollection;\n\nexport interface UseAsyncCollectionI<StateT> {\n  <PathT extends null | string | undefined, IdT extends number | string>(\n    id: IdT,\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;\n\n  <\n    Forced extends ForceT | LockT = LockT,\n    DataT = unknown,\n    IdT extends number | string = number | string,\n  >(\n    id: IdT,\n    path: null | string | undefined,\n    loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\n  <PathT extends null | string | undefined, IdT extends number | string>(\n    id: IdT[],\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncCollectionResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>;\n\n  <\n    Forced extends ForceT | LockT = LockT,\n    DataT = unknown,\n    IdT extends number | string = number | string,\n  >(\n    id: IdT[],\n    path: null | string | undefined,\n    loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncCollectionResT<DataT, IdT>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/module/useAsyncData.js

@@ -8,7 +8,7 @@ import { MIN_MS } from '@dr.pogodin/js-utils';
 import { getGlobalState } from "./GlobalStateProvider";
 import useGlobalState from "./useGlobalState";
 import { cloneDeepForLog, isDebugMode } from "./utils";
-const DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.
+export const DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.
 
 export function newAsyncDataEnvelope() {
   let initialData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
@@ -37,23 +37,38 @@ export function newAsyncDataEnvelope() {
  * @return Resolves once the operation is done.
  * @ignore
  */
-async function load(path, loader, globalState, oldData) {
-  let opIdPrefix = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'C';
+export async function load(path, loader, globalState, old) {
+  let operationId = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : `C${uuid()}`;
   if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
     /* eslint-disable no-console */
-    console.log(`ReactGlobalState: useAsyncData data (re-)loading. Path: "${path || ''}"`);
+    console.log(`ReactGlobalState: async data (re-)loading. Path: "${path || ''}"`);
     /* eslint-enable no-console */
   }
-  const operationId = opIdPrefix + uuid();
   const operationIdPath = path ? `${path}.operationId` : 'operationId';
   globalState.set(operationIdPath, operationId);
-  const dataOrLoader = loader(oldData || globalState.get(path).data);
-  const data = dataOrLoader instanceof Promise ? await dataOrLoader : dataOrLoader;
+  let definedOld = old;
+  if (!definedOld) {
+    // TODO: Can we improve the typing, to avoid ForceT?
+    const e = globalState.get(path);
+    definedOld = {
+      data: e.data,
+      timestamp: e.timestamp
+    };
+  }
+  const dataOrPromise = loader(definedOld.data, {
+    isAborted: () => {
+      // TODO: Can we improve the typing, to avoid ForceT?
+      const opid = globalState.get(path).operationId;
+      return opid !== operationId;
+    },
+    oldDataTimestamp: definedOld.timestamp
+  });
+  const data = dataOrPromise instanceof Promise ? await dataOrPromise : dataOrPromise;
   const state = globalState.get(path);
   if (operationId === state.operationId) {
     if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
       /* eslint-disable no-console */
-      console.groupCollapsed(`ReactGlobalState: useAsyncData data (re-)loaded. Path: "${path || ''}"`);
+      console.groupCollapsed(`ReactGlobalState: async data (re-)loaded. Path: "${path || ''}"`);
       console.log('Data:', cloneDeepForLog(data, path !== null && path !== void 0 ? path : ''));
       /* eslint-enable no-console */
     }
@@ -73,57 +88,15 @@ async function load(path, loader, globalState, oldData) {
 
 /**
  * Resolves asynchronous data, and stores them at given `path` of global
- * state. When multiple components rely on asynchronous data at the same `path`,
- * the data are resolved once, and reused until their age is within specified
- * bounds. Once the data are stale, the hook allows to refresh them. It also
- * garbage-collects stale data from the global state when the last component
- * relying on them is unmounted.
- * @param path Dot-delimitered state path, where data envelop is
- * stored.
- * @param loader Asynchronous function which resolves (loads)
- * data, which should be stored at the global state `path`. When multiple
- * components
- * use `useAsyncData()` hook for the same `path`, the library assumes that all
- * hook instances are called with the same `loader` (_i.e._ whichever of these
- * loaders is used to resolve async data, the result is acceptable to be reused
- * in all related components).
- * @param options Additional options.
- * @param options.deps An array of dependencies, which trigger
- * data reload when changed. Given dependency changes are watched shallowly
- * (similarly to the standard React's
- * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).
- * @param options.noSSR If `true`, this hook won't load data during
- * server-side rendering.
- * @param options.garbageCollectAge The maximum age of data
- * (in milliseconds), after which they are dropped from the state when the last
- * component referencing them via `useAsyncData()` hook unmounts. Defaults to
- * `maxage` option value.
- * @param options.maxage The maximum age of
- * data (in milliseconds) acceptable to the hook's caller. If loaded data are
- * older than this value, `null` is returned instead. Defaults to 5 minutes.
- * @param options.refreshAge The maximum age of data
- * (in milliseconds), after which their refreshment will be triggered when
- * any component referencing them via `useAsyncData()` hook (re-)renders.
- * Defaults to `maxage` value.
- * @return Returns an object with three fields: `data` holds the actual result of
- * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`
- * is a boolean flag, which is `true` if data are being loaded (the hook is
- * waiting for `loader` function resolution); `timestamp` (in milliseconds)
- * is Unix timestamp of related data currently loaded into the global state.
- *
- * Note that loaded data, if any, are stored at the given `path` of global state
- * along with related meta-information, using slightly different state segment
- * structure (see {@link AsyncDataEnvelopeT}). That segment of the global state
- * can be accessed, and even modified using other hooks,
- * _e.g._ {@link useGlobalState}, but doing so you may interfere with related
- * `useAsyncData()` hooks logic.
+ * state.
  */
 
 function useAsyncData(path, loader) {
+  var _options$maxage, _options$refreshAge, _options$garbageColle;
   let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  const maxage = options.maxage === undefined ? DEFAULT_MAXAGE : options.maxage;
-  const refreshAge = options.refreshAge === undefined ? maxage : options.refreshAge;
-  const garbageCollectAge = options.garbageCollectAge === undefined ? maxage : options.garbageCollectAge;
+  const maxage = (_options$maxage = options.maxage) !== null && _options$maxage !== void 0 ? _options$maxage : DEFAULT_MAXAGE;
+  const refreshAge = (_options$refreshAge = options.refreshAge) !== null && _options$refreshAge !== void 0 ? _options$refreshAge : maxage;
+  const garbageCollectAge = (_options$garbageColle = options.garbageCollectAge) !== null && _options$garbageColle !== void 0 ? _options$garbageColle : maxage;
 
   // Note: here we can't depend on useGlobalState() to init the initial value,
   // because that way we'll have issues with SSR (see details below).
@@ -141,12 +114,15 @@ function useAsyncData(path, loader) {
     heap.reload = customLoader => {
       const localLoader = customLoader || heap.loader;
       if (!localLoader || !heap.globalState) throw Error('Internal error');
-      return load(heap.path, localLoader, heap.globalState, null);
+      return load(heap.path, localLoader, heap.globalState);
     };
   }
   if (globalState.ssrContext && !options.noSSR) {
     if (!state.timestamp && !state.operationId) {
-      globalState.ssrContext.pending.push(load(path, loader, globalState, state.data, 'S'));
+      globalState.ssrContext.pending.push(load(path, loader, globalState, {
+        data: state.data,
+        timestamp: state.timestamp
+      }, `S${uuid()}`));
     }
   } else {
     // This takes care about the client-side reference counting, and garbage
@@ -190,9 +166,22 @@ function useAsyncData(path, loader) {
     useEffect(() => {
       // eslint-disable-line react-hooks/rules-of-hooks
       const state2 = globalState.get(path);
-      if (refreshAge < Date.now() - state2.timestamp && (!state2.operationId || state2.operationId.charAt(0) === 'S')) {
-        load(path, loader, globalState, state2.data);
+      const {
+        deps
+      } = options;
+      if (
+      // The hook is called with a list of dependencies, that mismatch
+      // dependencies last used to retrieve the data at given path.
+      deps && globalState.hasChangedDependencies(path || '', deps)
+
+      // Data at the path are stale, and are not being loaded.
+      || refreshAge < Date.now() - state2.timestamp && (!state2.operationId || state2.operationId.charAt(0) === 'S')) {
         loadTriggered = true; // eslint-disable-line react-hooks/exhaustive-deps
+        if (!deps) globalState.dropDependencies(path || '');
+        load(path, loader, globalState, {
+          data: state2.data,
+          timestamp: state2.timestamp
+        });
       }
     });
     useEffect(() => {
@@ -201,7 +190,7 @@ function useAsyncData(path, loader) {
         deps
       } = options;
       if (deps && globalState.hasChangedDependencies(path || '', deps) && !loadTriggered) {
-        load(path, loader, globalState, null);
+        load(path, loader, globalState);
       }
 
       // Here we need to default to empty array, so that this hook is re-evaluated

package/build/module/useAsyncData.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAsyncData.js","names":["useEffect","useRef","v4","uuid","MIN_MS","getGlobalState","useGlobalState","cloneDeepForLog","isDebugMode","DEFAULT_MAXAGE","newAsyncDataEnvelope","initialData","arguments","length","undefined","numRefs","timestamp","data","operationId","load","path","loader","globalState","oldData","opIdPrefix","process","env","NODE_ENV","console","log","operationIdPath","set","dataOrLoader","get","Promise","state","groupCollapsed","Date","now","groupEnd","useAsyncData","options","maxage","refreshAge","garbageCollectAge","initialValue","current","heap","reload","customLoader","localLoader","Error","ssrContext","noSSR","pending","push","numRefsPath","state2","dropDependencies","loadTriggered","charAt","deps","hasChangedDependencies","localState","loading","Boolean"],"sources":["../../src/useAsyncData.ts"],"sourcesContent":["/**\n * Loads and uses async data into the GlobalState path.\n */\n\nimport { useEffect, useRef } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport { MIN_MS } from '@dr.pogodin/js-utils';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport useGlobalState from './useGlobalState';\n\nimport {\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  cloneDeepForLog,\n  isDebugMode,\n} from './utils';\n\nimport GlobalState from './GlobalState';\nimport SsrContext from './SsrContext';\n\nconst DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.\n\nexport type AsyncDataLoaderT<DataT>\n= (oldData: null | DataT) => DataT | Promise<DataT>;\n\nexport type AsyncDataReloaderT<DataT>\n= (loader?: AsyncDataLoaderT<DataT>) => Promise<void>;\n\nexport type AsyncDataEnvelopeT<DataT> = {\n  data: null | DataT;\n  numRefs: number;\n  operationId: string;\n  timestamp: number;\n};\n\nexport function newAsyncDataEnvelope<DataT>(\n  initialData: DataT | null = null,\n  { numRefs = 0, timestamp = 0 } = {},\n): AsyncDataEnvelopeT<DataT> {\n  return {\n    data: initialData,\n    numRefs,\n    operationId: '',\n    timestamp,\n  };\n}\n\nexport type UseAsyncDataOptionsT = {\n  deps?: unknown[];\n  garbageCollectAge?: number;\n  maxage?: number;\n  noSSR?: boolean;\n  refreshAge?: number;\n};\n\nexport type UseAsyncDataResT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  reload: AsyncDataReloaderT<DataT>;\n  timestamp: number;\n};\n\n/**\n * Executes the data loading operation.\n * @param path Data segment path inside the global state.\n * @param loader Data loader.\n * @param globalState The global state instance.\n * @param oldData Optional. Previously fetched data, currently stored in\n *  the state, if already fetched by the caller; otherwise, they will be fetched\n *  by the load() function itself.\n * @param opIdPrefix operationId prefix to use, which should be\n * 'C' at the client-side (default), or 'S' at the server-side (within SSR\n * context).\n * @return Resolves once the operation is done.\n * @ignore\n */\nasync function load<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  globalState: GlobalState<unknown, SsrContext<unknown>>,\n  oldData: DataT | null,\n  opIdPrefix: 'C' | 'S' = 'C',\n): Promise<void> {\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.log(\n      `ReactGlobalState: useAsyncData data (re-)loading. Path: \"${path || ''}\"`,\n    );\n    /* eslint-enable no-console */\n  }\n  const operationId = opIdPrefix + uuid();\n  const operationIdPath = path ? `${path}.operationId` : 'operationId';\n  globalState.set<ForceT, string>(operationIdPath, operationId);\n\n  const dataOrLoader = loader(\n    oldData || (globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path)).data,\n  );\n\n  const data: DataT = dataOrLoader instanceof Promise\n    ? await dataOrLoader : dataOrLoader;\n\n  const state: AsyncDataEnvelopeT<DataT> = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path);\n  if (operationId === state.operationId) {\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupCollapsed(\n        `ReactGlobalState: useAsyncData data (re-)loaded. Path: \"${\n          path || ''\n        }\"`,\n      );\n      console.log('Data:', cloneDeepForLog(data, path ?? ''));\n      /* eslint-enable no-console */\n    }\n    globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n      ...state,\n      data,\n      operationId: '',\n      timestamp: Date.now(),\n    });\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n  }\n}\n\n/**\n * Resolves asynchronous data, and stores them at given `path` of global\n * state. When multiple components rely on asynchronous data at the same `path`,\n * the data are resolved once, and reused until their age is within specified\n * bounds. Once the data are stale, the hook allows to refresh them. It also\n * garbage-collects stale data from the global state when the last component\n * relying on them is unmounted.\n * @param path Dot-delimitered state path, where data envelop is\n * stored.\n * @param loader Asynchronous function which resolves (loads)\n * data, which should be stored at the global state `path`. When multiple\n * components\n * use `useAsyncData()` hook for the same `path`, the library assumes that all\n * hook instances are called with the same `loader` (_i.e._ whichever of these\n * loaders is used to resolve async data, the result is acceptable to be reused\n * in all related components).\n * @param options Additional options.\n * @param options.deps An array of dependencies, which trigger\n * data reload when changed. Given dependency changes are watched shallowly\n * (similarly to the standard React's\n * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).\n * @param options.noSSR If `true`, this hook won't load data during\n * server-side rendering.\n * @param options.garbageCollectAge The maximum age of data\n * (in milliseconds), after which they are dropped from the state when the last\n * component referencing them via `useAsyncData()` hook unmounts. Defaults to\n * `maxage` option value.\n * @param options.maxage The maximum age of\n * data (in milliseconds) acceptable to the hook's caller. If loaded data are\n * older than this value, `null` is returned instead. Defaults to 5 minutes.\n * @param options.refreshAge The maximum age of data\n * (in milliseconds), after which their refreshment will be triggered when\n * any component referencing them via `useAsyncData()` hook (re-)renders.\n * Defaults to `maxage` value.\n * @return Returns an object with three fields: `data` holds the actual result of\n * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`\n * is a boolean flag, which is `true` if data are being loaded (the hook is\n * waiting for `loader` function resolution); `timestamp` (in milliseconds)\n * is Unix timestamp of related data currently loaded into the global state.\n *\n * Note that loaded data, if any, are stored at the given `path` of global state\n * along with related meta-information, using slightly different state segment\n * structure (see {@link AsyncDataEnvelopeT}). That segment of the global state\n * can be accessed, and even modified using other hooks,\n * _e.g._ {@link useGlobalState}, but doing so you may interfere with related\n * `useAsyncData()` hooks logic.\n */\n\nexport type DataInEnvelopeAtPathT<StateT, PathT extends null | string | undefined>\n= ValueAtPathT<StateT, PathT, never> extends AsyncDataEnvelopeT<unknown>\n  ? Exclude<ValueAtPathT<StateT, PathT, never>['data'], null>\n  : void;\n\ntype HeapT<DataT> = {\n  // Note: these heap fields are necessary to make reload() a stable function.\n  globalState?: GlobalState<unknown>;\n  path?: null | string;\n  loader?: AsyncDataLoaderT<DataT>;\n  reload?: AsyncDataReloaderT<DataT>;\n};\n\nfunction useAsyncData<\n  StateT,\n  PathT extends null | string | undefined,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, PathT> =\n  DataInEnvelopeAtPathT<StateT, PathT>,\n>(\n  path: PathT,\n  loader: AsyncDataLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncData<\n  Forced extends ForceT | LockT = LockT,\n  DataT = void,\n>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncData<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const maxage: number = options.maxage === undefined\n    ? DEFAULT_MAXAGE : options.maxage;\n\n  const refreshAge: number = options.refreshAge === undefined\n    ? maxage : options.refreshAge;\n\n  const garbageCollectAge: number = options.garbageCollectAge === undefined\n    ? maxage : options.garbageCollectAge;\n\n  // Note: here we can't depend on useGlobalState() to init the initial value,\n  // because that way we'll have issues with SSR (see details below).\n  const globalState = getGlobalState();\n  const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n    initialValue: newAsyncDataEnvelope<DataT>(),\n  });\n\n  const { current: heap } = useRef<HeapT<DataT>>({});\n  heap.globalState = globalState;\n  heap.path = path;\n  heap.loader = loader;\n\n  if (!heap.reload) {\n    heap.reload = (customLoader?: AsyncDataLoaderT<DataT>) => {\n      const localLoader = customLoader || heap.loader;\n      if (!localLoader || !heap.globalState) throw Error('Internal error');\n      return load(heap.path, localLoader, heap.globalState, null);\n    };\n  }\n\n  if (globalState.ssrContext && !options.noSSR) {\n    if (!state.timestamp && !state.operationId) {\n      globalState.ssrContext.pending.push(\n        load(path, loader, globalState, state.data, 'S'),\n      );\n    }\n  } else {\n    // This takes care about the client-side reference counting, and garbage\n    // collection.\n    //\n    // Note: the Rules of Hook below are violated by conditional call to a hook,\n    // but as the condition is actually server-side or client-side environment,\n    // it is effectively non-conditional at the runtime.\n    //\n    // TODO: Though, maybe there is a way to refactor it into a cleaner code.\n    // The same applies to other useEffect() hooks below.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';\n      const numRefs = globalState.get<ForceT, number>(numRefsPath);\n      globalState.set<ForceT, number>(numRefsPath, numRefs + 1);\n      return () => {\n        const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n        ForceT, AsyncDataEnvelopeT<DataT>>(\n          path,\n        );\n        if (\n          state2.numRefs === 1\n          && garbageCollectAge < Date.now() - state2.timestamp\n        ) {\n          if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n            /* eslint-disable no-console */\n            console.log(\n              `ReactGlobalState - useAsyncData garbage collected at path ${\n                path || ''\n              }`,\n            );\n            /* eslint-enable no-console */\n          }\n          globalState.dropDependencies(path || '');\n          globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n            ...state2,\n            data: null,\n            numRefs: 0,\n            timestamp: 0,\n          });\n        } else globalState.set<ForceT, number>(numRefsPath, state2.numRefs - 1);\n      };\n    }, [garbageCollectAge, globalState, path]);\n\n    // Note: a bunch of Rules of Hooks ignored belows because in our very\n    // special case the otherwise wrong behavior is actually what we need.\n\n    // Data loading and refreshing.\n    let loadTriggered = false;\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n      ForceT, AsyncDataEnvelopeT<DataT>>(path);\n\n      if (refreshAge < Date.now() - state2.timestamp\n      && (!state2.operationId || state2.operationId.charAt(0) === 'S')) {\n        load(path, loader, globalState, state2.data);\n        loadTriggered = true; // eslint-disable-line react-hooks/exhaustive-deps\n      }\n    });\n\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const { deps } = options;\n      if (deps && globalState.hasChangedDependencies(path || '', deps) && !loadTriggered) {\n        load(path, loader, globalState, null);\n      }\n\n    // Here we need to default to empty array, so that this hook is re-evaluated\n    // only when dependencies specified in options change, and it should not be\n    // re-evaluated at all if no `deps` option is used.\n    }, options.deps || []); // eslint-disable-line react-hooks/exhaustive-deps\n  }\n\n  const [localState] = useGlobalState<ForceT, AsyncDataEnvelopeT<DataT>>(\n    path,\n    newAsyncDataEnvelope<DataT>(),\n  );\n\n  return {\n    data: maxage < Date.now() - localState.timestamp ? null : localState.data,\n    loading: Boolean(localState.operationId),\n    reload: heap.reload,\n    timestamp: localState.timestamp,\n  };\n}\n\nexport { useAsyncData };\n\nexport interface UseAsyncDataI<StateT> {\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"useAsyncData.js","names":["useEffect","useRef","v4","uuid","MIN_MS","getGlobalState","useGlobalState","cloneDeepForLog","isDebugMode","DEFAULT_MAXAGE","newAsyncDataEnvelope","initialData","arguments","length","undefined","numRefs","timestamp","data","operationId","load","path","loader","globalState","old","process","env","NODE_ENV","console","log","operationIdPath","set","definedOld","e","get","dataOrPromise","isAborted","opid","oldDataTimestamp","Promise","state","groupCollapsed","Date","now","groupEnd","useAsyncData","_options$maxage","_options$refreshAge","_options$garbageColle","options","maxage","refreshAge","garbageCollectAge","initialValue","current","heap","reload","customLoader","localLoader","Error","ssrContext","noSSR","pending","push","numRefsPath","state2","dropDependencies","loadTriggered","deps","hasChangedDependencies","charAt","localState","loading","Boolean"],"sources":["../../src/useAsyncData.ts"],"sourcesContent":["/**\n * Loads and uses async data into the GlobalState path.\n */\n\nimport { useEffect, useRef } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport { MIN_MS } from '@dr.pogodin/js-utils';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport useGlobalState from './useGlobalState';\n\nimport {\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  cloneDeepForLog,\n  isDebugMode,\n} from './utils';\n\nimport GlobalState from './GlobalState';\nimport SsrContext from './SsrContext';\n\nexport const DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.\n\nexport type AsyncDataLoaderT<DataT>\n= (oldData: null | DataT, meta: {\n  isAborted: () => boolean;\n  oldDataTimestamp: number;\n}) => DataT | Promise<DataT | null> | null;\n\nexport type AsyncDataReloaderT<DataT>\n= (loader?: AsyncDataLoaderT<DataT>) => Promise<void>;\n\nexport type AsyncDataEnvelopeT<DataT> = {\n  data: null | DataT;\n  numRefs: number;\n  operationId: string;\n  timestamp: number;\n};\n\nexport type OperationIdT = `${'C' | 'S'}${string}`;\n\nexport function newAsyncDataEnvelope<DataT>(\n  initialData: DataT | null = null,\n  { numRefs = 0, timestamp = 0 } = {},\n): AsyncDataEnvelopeT<DataT> {\n  return {\n    data: initialData,\n    numRefs,\n    operationId: '',\n    timestamp,\n  };\n}\n\nexport type UseAsyncDataOptionsT = {\n  deps?: unknown[];\n  garbageCollectAge?: number;\n  maxage?: number;\n  noSSR?: boolean;\n  refreshAge?: number;\n};\n\nexport type UseAsyncDataResT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  reload: AsyncDataReloaderT<DataT>;\n  timestamp: number;\n};\n\n/**\n * Executes the data loading operation.\n * @param path Data segment path inside the global state.\n * @param loader Data loader.\n * @param globalState The global state instance.\n * @param oldData Optional. Previously fetched data, currently stored in\n *  the state, if already fetched by the caller; otherwise, they will be fetched\n *  by the load() function itself.\n * @param opIdPrefix operationId prefix to use, which should be\n * 'C' at the client-side (default), or 'S' at the server-side (within SSR\n * context).\n * @return Resolves once the operation is done.\n * @ignore\n */\nexport async function load<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  globalState: GlobalState<unknown, SsrContext<unknown>>,\n  old?: { data: DataT | null, timestamp: number },\n  operationId: OperationIdT = `C${uuid()}`,\n): Promise<void> {\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.log(\n      `ReactGlobalState: async data (re-)loading. Path: \"${path || ''}\"`,\n    );\n    /* eslint-enable no-console */\n  }\n\n  const operationIdPath = path ? `${path}.operationId` : 'operationId';\n  globalState.set<ForceT, string>(operationIdPath, operationId);\n\n  let definedOld = old;\n  if (!definedOld) {\n    // TODO: Can we improve the typing, to avoid ForceT?\n    const e = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path);\n    definedOld = { data: e.data, timestamp: e.timestamp };\n  }\n\n  const dataOrPromise = loader(definedOld.data, {\n    isAborted: () => {\n      // TODO: Can we improve the typing, to avoid ForceT?\n      const opid = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path).operationId;\n      return opid !== operationId;\n    },\n    oldDataTimestamp: definedOld.timestamp,\n  });\n\n  const data: DataT | null = dataOrPromise instanceof Promise\n    ? await dataOrPromise : dataOrPromise;\n\n  const state: AsyncDataEnvelopeT<DataT> = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path);\n  if (operationId === state.operationId) {\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupCollapsed(\n        `ReactGlobalState: async data (re-)loaded. Path: \"${\n          path || ''\n        }\"`,\n      );\n      console.log('Data:', cloneDeepForLog(data, path ?? ''));\n      /* eslint-enable no-console */\n    }\n    globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n      ...state,\n      data,\n      operationId: '',\n      timestamp: Date.now(),\n    });\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n  }\n}\n\n/**\n * Resolves asynchronous data, and stores them at given `path` of global\n * state.\n */\n\nexport type DataInEnvelopeAtPathT<\n  StateT,\n  PathT extends null | string | undefined,\n> = Exclude<Extract<ValueAtPathT<StateT, PathT, void>, AsyncDataEnvelopeT<unknown>>['data'], null>;\n\ntype HeapT<DataT> = {\n  // Note: these heap fields are necessary to make reload() a stable function.\n  globalState?: GlobalState<unknown>;\n  path?: null | string;\n  loader?: AsyncDataLoaderT<DataT>;\n  reload?: AsyncDataReloaderT<DataT>;\n};\n\nfunction useAsyncData<\n  StateT,\n  PathT extends null | string | undefined,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, PathT> =\n  DataInEnvelopeAtPathT<StateT, PathT>,\n>(\n  path: PathT,\n  loader: AsyncDataLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncData<\n  Forced extends ForceT | LockT = LockT,\n  DataT = void,\n>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncData<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const maxage: number = options.maxage ?? DEFAULT_MAXAGE;\n  const refreshAge: number = options.refreshAge ?? maxage;\n  const garbageCollectAge: number = options.garbageCollectAge ?? maxage;\n\n  // Note: here we can't depend on useGlobalState() to init the initial value,\n  // because that way we'll have issues with SSR (see details below).\n  const globalState = getGlobalState();\n  const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n    initialValue: newAsyncDataEnvelope<DataT>(),\n  });\n\n  const { current: heap } = useRef<HeapT<DataT>>({});\n  heap.globalState = globalState;\n  heap.path = path;\n  heap.loader = loader;\n\n  if (!heap.reload) {\n    heap.reload = (customLoader?: AsyncDataLoaderT<DataT>) => {\n      const localLoader = customLoader || heap.loader;\n      if (!localLoader || !heap.globalState) throw Error('Internal error');\n      return load(heap.path, localLoader, heap.globalState);\n    };\n  }\n\n  if (globalState.ssrContext && !options.noSSR) {\n    if (!state.timestamp && !state.operationId) {\n      globalState.ssrContext.pending.push(\n        load(path, loader, globalState, {\n          data: state.data,\n          timestamp: state.timestamp,\n        }, `S${uuid()}`),\n      );\n    }\n  } else {\n    // This takes care about the client-side reference counting, and garbage\n    // collection.\n    //\n    // Note: the Rules of Hook below are violated by conditional call to a hook,\n    // but as the condition is actually server-side or client-side environment,\n    // it is effectively non-conditional at the runtime.\n    //\n    // TODO: Though, maybe there is a way to refactor it into a cleaner code.\n    // The same applies to other useEffect() hooks below.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';\n      const numRefs = globalState.get<ForceT, number>(numRefsPath);\n      globalState.set<ForceT, number>(numRefsPath, numRefs + 1);\n      return () => {\n        const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n        ForceT, AsyncDataEnvelopeT<DataT>>(\n          path,\n        );\n        if (\n          state2.numRefs === 1\n          && garbageCollectAge < Date.now() - state2.timestamp\n        ) {\n          if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n            /* eslint-disable no-console */\n            console.log(\n              `ReactGlobalState - useAsyncData garbage collected at path ${\n                path || ''\n              }`,\n            );\n            /* eslint-enable no-console */\n          }\n          globalState.dropDependencies(path || '');\n          globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n            ...state2,\n            data: null,\n            numRefs: 0,\n            timestamp: 0,\n          });\n        } else globalState.set<ForceT, number>(numRefsPath, state2.numRefs - 1);\n      };\n    }, [garbageCollectAge, globalState, path]);\n\n    // Note: a bunch of Rules of Hooks ignored belows because in our very\n    // special case the otherwise wrong behavior is actually what we need.\n\n    // Data loading and refreshing.\n    let loadTriggered = false;\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n      ForceT, AsyncDataEnvelopeT<DataT>>(path);\n\n      const { deps } = options;\n      if (\n        // The hook is called with a list of dependencies, that mismatch\n        // dependencies last used to retrieve the data at given path.\n        (deps && globalState.hasChangedDependencies(path || '', deps))\n\n        // Data at the path are stale, and are not being loaded.\n        || (\n          refreshAge < Date.now() - state2.timestamp\n          && (!state2.operationId || state2.operationId.charAt(0) === 'S')\n        )\n      ) {\n        loadTriggered = true; // eslint-disable-line react-hooks/exhaustive-deps\n        if (!deps) globalState.dropDependencies(path || '');\n        load(path, loader, globalState, {\n          data: state2.data,\n          timestamp: state2.timestamp,\n        });\n      }\n    });\n\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const { deps } = options;\n      if (\n        deps\n        && globalState.hasChangedDependencies(path || '', deps)\n        && !loadTriggered\n      ) {\n        load(path, loader, globalState);\n      }\n\n    // Here we need to default to empty array, so that this hook is re-evaluated\n    // only when dependencies specified in options change, and it should not be\n    // re-evaluated at all if no `deps` option is used.\n    }, options.deps || []); // eslint-disable-line react-hooks/exhaustive-deps\n  }\n\n  const [localState] = useGlobalState<ForceT, AsyncDataEnvelopeT<DataT>>(\n    path,\n    newAsyncDataEnvelope<DataT>(),\n  );\n\n  return {\n    data: maxage < Date.now() - localState.timestamp ? null : localState.data,\n    loading: Boolean(localState.operationId),\n    reload: heap.reload,\n    timestamp: localState.timestamp,\n  };\n}\n\nexport { useAsyncData };\n\nexport interface UseAsyncDataI<StateT> {\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/types/index.d.ts

@@ -1,14 +1,13 @@
 import GlobalState from './GlobalState';
 import GlobalStateProvider, { getGlobalState, getSsrContext } from './GlobalStateProvider';
 import SsrContext from './SsrContext';
-import useAsyncCollection, { type UseAsyncCollectionI } from './useAsyncCollection';
-import { type UseAsyncDataI, newAsyncDataEnvelope } from './useAsyncData';
+import useAsyncCollection, { type UseAsyncCollectionI, type UseAsyncCollectionResT } from './useAsyncCollection';
+import { type AsyncDataEnvelopeT, type AsyncDataLoaderT, type AsyncDataReloaderT, type UseAsyncDataI, type UseAsyncDataResT, newAsyncDataEnvelope, useAsyncData } from './useAsyncData';
 import useGlobalState, { type UseGlobalStateI } from './useGlobalState';
 export type { AsyncCollectionLoaderT } from './useAsyncCollection';
-export * from './useAsyncData';
 export type { SetterT, UseGlobalStateResT } from './useGlobalState';
 export type { ForceT, ValueOrInitializerT } from './utils';
-export { getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, SsrContext, useAsyncCollection, useGlobalState, };
+export { type AsyncDataEnvelopeT, type AsyncDataLoaderT, type AsyncDataReloaderT, type UseAsyncCollectionResT, type UseAsyncDataResT, getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, newAsyncDataEnvelope, SsrContext, useAsyncCollection, useAsyncData, useGlobalState, };
 interface API<StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>> {
     getGlobalState: typeof getGlobalState<StateT, SsrContextT>;
     getSsrContext: typeof getSsrContext<SsrContextT>;