@dr.pogodin/react-global-state 0.19.1 → 0.19.3

package/build/cjs/useGlobalState.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lodash = require("lodash");
+var _react = require("react");
+var _jsUtils = require("@dr.pogodin/js-utils");
+var _GlobalStateProvider = require("./GlobalStateProvider");
+var _utils = require("./utils");
+// Hook for updates of global state.
+
+/**
+ * The primary hook for interacting with the global state, modeled after
+ * the standard React's
+ * [useState](https://reactjs.org/docs/hooks-reference.html#usestate).
+ * It subscribes a component to a given `path` of global state, and provides
+ * a function to update it. Each time the value at `path` changes, the hook
+ * triggers re-render of its host component.
+ *
+ * **Note:**
+ * - For performance, the library does not copy objects written to / read from
+ *   global state paths. You MUST NOT manually mutate returned state values,
+ *   or change objects already written into the global state, without explicitly
+ *   clonning them first yourself.
+ * - State update notifications are asynchronous. When your code does multiple
+ *   global state updates in the same React rendering cycle, all state update
+ *   notifications are queued and dispatched together, after the current
+ *   rendering cycle. In other words, in any given rendering cycle the global
+ *   state values are "fixed", and all changes becomes visible at once in the
+ *   next triggered rendering pass.
+ *
+ * @param path Dot-delimitered state path. It can be undefined to
+ * subscribe for entire state.
+ *
+ * Under-the-hood state values are read and written using `lodash`
+ * [_.get()](https://lodash.com/docs/4.17.15#get) and
+ * [_.set()](https://lodash.com/docs/4.17.15#set) methods, thus it is safe
+ * to access state paths which have not been created before.
+ * @param initialValue Initial value to set at the `path`, or its
+ * factory:
+ * - If a function is given, it will act similar to
+ *   [the lazy initial state of the standard React's useState()](https://reactjs.org/docs/hooks-reference.html#lazy-initial-state):
+ *   only if the value at `path` is `undefined`, the function will be executed,
+ *   and the value it returns will be written to the `path`.
+ * - Otherwise, the given value itself will be written to the `path`,
+ *   if the current value at `path` is `undefined`.
+ * @return It returs an array with two elements: `[value, setValue]`:
+ *
+ * - The `value` is the current value at given `path`.
+ *
+ * - The `setValue()` is setter function to write a new value to the `path`.
+ *
+ *   Similar to the standard React's `useState()`, it supports
+ *   [functional value updates](https://reactjs.org/docs/hooks-reference.html#functional-updates):
+ *   if `setValue()` is called with a function as argument, that function will
+ *   be called and its return value will be written to `path`. Otherwise,
+ *   the argument of `setValue()` itself is written to `path`.
+ *
+ *   Also, similar to the standard React's state setters, `setValue()` is
+ *   stable function: it does not change between component re-renders.
+ */
+
+// "Enforced type overload"
+
+// "Entire state overload"
+
+// "State evaluation overload"
+
+function useGlobalState(path,
+// TODO: Revise it later!
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+initialValue
+
+// TODO: Revise it later!
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  const globalState = (0, _GlobalStateProvider.getGlobalState)();
+  const ref = (0, _react.useRef)(undefined);
+
+  // TODO: Revise how this `rc` variable is used, perhaps we can simplify stuff
+  // here.
+  let rc = ref.current;
+  if (!ref.current) {
+    const emitter = new _jsUtils.Emitter();
+    ref.current = {
+      emitter,
+      globalState,
+      path,
+      setter: value => {
+        const newState = (0, _lodash.isFunction)(value) ? value(rc.globalState.get(rc.path)) : value;
+        if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
+          /* eslint-disable no-console */
+          console.groupCollapsed(`ReactGlobalState - useGlobalState setter triggered for path ${rc.path ?? ''}`);
+          console.log('New value:', (0, _utils.cloneDeepForLog)(newState, rc.path ?? ''));
+          console.groupEnd();
+          /* eslint-enable no-console */
+        }
+        rc.globalState.set(rc.path, newState);
+
+        // NOTE: The regular global state's update notifications, automatically
+        // triggered by the rc.globalState.set() call above, are batched, and
+        // scheduled to fire asynchronosuly at a later time, which is problematic
+        // for managed text inputs - if they have their value update delayed to
+        // future render cycles, it will result in reset of their cursor position
+        // to the value end. Calling the rc.emitter.emit() below causes a sooner
+        // state update for the current component, thus working around the issue.
+        // For additional details see the original issue:
+        // https://github.com/birdofpreyru/react-global-state/issues/22
+        if (newState !== rc.state) rc.emitter.emit();
+      },
+      state: (0, _lodash.isFunction)(initialValue) ? initialValue() : initialValue,
+      subscribe: emitter.addListener.bind(emitter),
+      watcher: () => {
+        // TODO: Revise it later.
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+        const state = rc.globalState.get(rc.path);
+        if (state !== rc.state) rc.emitter.emit();
+      }
+    };
+  }
+  rc = ref.current;
+  rc.globalState = globalState;
+  rc.path = path;
+  rc.state = (0, _react.useSyncExternalStore)(rc.subscribe, () => rc.globalState.get(rc.path, {
+    initialValue
+  }), () => rc.globalState.get(rc.path, {
+    initialState: true,
+    initialValue
+  }));
+  (0, _react.useEffect)(() => {
+    const {
+      watcher
+    } = ref.current;
+    globalState.watch(watcher);
+    watcher();
+    return () => {
+      globalState.unWatch(watcher);
+    };
+  }, [globalState]);
+  (0, _react.useEffect)(() => {
+    ref.current.watcher();
+  }, [path]);
+  return [rc.state, rc.setter];
+}
+var _default = exports.default = useGlobalState; // TODO: Revise.
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+//# sourceMappingURL=useGlobalState.js.map

package/build/cjs/useGlobalState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlobalState.js","names":["_lodash","require","_react","_jsUtils","_GlobalStateProvider","_utils","useGlobalState","path","initialValue","globalState","getGlobalState","ref","useRef","undefined","rc","current","emitter","Emitter","setter","value","newState","isFunction","get","process","env","NODE_ENV","isDebugMode","console","groupCollapsed","log","cloneDeepForLog","groupEnd","set","state","emit","subscribe","addListener","bind","watcher","useSyncExternalStore","initialState","useEffect","watch","unWatch","_default","exports","default"],"sources":["../../src/useGlobalState.ts"],"sourcesContent":["// Hook for updates of global state.\n\nimport { isFunction } from 'lodash';\n\nimport {\n  type Dispatch,\n  type SetStateAction,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\n\nimport { Emitter } from '@dr.pogodin/js-utils';\n\nimport type GlobalState from './GlobalState';\nimport { getGlobalState } from './GlobalStateProvider';\n\nimport {\n  type CallbackT,\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  type ValueOrInitializerT,\n  cloneDeepForLog,\n  isDebugMode,\n} from './utils';\n\nexport type SetterT<T> = Dispatch<SetStateAction<T>>;\n\ntype ListenerT = () => void;\n\ntype GlobalStateRef = {\n  emitter: Emitter<[]>;\n  globalState: GlobalState<unknown>;\n  path: null | string | undefined;\n  setter: SetterT<unknown>;\n  subscribe: (listener: ListenerT) => () => void;\n  state: unknown;\n  watcher: CallbackT;\n};\n\nexport type UseGlobalStateResT<T> = [T, SetterT<T>];\n\n/**\n * The primary hook for interacting with the global state, modeled after\n * the standard React's\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate).\n * It subscribes a component to a given `path` of global state, and provides\n * a function to update it. Each time the value at `path` changes, the hook\n * triggers re-render of its host component.\n *\n * **Note:**\n * - For performance, the library does not copy objects written to / read from\n *   global state paths. You MUST NOT manually mutate returned state values,\n *   or change objects already written into the global state, without explicitly\n *   clonning them first yourself.\n * - State update notifications are asynchronous. When your code does multiple\n *   global state updates in the same React rendering cycle, all state update\n *   notifications are queued and dispatched together, after the current\n *   rendering cycle. In other words, in any given rendering cycle the global\n *   state values are \"fixed\", and all changes becomes visible at once in the\n *   next triggered rendering pass.\n *\n * @param path Dot-delimitered state path. It can be undefined to\n * subscribe for entire state.\n *\n * Under-the-hood state values are read and written using `lodash`\n * [_.get()](https://lodash.com/docs/4.17.15#get) and\n * [_.set()](https://lodash.com/docs/4.17.15#set) methods, thus it is safe\n * to access state paths which have not been created before.\n * @param initialValue Initial value to set at the `path`, or its\n * factory:\n * - If a function is given, it will act similar to\n *   [the lazy initial state of the standard React's useState()](https://reactjs.org/docs/hooks-reference.html#lazy-initial-state):\n *   only if the value at `path` is `undefined`, the function will be executed,\n *   and the value it returns will be written to the `path`.\n * - Otherwise, the given value itself will be written to the `path`,\n *   if the current value at `path` is `undefined`.\n * @return It returs an array with two elements: `[value, setValue]`:\n *\n * - The `value` is the current value at given `path`.\n *\n * - The `setValue()` is setter function to write a new value to the `path`.\n *\n *   Similar to the standard React's `useState()`, it supports\n *   [functional value updates](https://reactjs.org/docs/hooks-reference.html#functional-updates):\n *   if `setValue()` is called with a function as argument, that function will\n *   be called and its return value will be written to `path`. Otherwise,\n *   the argument of `setValue()` itself is written to `path`.\n *\n *   Also, similar to the standard React's state setters, `setValue()` is\n *   stable function: it does not change between component re-renders.\n */\n\n// \"Enforced type overload\"\nfunction useGlobalState<\n  Forced extends ForceT | LockT = LockT,\n  ValueT = void,\n>(\n  path: null | string | undefined,\n  initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n\n// \"Entire state overload\"\nfunction useGlobalState<StateT>(): UseGlobalStateResT<StateT>;\n\n// \"State evaluation overload\"\nfunction useGlobalState<\n  StateT,\n  PathT extends null | string | undefined,\n>(\n  path: PathT,\n  initialValue: ValueOrInitializerT<\n    Exclude<ValueAtPathT<StateT, PathT, never>, undefined>>\n): UseGlobalStateResT<Exclude<ValueAtPathT<StateT, PathT, void>, undefined>>;\n\nfunction useGlobalState<\n  StateT,\n  PathT extends null | string | undefined,\n>(\n  path: PathT,\n  initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>\n): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;\n\nfunction useGlobalState(\n  path?: null | string,\n  // TODO: Revise it later!\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  initialValue?: ValueOrInitializerT<any>,\n\n  // TODO: Revise it later!\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): UseGlobalStateResT<any> {\n  const globalState = getGlobalState();\n\n  const ref = useRef<GlobalStateRef>(undefined);\n\n  // TODO: Revise how this `rc` variable is used, perhaps we can simplify stuff\n  // here.\n  let rc: GlobalStateRef | undefined = ref.current;\n  if (!ref.current) {\n    const emitter = new Emitter();\n    ref.current = {\n      emitter,\n      globalState,\n      path,\n      setter: (value) => {\n        const newState = isFunction(value)\n          ? value(rc!.globalState.get(rc!.path)) as unknown\n          : value;\n\n        if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n          /* eslint-disable no-console */\n          console.groupCollapsed(\n            `ReactGlobalState - useGlobalState setter triggered for path ${\n              rc!.path ?? ''\n            }`,\n          );\n          console.log('New value:', cloneDeepForLog(newState, rc!.path ?? ''));\n          console.groupEnd();\n          /* eslint-enable no-console */\n        }\n        rc!.globalState.set<ForceT, unknown>(rc!.path, newState);\n\n        // NOTE: The regular global state's update notifications, automatically\n        // triggered by the rc.globalState.set() call above, are batched, and\n        // scheduled to fire asynchronosuly at a later time, which is problematic\n        // for managed text inputs - if they have their value update delayed to\n        // future render cycles, it will result in reset of their cursor position\n        // to the value end. Calling the rc.emitter.emit() below causes a sooner\n        // state update for the current component, thus working around the issue.\n        // For additional details see the original issue:\n        // https://github.com/birdofpreyru/react-global-state/issues/22\n        if (newState !== rc!.state) rc!.emitter.emit();\n      },\n      state: isFunction(initialValue) ? initialValue() : initialValue,\n      subscribe: emitter.addListener.bind(emitter),\n      watcher: () => {\n        // TODO: Revise it later.\n        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n        const state = rc!.globalState.get(rc!.path) as unknown;\n        if (state !== rc!.state) rc!.emitter.emit();\n      },\n    };\n  }\n  rc = ref.current!;\n\n  rc.globalState = globalState;\n  rc.path = path;\n\n  rc.state = useSyncExternalStore(\n    rc.subscribe,\n    () => rc.globalState.get<ForceT, unknown>(rc.path, { initialValue }),\n\n    () => rc.globalState.get<ForceT, unknown>(\n      rc.path,\n      { initialState: true, initialValue },\n    ),\n  );\n\n  useEffect(() => {\n    const { watcher } = ref.current!;\n    globalState.watch(watcher);\n    watcher();\n    return () => {\n      globalState.unWatch(watcher);\n    };\n  }, [globalState]);\n\n  useEffect(() => {\n    ref.current!.watcher();\n  }, [path]);\n\n  return [rc.state, rc.setter];\n}\n\nexport default useGlobalState;\n\n// TODO: Revise.\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport interface UseGlobalStateI<StateT> {\n  (): UseGlobalStateResT<StateT>;\n\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    initialValue: ValueOrInitializerT<\n      Exclude<ValueAtPathT<StateT, PathT, never>, undefined>>\n  ): UseGlobalStateResT<Exclude<ValueAtPathT<StateT, PathT, void>, undefined>>;\n\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>\n  ): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;\n\n  <Forced extends ForceT | LockT = LockT, ValueT = unknown>(\n    path: null | string | undefined,\n    initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n  ): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/cjs/utils.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloneDeepForLog = cloneDeepForLog;
+exports.escape = escape;
+exports.hash = hash;
+exports.isDebugMode = isDebugMode;
+var _lodash = require("lodash");
+// TODO: This (ForceT, LockT, and TypeLock) probably should be moved to JS Utils
+// lib.
+
+/**
+ * Given the type of state, `StateT`, and the type of state path, `PathT`,
+ * it evaluates the type of value at that path of the state, if it can be
+ * evaluated from the path type (it is possible when `PathT` is a string
+ * literal type, and `StateT` elements along this path have appropriate
+ * types); otherwise it falls back to the specified `UnknownT` type,
+ * which should be set either `never` (for input arguments), or `void`
+ * (for return types) - `never` and `void` in those places forbid assignments,
+ * and are not auto-inferred to more permissible types.
+ *
+ * BEWARE: When StateT is any the construct resolves to any for any string
+ * paths.
+ */
+
+/**
+ * Returns 'true' if debug logging should be performed; 'false' otherwise.
+ *
+ * BEWARE: The actual safeguards for the debug logging still should read
+ *  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
+ *    // Some debug logging
+ *  }
+ * to ensure that debug code is stripped out by Webpack in production mode.
+ *
+ * @returns
+ * @ignore
+ */
+function isDebugMode() {
+  try {
+    return process.env.NODE_ENV !== 'production' && !!process.env.REACT_GLOBAL_STATE_DEBUG;
+  } catch {
+    return false;
+  }
+}
+const cloneDeepBailKeys = new Set();
+
+/**
+ * Deep-clones given value for logging purposes, or returns the value itself
+ * if the previous clone attempt, with the same key, took more than 300ms
+ * (to avoid situations when large payload in the global state slows down
+ * development versions of the app due to the logging overhead).
+ */
+function cloneDeepForLog(value, key = '') {
+  if (cloneDeepBailKeys.has(key)) {
+    // eslint-disable-next-line no-console
+    console.warn(`The logged value won't be clonned (key "${key}").`);
+    return value;
+  }
+  const start = Date.now();
+  const res = (0, _lodash.cloneDeep)(value);
+  const time = Date.now() - start;
+  if (time > 300) {
+    // eslint-disable-next-line no-console
+    console.warn(`${time}ms spent to clone the logged value (key "${key}").`);
+    cloneDeepBailKeys.add(key);
+  }
+  return res;
+}
+
+/**
+ * Converts given value to an escaped string. For now, we are good with the most
+ * trivial escape logic:
+ *  - '%' characters are replaced by '%0' code pair;
+ *  - '/' characters are replaced by '%1' code pair.
+ */
+function escape(x) {
+  return typeof x === 'string' ? x.replace(/%/g, '%0').replace(/\//g, '%1') : x.toString();
+}
+
+/**
+ * Hashes given string array. For our current needs we are fine to go with
+ * the most trivial implementation, which probably should not be called "hash"
+ * in the strict sense: we just escape each given string to not include '/'
+ * characters, and then we join all those strings using '/' as the separator.
+ */
+function hash(items) {
+  return items.map(escape).join('/');
+}
+//# sourceMappingURL=utils.js.map

package/build/cjs/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["_lodash","require","isDebugMode","process","env","NODE_ENV","REACT_GLOBAL_STATE_DEBUG","cloneDeepBailKeys","Set","cloneDeepForLog","value","key","has","console","warn","start","Date","now","res","cloneDeep","time","add","escape","x","replace","toString","hash","items","map","join"],"sources":["../../src/utils.ts"],"sourcesContent":["import { type GetFieldType, cloneDeep } from 'lodash';\n\nexport type CallbackT = () => void;\n\n// TODO: This (ForceT, LockT, and TypeLock) probably should be moved to JS Utils\n// lib.\n\nexport declare const force: unique symbol;\nexport declare const lock: unique symbol;\n\nexport type ForceT = typeof force;\nexport type LockT = typeof lock;\n\nexport type TypeLock<\n  Unlocked extends ForceT | LockT,\n\n  // TODO: Revise later.\n  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\n  LockedT extends never | void,\n  UnlockedT,\n> = Unlocked extends ForceT ? UnlockedT : LockedT;\n\n/**\n * Given the type of state, `StateT`, and the type of state path, `PathT`,\n * it evaluates the type of value at that path of the state, if it can be\n * evaluated from the path type (it is possible when `PathT` is a string\n * literal type, and `StateT` elements along this path have appropriate\n * types); otherwise it falls back to the specified `UnknownT` type,\n * which should be set either `never` (for input arguments), or `void`\n * (for return types) - `never` and `void` in those places forbid assignments,\n * and are not auto-inferred to more permissible types.\n *\n * BEWARE: When StateT is any the construct resolves to any for any string\n * paths.\n */\nexport type ValueAtPathT<\n  StateT,\n  PathT extends null | string | undefined,\n\n  // TODO: Revise later.\n  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-invalid-void-type\n  UnknownT extends never | undefined | void,\n> = unknown extends StateT\n  ? UnknownT\n  : string extends PathT\n    ? UnknownT\n    : PathT extends null | undefined\n      ? StateT\n      : GetFieldType<StateT, PathT> extends undefined\n        ? UnknownT : GetFieldType<StateT, PathT>;\n\nexport type ValueOrInitializerT<ValueT> = ValueT | (() => ValueT);\n\n/**\n * Returns 'true' if debug logging should be performed; 'false' otherwise.\n *\n * BEWARE: The actual safeguards for the debug logging still should read\n *  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n *    // Some debug logging\n *  }\n * to ensure that debug code is stripped out by Webpack in production mode.\n *\n * @returns\n * @ignore\n */\nexport function isDebugMode(): boolean {\n  try {\n    return process.env.NODE_ENV !== 'production'\n      && !!process.env.REACT_GLOBAL_STATE_DEBUG;\n  } catch {\n    return false;\n  }\n}\n\nconst cloneDeepBailKeys = new Set<string>();\n\n/**\n * Deep-clones given value for logging purposes, or returns the value itself\n * if the previous clone attempt, with the same key, took more than 300ms\n * (to avoid situations when large payload in the global state slows down\n * development versions of the app due to the logging overhead).\n */\nexport function cloneDeepForLog<T>(value: T, key: string = ''): T {\n  if (cloneDeepBailKeys.has(key)) {\n    // eslint-disable-next-line no-console\n    console.warn(`The logged value won't be clonned (key \"${key}\").`);\n    return value;\n  }\n\n  const start = Date.now();\n  const res = cloneDeep(value);\n  const time = Date.now() - start;\n  if (time > 300) {\n    // eslint-disable-next-line no-console\n    console.warn(`${time}ms spent to clone the logged value (key \"${key}\").`);\n    cloneDeepBailKeys.add(key);\n  }\n\n  return res;\n}\n\n/**\n * Converts given value to an escaped string. For now, we are good with the most\n * trivial escape logic:\n *  - '%' characters are replaced by '%0' code pair;\n *  - '/' characters are replaced by '%1' code pair.\n */\nexport function escape(x: number | string): string {\n  return typeof x === 'string'\n    ? x.replace(/%/g, '%0').replace(/\\//g, '%1')\n    : x.toString();\n}\n\n/**\n * Hashes given string array. For our current needs we are fine to go with\n * the most trivial implementation, which probably should not be called \"hash\"\n * in the strict sense: we just escape each given string to not include '/'\n * characters, and then we join all those strings using '/' as the separator.\n */\nexport function hash(items: Array<number | string>): string {\n  return items.map(escape).join('/');\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAIA;AACA;;AAiBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAmBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,WAAWA,CAAA,EAAY;EACrC,IAAI;IACF,OAAOC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,IACvC,CAAC,CAACF,OAAO,CAACC,GAAG,CAACE,wBAAwB;EAC7C,CAAC,CAAC,MAAM;IACN,OAAO,KAAK;EACd;AACF;AAEA,MAAMC,iBAAiB,GAAG,IAAIC,GAAG,CAAS,CAAC;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,eAAeA,CAAIC,KAAQ,EAAEC,GAAW,GAAG,EAAE,EAAK;EAChE,IAAIJ,iBAAiB,CAACK,GAAG,CAACD,GAAG,CAAC,EAAE;IAC9B;IACAE,OAAO,CAACC,IAAI,CAAC,2CAA2CH,GAAG,KAAK,CAAC;IACjE,OAAOD,KAAK;EACd;EAEA,MAAMK,KAAK,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;EACxB,MAAMC,GAAG,GAAG,IAAAC,iBAAS,EAACT,KAAK,CAAC;EAC5B,MAAMU,IAAI,GAAGJ,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGF,KAAK;EAC/B,IAAIK,IAAI,GAAG,GAAG,EAAE;IACd;IACAP,OAAO,CAACC,IAAI,CAAC,GAAGM,IAAI,4CAA4CT,GAAG,KAAK,CAAC;IACzEJ,iBAAiB,CAACc,GAAG,CAACV,GAAG,CAAC;EAC5B;EAEA,OAAOO,GAAG;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,MAAMA,CAACC,CAAkB,EAAU;EACjD,OAAO,OAAOA,CAAC,KAAK,QAAQ,GACxBA,CAAC,CAACC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAACA,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,GAC1CD,CAAC,CAACE,QAAQ,CAAC,CAAC;AAClB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,IAAIA,CAACC,KAA6B,EAAU;EAC1D,OAAOA,KAAK,CAACC,GAAG,CAACN,MAAM,CAAC,CAACO,IAAI,CAAC,GAAG,CAAC;AACpC","ignoreList":[]}

package/build/code/GlobalStateProvider.js

@@ -36,8 +36,7 @@ export function getGlobalState() {
  * - If `throwWithoutSsrContext` is `true`, and there is no SSR context attached
  *   to the global state provided by {@link <GlobalStateProvider>}.
  */
-export function getSsrContext() {
-  let throwWithoutSsrContext = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+export function getSsrContext(throwWithoutSsrContext = true) {
   const {
     ssrContext
   } = getGlobalState();
@@ -59,11 +58,10 @@ export function getSsrContext() {
  * - If `GlobalState` instance, it will be used by this provider.
  * - If not given, a new `GlobalState` instance will be created and used.
  */
-const GlobalStateProvider = _ref => {
-  let {
-    children,
-    ...rest
-  } = _ref;
+const GlobalStateProvider = ({
+  children,
+  ...rest
+}) => {
   const localStateRef = useRef(undefined);
   let state;
   // TODO: Revise.

package/build/code/GlobalStateProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalStateProvider.js","names":["isFunction","createContext","use","useRef","GlobalState","jsx","_jsx","Context","getGlobalState","globalState","Error","getSsrContext","throwWithoutSsrContext","arguments","length","undefined","ssrContext","GlobalStateProvider","_ref","children","rest","localStateRef","state","stateProxy","current","initialState","value"],"sources":["../../src/GlobalStateProvider.tsx"],"sourcesContent":["import { isFunction } from 'lodash';\n\nimport {\n  type ReactNode,\n  createContext,\n  use,\n  useRef,\n} from 'react';\n\nimport GlobalState from './GlobalState';\nimport type SsrContext from './SsrContext';\n\nimport type { ValueOrInitializerT } from './utils';\n\nconst Context = createContext<GlobalState<unknown> | null>(null);\n\n/**\n * Gets {@link GlobalState} instance from the context. In most cases\n * you should use {@link useGlobalState}, and other hooks to interact with\n * the global state, instead of accessing it directly.\n * @return\n */\nexport function getGlobalState<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(): GlobalState<StateT, SsrContextT> {\n  // TODO: Think about it: on one hand we on purpose called this function\n  // as getGlobalState(), so that ppl looking for the state hook prefer using\n  // useGlobalState(), while this getGlobalState() is reserved for nieche cases;\n  // on the other hand, perhaps we can rename it into useSomething, to both\n  // follow conventions, and to keep stuff clearly named at the same time.\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const globalState = use(Context);\n  if (!globalState) throw new Error('Missing GlobalStateProvider');\n  return globalState as GlobalState<StateT, SsrContextT>;\n}\n\n/**\n * @category Hooks\n * @desc Gets SSR context.\n * @param throwWithoutSsrContext If `true` (default),\n * this hook will throw if no SSR context is attached to the global state;\n * set `false` to not throw in such case. In either case the hook will throw\n * if the {@link &lt;GlobalStateProvider&gt;} (hence the state) is missing.\n * @returns SSR context.\n * @throws\n * - If current component has no parent {@link &lt;GlobalStateProvider&gt;}\n *   in the rendered React tree.\n * - If `throwWithoutSsrContext` is `true`, and there is no SSR context attached\n *   to the global state provided by {@link &lt;GlobalStateProvider&gt;}.\n */\nexport function getSsrContext<\n  SsrContextT extends SsrContext<unknown>,\n>(\n  throwWithoutSsrContext = true,\n): SsrContextT | undefined {\n  const { ssrContext } = getGlobalState<SsrContextT['state'], SsrContextT>();\n  if (!ssrContext && throwWithoutSsrContext) {\n    throw new Error('No SSR context found');\n  }\n  return ssrContext;\n}\n\ntype NewStateProps<StateT, SsrContextT extends SsrContext<StateT>> = {\n  initialState: ValueOrInitializerT<StateT>;\n  ssrContext?: SsrContextT;\n};\n\ntype GlobalStateProviderProps<\n  StateT,\n  SsrContextT extends SsrContext<StateT>,\n> = {\n  children?: ReactNode;\n} & (NewStateProps<StateT, SsrContextT> | {\n  stateProxy: true | GlobalState<StateT, SsrContextT>;\n});\n\n/**\n * Provides global state to its children.\n * @param prop.children Component children, which will be provided with\n * the global state, and rendered in place of the provider.\n * @param prop.initialState Initial content of the global state.\n * @param prop.ssrContext Server-side rendering (SSR) context.\n * @param prop.stateProxy This option is useful for code\n * splitting and SSR implementation:\n * - If `true`, this provider instance will fetch and reuse the global state\n *   from a parent provider.\n * - If `GlobalState` instance, it will be used by this provider.\n * - If not given, a new `GlobalState` instance will be created and used.\n */\nconst GlobalStateProvider = <\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(\n  { children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>,\n): ReactNode => {\n  type GST = GlobalState<StateT, SsrContextT>;\n  const localStateRef = useRef<GST>(undefined);\n  let state: GST;\n  // TODO: Revise.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if ('stateProxy' in rest && rest.stateProxy) {\n    localStateRef.current = undefined;\n    state = rest.stateProxy === true ? getGlobalState() : rest.stateProxy;\n  } else {\n    if (!localStateRef.current) {\n      const {\n        initialState,\n        ssrContext,\n      } = rest as NewStateProps<StateT, SsrContextT>;\n      localStateRef.current = new GlobalState(\n        isFunction(initialState) ? initialState() : initialState,\n        ssrContext,\n      );\n    }\n    state = localStateRef.current;\n  }\n  return <Context value={state}>{children}</Context>;\n};\n\nexport default GlobalStateProvider;\n"],"mappings":"AAAA,SAASA,UAAU,QAAQ,QAAQ;AAEnC,SAEEC,aAAa,EACbC,GAAG,EACHC,MAAM,QACD,OAAO;AAEd,OAAOC,WAAW;AAAsB,SAAAC,GAAA,IAAAC,IAAA;AAKxC,MAAMC,OAAO,gBAAGN,aAAa,CAA8B,IAAI,CAAC;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASO,cAAcA,CAAA,EAGQ;EACpC;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,WAAW,GAAGP,GAAG,CAACK,OAAO,CAAC;EAChC,IAAI,CAACE,WAAW,EAAE,MAAM,IAAIC,KAAK,CAAC,6BAA6B,CAAC;EAChE,OAAOD,WAAW;AACpB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,aAAaA,CAAA,EAIF;EAAA,IADzBC,sBAAsB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,IAAI;EAE7B,MAAM;IAAEG;EAAW,CAAC,GAAGR,cAAc,CAAoC,CAAC;EAC1E,IAAI,CAACQ,UAAU,IAAIJ,sBAAsB,EAAE;IACzC,MAAM,IAAIF,KAAK,CAAC,sBAAsB,CAAC;EACzC;EACA,OAAOM,UAAU;AACnB;AAgBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,GAAGC,IAAA,IAKZ;EAAA,IADd;IAAEC,QAAQ;IAAE,GAAGC;EAAoD,CAAC,GAAAF,IAAA;EAGpE,MAAMG,aAAa,GAAGlB,MAAM,CAAMY,SAAS,CAAC;EAC5C,IAAIO,KAAU;EACd;EACA;EACA,IAAI,YAAY,IAAIF,IAAI,IAAIA,IAAI,CAACG,UAAU,EAAE;IAC3CF,aAAa,CAACG,OAAO,GAAGT,SAAS;IACjCO,KAAK,GAAGF,IAAI,CAACG,UAAU,KAAK,IAAI,GAAGf,cAAc,CAAC,CAAC,GAAGY,IAAI,CAACG,UAAU;EACvE,CAAC,MAAM;IACL,IAAI,CAACF,aAAa,CAACG,OAAO,EAAE;MAC1B,MAAM;QACJC,YAAY;QACZT;MACF,CAAC,GAAGI,IAA0C;MAC9CC,aAAa,CAACG,OAAO,GAAG,IAAIpB,WAAW,CACrCJ,UAAU,CAACyB,YAAY,CAAC,GAAGA,YAAY,CAAC,CAAC,GAAGA,YAAY,EACxDT,UACF,CAAC;IACH;IACAM,KAAK,GAAGD,aAAa,CAACG,OAAO;EAC/B;EACA,oBAAOlB,IAAA,CAACC,OAAO;IAACmB,KAAK,EAAEJ,KAAM;IAAAH,QAAA,EAAEA;EAAQ,CAAU,CAAC;AACpD,CAAC;AAED,eAAeF,mBAAmB","ignoreList":[]}
+{"version":3,"file":"GlobalStateProvider.js","names":["isFunction","createContext","use","useRef","GlobalState","jsx","_jsx","Context","getGlobalState","globalState","Error","getSsrContext","throwWithoutSsrContext","ssrContext","GlobalStateProvider","children","rest","localStateRef","undefined","state","stateProxy","current","initialState","value"],"sources":["../../src/GlobalStateProvider.tsx"],"sourcesContent":["import { isFunction } from 'lodash';\n\nimport {\n  type ReactNode,\n  createContext,\n  use,\n  useRef,\n} from 'react';\n\nimport GlobalState from './GlobalState';\nimport type SsrContext from './SsrContext';\n\nimport type { ValueOrInitializerT } from './utils';\n\nconst Context = createContext<GlobalState<unknown> | null>(null);\n\n/**\n * Gets {@link GlobalState} instance from the context. In most cases\n * you should use {@link useGlobalState}, and other hooks to interact with\n * the global state, instead of accessing it directly.\n * @return\n */\nexport function getGlobalState<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(): GlobalState<StateT, SsrContextT> {\n  // TODO: Think about it: on one hand we on purpose called this function\n  // as getGlobalState(), so that ppl looking for the state hook prefer using\n  // useGlobalState(), while this getGlobalState() is reserved for nieche cases;\n  // on the other hand, perhaps we can rename it into useSomething, to both\n  // follow conventions, and to keep stuff clearly named at the same time.\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const globalState = use(Context);\n  if (!globalState) throw new Error('Missing GlobalStateProvider');\n  return globalState as GlobalState<StateT, SsrContextT>;\n}\n\n/**\n * @category Hooks\n * @desc Gets SSR context.\n * @param throwWithoutSsrContext If `true` (default),\n * this hook will throw if no SSR context is attached to the global state;\n * set `false` to not throw in such case. In either case the hook will throw\n * if the {@link &lt;GlobalStateProvider&gt;} (hence the state) is missing.\n * @returns SSR context.\n * @throws\n * - If current component has no parent {@link &lt;GlobalStateProvider&gt;}\n *   in the rendered React tree.\n * - If `throwWithoutSsrContext` is `true`, and there is no SSR context attached\n *   to the global state provided by {@link &lt;GlobalStateProvider&gt;}.\n */\nexport function getSsrContext<\n  SsrContextT extends SsrContext<unknown>,\n>(\n  throwWithoutSsrContext = true,\n): SsrContextT | undefined {\n  const { ssrContext } = getGlobalState<SsrContextT['state'], SsrContextT>();\n  if (!ssrContext && throwWithoutSsrContext) {\n    throw new Error('No SSR context found');\n  }\n  return ssrContext;\n}\n\ntype NewStateProps<StateT, SsrContextT extends SsrContext<StateT>> = {\n  initialState: ValueOrInitializerT<StateT>;\n  ssrContext?: SsrContextT;\n};\n\ntype GlobalStateProviderProps<\n  StateT,\n  SsrContextT extends SsrContext<StateT>,\n> = {\n  children?: ReactNode;\n} & (NewStateProps<StateT, SsrContextT> | {\n  stateProxy: true | GlobalState<StateT, SsrContextT>;\n});\n\n/**\n * Provides global state to its children.\n * @param prop.children Component children, which will be provided with\n * the global state, and rendered in place of the provider.\n * @param prop.initialState Initial content of the global state.\n * @param prop.ssrContext Server-side rendering (SSR) context.\n * @param prop.stateProxy This option is useful for code\n * splitting and SSR implementation:\n * - If `true`, this provider instance will fetch and reuse the global state\n *   from a parent provider.\n * - If `GlobalState` instance, it will be used by this provider.\n * - If not given, a new `GlobalState` instance will be created and used.\n */\nconst GlobalStateProvider = <\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(\n  { children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>,\n): ReactNode => {\n  type GST = GlobalState<StateT, SsrContextT>;\n  const localStateRef = useRef<GST>(undefined);\n  let state: GST;\n  // TODO: Revise.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if ('stateProxy' in rest && rest.stateProxy) {\n    localStateRef.current = undefined;\n    state = rest.stateProxy === true ? getGlobalState() : rest.stateProxy;\n  } else {\n    if (!localStateRef.current) {\n      const {\n        initialState,\n        ssrContext,\n      } = rest as NewStateProps<StateT, SsrContextT>;\n      localStateRef.current = new GlobalState(\n        isFunction(initialState) ? initialState() : initialState,\n        ssrContext,\n      );\n    }\n    state = localStateRef.current;\n  }\n  return <Context value={state}>{children}</Context>;\n};\n\nexport default GlobalStateProvider;\n"],"mappings":"AAAA,SAASA,UAAU,QAAQ,QAAQ;AAEnC,SAEEC,aAAa,EACbC,GAAG,EACHC,MAAM,QACD,OAAO;AAEd,OAAOC,WAAW;AAAsB,SAAAC,GAAA,IAAAC,IAAA;AAKxC,MAAMC,OAAO,gBAAGN,aAAa,CAA8B,IAAI,CAAC;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASO,cAAcA,CAAA,EAGQ;EACpC;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,WAAW,GAAGP,GAAG,CAACK,OAAO,CAAC;EAChC,IAAI,CAACE,WAAW,EAAE,MAAM,IAAIC,KAAK,CAAC,6BAA6B,CAAC;EAChE,OAAOD,WAAW;AACpB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,aAAaA,CAG3BC,sBAAsB,GAAG,IAAI,EACJ;EACzB,MAAM;IAAEC;EAAW,CAAC,GAAGL,cAAc,CAAoC,CAAC;EAC1E,IAAI,CAACK,UAAU,IAAID,sBAAsB,EAAE;IACzC,MAAM,IAAIF,KAAK,CAAC,sBAAsB,CAAC;EACzC;EACA,OAAOG,UAAU;AACnB;AAgBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,GAAGA,CAI1B;EAAEC,QAAQ;EAAE,GAAGC;AAAoD,CAAC,KACtD;EAEd,MAAMC,aAAa,GAAGd,MAAM,CAAMe,SAAS,CAAC;EAC5C,IAAIC,KAAU;EACd;EACA;EACA,IAAI,YAAY,IAAIH,IAAI,IAAIA,IAAI,CAACI,UAAU,EAAE;IAC3CH,aAAa,CAACI,OAAO,GAAGH,SAAS;IACjCC,KAAK,GAAGH,IAAI,CAACI,UAAU,KAAK,IAAI,GAAGZ,cAAc,CAAC,CAAC,GAAGQ,IAAI,CAACI,UAAU;EACvE,CAAC,MAAM;IACL,IAAI,CAACH,aAAa,CAACI,OAAO,EAAE;MAC1B,MAAM;QACJC,YAAY;QACZT;MACF,CAAC,GAAGG,IAA0C;MAC9CC,aAAa,CAACI,OAAO,GAAG,IAAIjB,WAAW,CACrCJ,UAAU,CAACsB,YAAY,CAAC,GAAGA,YAAY,CAAC,CAAC,GAAGA,YAAY,EACxDT,UACF,CAAC;IACH;IACAM,KAAK,GAAGF,aAAa,CAACI,OAAO;EAC/B;EACA,oBAAOf,IAAA,CAACC,OAAO;IAACgB,KAAK,EAAEJ,KAAM;IAAAJ,QAAA,EAAEA;EAAQ,CAAU,CAAC;AACpD,CAAC;AAED,eAAeD,mBAAmB","ignoreList":[]}

package/build/code/useAsyncCollection.js

@@ -72,7 +72,10 @@ function gcOnRelease(ids, path, gs, gcAge) {
 }
 function normalizeIds(idOrIds) {
   if (Array.isArray(idOrIds)) {
-    const res = [...idOrIds];
+    // Removes ID duplicates.
+    const res = Array.from(new Set(idOrIds));
+
+    // Ensures stable ID order.
     res.sort((a, b) => a.toString().localeCompare(b.toString()));
     return res;
   }
@@ -134,12 +137,7 @@ function useHeap(ids, path, loader, gs) {
       // happens if the outer function on the next line matches the same
       // async / sync signature.
       // eslint-disable-next-line @typescript-eslint/promise-function-async
-      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);
-      })
+      customLoader && ((id, ...args) => customLoader(...args)))
     };
     ref.current = heap;
   }
@@ -155,9 +153,8 @@ function useHeap(ids, path, loader, gs) {
 // Perhaps, a bunch of logic blocks can be split into stand-alone functions,
 // and reused in both hooks.
 // eslint-disable-next-line complexity
-function useAsyncCollection(idOrIds, path, loader) {
+function useAsyncCollection(idOrIds, path, loader, options = {}) {
   var _options$maxage, _options$refreshAge, _options$garbageColle;
-  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
   const ids = normalizeIds(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;
@@ -166,31 +163,32 @@ function useAsyncCollection(idOrIds, path, loader) {
   const heap = useHeap(ids, path, loader, globalState);
 
   // Server-side logic.
-  if (globalState.ssrContext && !options.noSSR) {
-    const operationId = `S${uuid()}`;
-    for (const id of ids) {
-      const itemPath = path ? `${path}.${id}` : `${id}`;
-      const state = globalState.get(itemPath, {
-        initialValue: newAsyncDataEnvelope()
-      });
-      if (!state.timestamp && !state.operationId) {
-        const promiseOrVoid = load(itemPath, function () {
-          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-            args[_key2] = arguments[_key2];
+  if (globalState.ssrContext) {
+    if (!options.disabled && !options.noSSR) {
+      const operationId = `S${uuid()}`;
+      for (const id of ids) {
+        const itemPath = path ? `${path}.${id}` : `${id}`;
+        const state = globalState.get(itemPath, {
+          initialValue: newAsyncDataEnvelope()
+        });
+        if (!state.timestamp && !state.operationId) {
+          const promiseOrVoid = load(itemPath, (...args) => loader(id, ...args), globalState, {
+            data: state.data,
+            timestamp: state.timestamp
+          }, operationId);
+          if (promiseOrVoid instanceof Promise) {
+            globalState.ssrContext.pending.push(promiseOrVoid);
           }
-          return loader(id, ...args);
-        }, globalState, {
-          data: state.data,
-          timestamp: state.timestamp
-        }, operationId);
-        if (promiseOrVoid instanceof Promise) {
-          globalState.ssrContext.pending.push(promiseOrVoid);
         }
       }
     }
 
     // Client-side logic.
   } else {
+    const {
+      disabled
+    } = options;
+
     // Reference-counting & garbage collection.
 
     const idsHash = hash(ids);
@@ -199,15 +197,15 @@ function useAsyncCollection(idOrIds, path, loader) {
     // but perhaps it can be refactored to avoid the need for it.
     useEffect(() => {
       // eslint-disable-line react-hooks/rules-of-hooks
-      gcOnWithhold(ids, path, globalState);
+      if (!disabled) gcOnWithhold(ids, path, globalState);
       return () => {
-        gcOnRelease(ids, path, globalState, garbageCollectAge);
+        if (!disabled) gcOnRelease(ids, path, globalState, garbageCollectAge);
       };
 
       // `ids` are represented in the dependencies array by `idsHash` value,
       // as useEffect() hook requires a constant size of dependencies array.
       // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [garbageCollectAge, globalState, idsHash, path]);
+    }, [disabled, garbageCollectAge, globalState, idsHash, path]);
 
     // NOTE: a bunch of Rules of Hooks ignored belows because in our very
     // special case the otherwise wrong behavior is actually what we need.
@@ -215,34 +213,31 @@ function useAsyncCollection(idOrIds, path, loader) {
     // Data loading and refreshing.
     useEffect(() => {
       // eslint-disable-line react-hooks/rules-of-hooks
-      void (async () => {
-        for (const id of ids) {
-          var _state2$timestamp;
-          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 === null || state2 === void 0 ? void 0 : state2.timestamp) !== null && _state2$timestamp !== void 0 ? _state2$timestamp : 0) && (!(state2 !== null && state2 !== void 0 && state2.operationId) || state2.operationId.startsWith('S'))) {
-            var _state2$timestamp2;
-            if (!deps) globalState.dropDependencies(itemPath);
-            await load(itemPath,
-            // TODO: I guess, the loader is not correctly typed here -
-            // it can be synchronous, and in that case the following method
-            // should be kept synchronous to not alter the sync logic.
-            // eslint-disable-next-line @typescript-eslint/promise-function-async
-            function (old) {
-              for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-                args[_key3 - 1] = arguments[_key3];
-              }
-              return loader(id, old, ...args);
-            }, globalState, {
-              data: state2 === null || state2 === void 0 ? void 0 : state2.data,
-              timestamp: (_state2$timestamp2 = state2 === null || state2 === void 0 ? void 0 : state2.timestamp) !== null && _state2$timestamp2 !== void 0 ? _state2$timestamp2 : 0
-            });
+      if (!disabled) {
+        void (async () => {
+          for (const id of ids) {
+            var _state2$timestamp;
+            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 === null || state2 === void 0 ? void 0 : state2.timestamp) !== null && _state2$timestamp !== void 0 ? _state2$timestamp : 0) && (!(state2 !== null && state2 !== void 0 && state2.operationId) || state2.operationId.startsWith('S'))) {
+              var _state2$timestamp2;
+              if (!deps) globalState.dropDependencies(itemPath);
+              await load(itemPath,
+              // TODO: I guess, the loader is not correctly typed here -
+              // it can be synchronous, and in that case the following method
+              // should be kept synchronous to not alter the sync logic.
+              // eslint-disable-next-line @typescript-eslint/promise-function-async
+              (old, ...args) => loader(id, old, ...args), globalState, {
+                data: state2 === null || state2 === void 0 ? void 0 : state2.data,
+                timestamp: (_state2$timestamp2 = state2 === null || state2 === void 0 ? void 0 : state2.timestamp) !== null && _state2$timestamp2 !== void 0 ? _state2$timestamp2 : 0
+              });
+            }
           }
-        }
-      })();
+        })();
+      }
     });
   }
   const [localState] = useGlobalState(path, {});