@dr.pogodin/react-global-state 0.18.0 → 0.19.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-_Copyright © 2019–2023, Dr. Sergey Pogodin_
+_Copyright © 2019–2025, Dr. Sergey Pogodin_
   &mdash; <doc@pogodin.studio> (https://dr.pogodin.studio)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

package/build/{module → code}/GlobalState.js

@@ -132,9 +132,7 @@ export default class GlobalState {
       _classPrivateFieldSet(_nextNotifierId, this, setTimeout(() => {
         _classPrivateFieldSet(_nextNotifierId, this, undefined);
         const watchers = [..._classPrivateFieldGet(_watchers, this)];
-        for (let i = 0; i < watchers.length; ++i) {
-          watchers[i]();
-        }
+        for (const watcher of watchers) watcher();
       }));
     }
   }
@@ -193,7 +191,10 @@ export default class GlobalState {
     if (res !== undefined || (opts === null || opts === void 0 ? void 0 : opts.initialValue) === undefined) return res;
     const iv = opts.initialValue;
     res = isFunction(iv) ? iv() : iv;
-    if (!(opts !== null && opts !== void 0 && opts.initialState) || this.get(path) === undefined) {
+
+    // TODO: Revise.
+    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+    if (!opts.initialState || this.get(path) === undefined) {
       this.set(path, res);
     }
     return res;
@@ -214,15 +215,24 @@ export default class GlobalState {
 
   set(path, value) {
     if (isNil(path)) return this.setEntireState(value);
+
+    // TODO: Revise.
+    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     if (value !== this.get(path)) {
       const root = {
         state: _classPrivateFieldGet(_currentState, this)
       };
       let segIdx = 0;
+
+      // TODO: It is not 100% correct, as `pos` can be an array, or any other
+      // value as we travel through the state tree. To simplify the typing for
+      // now, I guess, we can go with this record type, though.
       let pos = root;
       const pathSegments = toPath(`state.${path}`);
       for (; segIdx < pathSegments.length - 1; segIdx += 1) {
         const seg = pathSegments[segIdx];
+
+        // TODO: Revise: Typing is not quite correct here, but it works fine in the runtime.
         const next = pos[seg];
         if (Array.isArray(next)) pos[seg] = [...next];else if (isObject(next)) pos[seg] = {
           ...next
@@ -274,7 +284,7 @@ export default class GlobalState {
   watch(callback) {
     if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);
     const watchers = _classPrivateFieldGet(_watchers, this);
-    if (watchers.indexOf(callback) < 0) {
+    if (!watchers.includes(callback)) {
       watchers.push(callback);
     }
   }

package/build/code/GlobalState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalState.js","names":["get","isFunction","isObject","isNil","set","toPath","cloneDeepForLog","isDebugMode","ERR_NO_SSR_WATCH","_asyncDataAbortCallbacks","WeakMap","_dependencies","_initialState","_watchers","_nextNotifierId","_currentState","GlobalState","constructor","initialState","ssrContext","_classPrivateFieldInitSpec","_classPrivateFieldSet","dirty","pending","state","_classPrivateFieldGet","process","env","NODE_ENV","msg","console","groupCollapsed","log","groupEnd","numAsyncDataAbortCallbacks","Object","keys","length","asyncDataLoadDone","opid","aborted","_classPrivateFieldGet2","_classPrivateFieldGet3","call","dropDependencies","path","hasChangedDependencies","deps","prevDeps","changed","i","freeze","getEntireState","opts","undefined","initialValue","iv","setEntireState","notifyStateUpdate","value","p","setTimeout","watchers","watcher","setAsyncDataAbortCallback","cb","res","root","segIdx","pos","pathSegments","seg","next","Array","isArray","slice","unWatch","callback","Error","indexOf","pop","watch","includes","push"],"sources":["../../src/GlobalState.ts"],"sourcesContent":["import {\n  get,\n  isFunction,\n  isObject,\n  isNil,\n  set,\n  toPath,\n} from 'lodash';\n\nimport type SsrContext from './SsrContext';\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\nconst ERR_NO_SSR_WATCH = 'GlobalState must not be watched at server side';\n\ntype GetOptsT<T> = {\n  initialState?: boolean;\n  initialValue?: ValueOrInitializerT<T>;\n};\n\nexport default class GlobalState<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n> {\n  readonly ssrContext?: SsrContextT;\n\n  #asyncDataAbortCallbacks: Record<string, () => void> = {};\n\n  #dependencies: Record<string, readonly unknown[]> = {};\n\n  #initialState: StateT;\n\n  // TODO: It is tempting to replace watchers here by\n  // Emitter from @dr.pogodin/js-utils, but we need to clone\n  // current watchers for emitting later, and this is not something\n  // Emitter supports right now.\n  #watchers: CallbackT[] = [];\n\n  #nextNotifierId?: NodeJS.Timeout;\n\n  #currentState: StateT;\n\n  /**\n   * Creates a new global state object.\n   * @param initialState Intial global state content.\n   * @param ssrContext Server-side rendering context.\n   */\n  constructor(\n    initialState: StateT,\n    ssrContext?: SsrContextT,\n  ) {\n    this.#currentState = initialState;\n    this.#initialState = initialState;\n\n    if (ssrContext) {\n      /* eslint-disable no-param-reassign */\n      ssrContext.dirty = false;\n      ssrContext.pending = [];\n      ssrContext.state = this.#currentState;\n      /* eslint-enable no-param-reassign */\n\n      this.ssrContext = ssrContext;\n    }\n\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      let msg = 'New ReactGlobalState created';\n      if (ssrContext) msg += ' (SSR mode)';\n      console.groupCollapsed(msg);\n      console.log('Initial state:', cloneDeepForLog(initialState));\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n  }\n\n  /**\n   * Returns the number of currently registered async data abort callbacks,\n   * just for the sake of testing the library.\n   */\n  get numAsyncDataAbortCallbacks(): number {\n    return Object.keys(this.#asyncDataAbortCallbacks).length;\n  }\n\n  /**\n   * If `aborted` is \"true\" and there is an abort callback registered for\n   * the specified operation, it triggers the callback. Then, in any case,\n   * it drops the callback.\n   */\n  asyncDataLoadDone(opid: string, aborted: boolean): void {\n    if (aborted) this.#asyncDataAbortCallbacks[opid]?.();\n    delete this.#asyncDataAbortCallbacks[opid];\n  }\n\n  /**\n   * Drops the record of dependencies, if any, for the given path.\n   */\n  dropDependencies(path: string): void {\n    delete this.#dependencies[path];\n  }\n\n  /**\n   * Checks if given `deps` are different from previously recorded ones for\n   * the given `path`. If they are, `deps` are recorded as the new deps for\n   * the `path`, and also the array is frozen, to prevent it from being\n   * modified.\n   *\n   * TODO: This may not work as expected if path string is not normalized,\n   * and the for the same path different alternative ways to spell it down\n   * are used. We should normalize given path here, I guess, or on a higher\n   * level in the logic?\n   */\n  hasChangedDependencies(path: string, deps: unknown[]): boolean {\n    const prevDeps = this.#dependencies[path];\n    let changed = !prevDeps || prevDeps.length !== deps.length;\n    for (let i = 0; !changed && i < deps.length; ++i) {\n      changed = prevDeps![i] !== deps[i];\n    }\n    this.#dependencies[path] = Object.freeze(deps);\n    return changed;\n  }\n\n  /**\n   * Gets entire state, the same way as .get(null, opts) would do.\n   * @param opts.initialState\n   * @param opts.initialValue\n   */\n  getEntireState(opts?: GetOptsT<StateT>): StateT {\n    let state = opts?.initialState ? this.#initialState : this.#currentState;\n    if (state !== undefined || opts?.initialValue === undefined) return state;\n\n    const iv = opts.initialValue;\n    state = isFunction(iv) ? iv() : iv;\n    if (this.#currentState === undefined) this.setEntireState(state);\n    return state;\n  }\n\n  /**\n   * Notifies all connected state watchers that a state update has happened.\n   */\n  private notifyStateUpdate(path: null | string | undefined, value: unknown) {\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      const p = typeof path === 'string'\n        ? `\"${path}\"` : 'none (entire state update)';\n      console.groupCollapsed(`ReactGlobalState update. Path: ${p}`);\n      console.log('New value:', cloneDeepForLog(value, path ?? ''));\n      console.log('New state:', cloneDeepForLog(this.#currentState));\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n\n    if (this.ssrContext) {\n      this.ssrContext.dirty = true;\n      this.ssrContext.state = this.#currentState;\n    } else if (!this.#nextNotifierId) {\n      this.#nextNotifierId = setTimeout(() => {\n        this.#nextNotifierId = undefined;\n        const watchers = [...this.#watchers];\n        for (const watcher of watchers) watcher();\n      });\n    }\n  }\n\n  /**\n   * Registers an abort callback for an async data retrieval operation with\n   * the given operation ID. Throws if already registered.\n   */\n  setAsyncDataAbortCallback(opid: string, cb: () => void): void {\n    this.#asyncDataAbortCallbacks[opid] = cb;\n  }\n\n  /**\n   * Sets entire state, the same way as .set(null, value) would do.\n   * @param value\n   */\n  setEntireState(value: StateT): StateT {\n    if (this.#currentState !== value) {\n      this.#currentState = value;\n      this.notifyStateUpdate(null, value);\n    }\n    return value;\n  }\n\n  /**\n   * Gets current or initial value at the specified \"path\" of the global state.\n   * @param path Dot-delimitered state path.\n   * @param options Additional options.\n   * @param options.initialState If \"true\" the value will be read\n   *  from the initial state instead of the current one.\n   * @param options.initialValue If the value read from the \"path\" is\n   *  \"undefined\", this \"initialValue\" will be returned instead. In such case\n   *  \"initialValue\" will also be written to the \"path\" of the current global\n   *  state (no matter \"initialState\" flag), if \"undefined\" is stored there.\n   * @return Retrieved value.\n   */\n\n  // .get() without arguments just falls back to .getEntireState().\n  get(): StateT;\n\n  // This variant attempts to automatically resolve and check the type of value\n  // at the given path, as precise as the actual state and path types permit.\n  // If the automatic path resolution is not possible, the ValueT fallsback\n  // to `never` (or to `undefined` in some cases), effectively forbidding\n  // to use this .get() variant.\n  get<\n    PathT extends null | string | undefined,\n    ValueArgT extends ValueAtPathT<StateT, PathT, never>,\n    ValueResT extends ValueAtPathT<StateT, PathT, void>,\n  >(path: PathT, opts?: GetOptsT<ValueArgT>): ValueResT;\n\n  // This variant is not callable by default (without generic arguments),\n  // otherwise it allows to set the correct ValueT directly.\n  get<Forced extends ForceT | LockT = LockT, ValueT = void>(\n    path?: null | string,\n    opts?: GetOptsT<TypeLock<Forced, never, ValueT>>,\n  ): TypeLock<Forced, void, ValueT>;\n\n  get<ValueT>(path?: null | string, opts?: GetOptsT<ValueT>): ValueT {\n    if (isNil(path)) {\n      const res = this.getEntireState((opts as unknown) as GetOptsT<StateT>);\n      return (res as unknown) as ValueT;\n    }\n\n    const state = opts?.initialState ? this.#initialState : this.#currentState;\n\n    let res = get(state, path) as ValueT;\n    if (res !== undefined || opts?.initialValue === undefined) return res;\n\n    const iv = opts.initialValue;\n    res = isFunction(iv) ? iv() : iv;\n\n    // TODO: Revise.\n    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n    if (!opts.initialState || (this.get(path) as unknown) === undefined) {\n      this.set<ForceT, unknown>(path, res);\n    }\n\n    return res;\n  }\n\n  /**\n   * Writes the `value` to given global state `path`.\n   * @param path Dot-delimitered state path. If not given, entire\n   * global state content is replaced by the `value`.\n   * @param value The value.\n   * @return Given `value` itself.\n   */\n\n  // This variant attempts automatic value type resolution & checking.\n  set<\n    PathT extends null | string | undefined,\n    ValueArgT extends ValueAtPathT<StateT, PathT, never>,\n    ValueResT extends ValueAtPathT<StateT, PathT, void>,\n  >(path: PathT, value: ValueArgT): ValueResT;\n\n  // This variant is disabled by default, otherwise allows to give\n  // expected value type explicitly.\n  set<Forced extends ForceT | LockT = LockT, ValueT = never>(\n    path: null | string | undefined,\n    value: TypeLock<Forced, never, ValueT>,\n  ): TypeLock<Forced, void, ValueT>;\n\n  set(path: null | string | undefined, value: unknown): unknown {\n    if (isNil(path)) return this.setEntireState(value as StateT);\n\n    // TODO: Revise.\n    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n    if (value !== this.get(path)) {\n      const root = { state: this.#currentState };\n      let segIdx = 0;\n\n      // TODO: It is not 100% correct, as `pos` can be an array, or any other\n      // value as we travel through the state tree. To simplify the typing for\n      // now, I guess, we can go with this record type, though.\n      let pos: Record<string, unknown> = root;\n      const pathSegments = toPath(`state.${path}`);\n      for (; segIdx < pathSegments.length - 1; segIdx += 1) {\n        const seg = pathSegments[segIdx]!;\n\n        // TODO: Revise: Typing is not quite correct here, but it works fine in the runtime.\n        const next = pos[seg];\n        if (Array.isArray(next)) pos[seg] = [...(next as unknown[])];\n        else if (isObject(next)) pos[seg] = { ...next };\n        else {\n          // We arrived to a state sub-segment, where the remaining part of\n          // the update path does not exist yet. We rely on lodash's set()\n          // function to create the remaining path, and set the value.\n          set(pos, pathSegments.slice(segIdx), value);\n          break;\n        }\n        pos = pos[seg] as Record<string, unknown>;\n      }\n\n      if (segIdx === pathSegments.length - 1) {\n        pos[pathSegments[segIdx]!] = value;\n      }\n\n      this.#currentState = root.state;\n\n      this.notifyStateUpdate(path, value);\n    }\n    return value;\n  }\n\n  /**\n   * Unsubscribes `callback` from watching state updates; no operation if\n   * `callback` is not subscribed to the state updates.\n   * @param callback\n   * @throws if {@link SsrContext} is attached to the state instance: the state\n   * watching functionality is intended for client-side (non-SSR) only.\n   */\n  unWatch(callback: CallbackT): void {\n    if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);\n\n    const watchers = this.#watchers;\n    const pos = watchers.indexOf(callback);\n    if (pos >= 0) {\n      watchers[pos] = watchers[watchers.length - 1]!;\n      watchers.pop();\n    }\n  }\n\n  /**\n   * Subscribes `callback` to watch state updates; no operation if\n   * `callback` is already subscribed to this state instance.\n   * @param callback It will be called without any arguments every\n   * time the state content changes (note, howhever, separate state updates can\n   * be applied to the state at once, and watching callbacks will be called once\n   * after such bulk update).\n   * @throws if {@link SsrContext} is attached to the state instance: the state\n   * watching functionality is intended for client-side (non-SSR) only.\n   */\n  watch(callback: CallbackT): void {\n    if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);\n\n    const watchers = this.#watchers;\n    if (!watchers.includes(callback)) {\n      watchers.push(callback);\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/{module → code}/GlobalStateProvider.js

@@ -11,14 +11,13 @@ const Context = /*#__PURE__*/createContext(null);
  * @return
  */
 export function getGlobalState() {
-  // Here Rules of Hooks are violated because "getGlobalState()" does not follow
-  // convention that hook names should start with use... This is intentional in
-  // our case, as getGlobalState() hook is intended for advance scenarious,
-  // while the normal interaction with the global state should happen via
-  // another hook, useGlobalState().
-  /* eslint-disable react-hooks/rules-of-hooks */
+  // TODO: Think about it: on one hand we on purpose called this function
+  // as getGlobalState(), so that ppl looking for the state hook prefer using
+  // useGlobalState(), while this getGlobalState() is reserved for nieche cases;
+  // on the other hand, perhaps we can rename it into useSomething, to both
+  // follow conventions, and to keep stuff clearly named at the same time.
+  // eslint-disable-next-line react-hooks/rules-of-hooks
   const globalState = use(Context);
-  /* eslint-enable react-hooks/rules-of-hooks */
   if (!globalState) throw new Error('Missing GlobalStateProvider');
   return globalState;
 }
@@ -65,24 +64,25 @@ const GlobalStateProvider = _ref => {
     children,
     ...rest
   } = _ref;
-  const state = useRef(undefined);
-  if (!state.current) {
-    // NOTE: The last part of condition, "&& rest.stateProxy", is needed for
-    // graceful compatibility with JavaScript - if "undefined" stateProxy value
-    // is given, we want to follow the second branch, which creates a new
-    // GlobalState with whatever intiialState given.
-    if ('stateProxy' in rest && rest.stateProxy) {
-      if (rest.stateProxy === true) state.current = getGlobalState();else state.current = rest.stateProxy;
-    } else {
+  const localStateRef = useRef(undefined);
+  let state;
+  // TODO: Revise.
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if ('stateProxy' in rest && rest.stateProxy) {
+    localStateRef.current = undefined;
+    state = rest.stateProxy === true ? getGlobalState() : rest.stateProxy;
+  } else {
+    if (!localStateRef.current) {
       const {
         initialState,
         ssrContext
       } = rest;
-      state.current = new GlobalState(isFunction(initialState) ? initialState() : initialState, ssrContext);
+      localStateRef.current = new GlobalState(isFunction(initialState) ? initialState() : initialState, ssrContext);
     }
+    state = localStateRef.current;
   }
   return /*#__PURE__*/_jsx(Context, {
-    value: state.current,
+    value: state,
     children: children
   });
 };

package/build/code/GlobalStateProvider.js.map

@@ -0,0 +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":[]}

package/build/code/SsrContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SsrContext.js","names":["SsrContext","constructor","state","_defineProperty"],"sources":["../../src/SsrContext.ts"],"sourcesContent":["export default class SsrContext<StateT> {\n  dirty: boolean = false;\n\n  pending: Array<Promise<void>> = [];\n\n  constructor(public state?: StateT) { }\n}\n"],"mappings":";AAAA,eAAe,MAAMA,UAAU,CAAS;EAKtCC,WAAWA,CAAQC,KAAc,EAAE;IAAAC,eAAA,gBAJlB,KAAK;IAAAA,eAAA,kBAEU,EAAE;IAAA,KAEfD,KAAc,GAAdA,KAAc;EAAI;AACvC","ignoreList":[]}

package/build/{module → code}/index.js

@@ -5,13 +5,19 @@ import useAsyncCollection from "./useAsyncCollection";
 import { newAsyncDataEnvelope, useAsyncData } from "./useAsyncData";
 import useGlobalState from "./useGlobalState";
 export { getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, newAsyncDataEnvelope, SsrContext, useAsyncCollection, useAsyncData, useGlobalState };
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+
 const api = {
-  getGlobalState,
-  getSsrContext,
+  // TODO: I am puzzled, why ESLint eforces this sorting order as alphabetical?
+  // Perhaps, we should tune something in its config settings, as it seems to mix
+  // some extra sorting logic, which I am not sure I like.
   GlobalState,
   GlobalStateProvider,
-  newAsyncDataEnvelope,
   SsrContext,
+  getGlobalState,
+  getSsrContext,
+  newAsyncDataEnvelope,
   useAsyncCollection,
   useAsyncData,
   useGlobalState

package/build/code/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["GlobalState","GlobalStateProvider","getGlobalState","getSsrContext","SsrContext","useAsyncCollection","newAsyncDataEnvelope","useAsyncData","useGlobalState","api","withGlobalStateType"],"sources":["../../src/index.ts"],"sourcesContent":["import GlobalState from './GlobalState';\n\nimport GlobalStateProvider, {\n  getGlobalState,\n  getSsrContext,\n} from './GlobalStateProvider';\n\nimport SsrContext from './SsrContext';\n\nimport useAsyncCollection, {\n  type UseAsyncCollectionI,\n  type UseAsyncCollectionResT,\n} from './useAsyncCollection';\n\nimport {\n  type AsyncDataEnvelopeT,\n  type AsyncDataLoaderT,\n  type AsyncDataReloaderT,\n  type UseAsyncDataI,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n  newAsyncDataEnvelope,\n  useAsyncData,\n} from './useAsyncData';\n\nimport useGlobalState, { type UseGlobalStateI } from './useGlobalState';\n\nexport type { AsyncCollectionLoaderT, AsyncCollectionT } from './useAsyncCollection';\n\nexport type { SetterT, UseGlobalStateResT } from './useGlobalState';\n\nexport type { ForceT, ValueOrInitializerT } from './utils';\n\nexport {\n  type AsyncDataEnvelopeT,\n  type AsyncDataLoaderT,\n  type AsyncDataReloaderT,\n  type UseAsyncCollectionResT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n  getGlobalState,\n  getSsrContext,\n  GlobalState,\n  GlobalStateProvider,\n  newAsyncDataEnvelope,\n  SsrContext,\n  useAsyncCollection,\n  useAsyncData,\n  useGlobalState,\n};\n\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ninterface API<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n> {\n  getGlobalState: typeof getGlobalState<StateT, SsrContextT>;\n  getSsrContext: typeof getSsrContext<SsrContextT>;\n  GlobalState: typeof GlobalState<StateT, SsrContextT>;\n  GlobalStateProvider: typeof GlobalStateProvider<StateT, SsrContextT>;\n  newAsyncDataEnvelope: typeof newAsyncDataEnvelope;\n  SsrContext: typeof SsrContext<StateT>;\n  useAsyncCollection: UseAsyncCollectionI<StateT>;\n  useAsyncData: UseAsyncDataI<StateT>;\n  useGlobalState: UseGlobalStateI<StateT>;\n}\n\nconst api = {\n  // TODO: I am puzzled, why ESLint eforces this sorting order as alphabetical?\n  // Perhaps, we should tune something in its config settings, as it seems to mix\n  // some extra sorting logic, which I am not sure I like.\n  GlobalState,\n  GlobalStateProvider,\n  SsrContext,\n  getGlobalState,\n  getSsrContext,\n  newAsyncDataEnvelope,\n  useAsyncCollection,\n  useAsyncData,\n  useGlobalState,\n};\n\nexport function withGlobalStateType<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(): API<StateT, SsrContextT> {\n  return api as API<StateT, SsrContextT>;\n}\n"],"mappings":"AAAA,OAAOA,WAAW;AAElB,OAAOC,mBAAmB,IACxBC,cAAc,EACdC,aAAa;AAGf,OAAOC,UAAU;AAEjB,OAAOC,kBAAkB;AAKzB,SAOEC,oBAAoB,EACpBC,YAAY;AAGd,OAAOC,cAAc;AAQrB,SAOEN,cAAc,EACdC,aAAa,EACbH,WAAW,EACXC,mBAAmB,EACnBK,oBAAoB,EACpBF,UAAU,EACVC,kBAAkB,EAClBE,YAAY,EACZC,cAAc;;AAGhB;;AAgBA,MAAMC,GAAG,GAAG;EACV;EACA;EACA;EACAT,WAAW;EACXC,mBAAmB;EACnBG,UAAU;EACVF,cAAc;EACdC,aAAa;EACbG,oBAAoB;EACpBD,kBAAkB;EAClBE,YAAY;EACZC;AACF,CAAC;AAED,OAAO,SAASE,mBAAmBA,CAAA,EAGL;EAC5B,OAAOD,GAAG;AACZ","ignoreList":[]}

package/build/{module → code}/useAsyncCollection.js

@@ -18,8 +18,7 @@ function gcOnWithhold(ids, path, gs) {
   const collection = {
     ...gs.get(path)
   };
-  for (let i = 0; i < ids.length; ++i) {
-    const id = ids[i];
+  for (const id of ids) {
     let envelope = collection[id];
     if (envelope) envelope = {
       ...envelope,
@@ -33,8 +32,8 @@ function gcOnWithhold(ids, path, gs) {
 }
 function idsToStringSet(ids) {
   const res = new Set();
-  for (let i = 0; i < ids.length; ++i) {
-    res.add(ids[i].toString());
+  for (const id of ids) {
+    res.add(id.toString());
   }
   return res;
 }
@@ -51,8 +50,7 @@ function gcOnRelease(ids, path, gs, gcAge) {
   const now = Date.now();
   const idSet = idsToStringSet(ids);
   const collection = {};
-  for (let i = 0; i < entries.length; ++i) {
-    const [id, envelope] = entries[i];
+  for (const [id, envelope] of entries) {
     if (envelope) {
       const toBeReleased = idSet.has(id);
       let {
@@ -75,7 +73,7 @@ function gcOnRelease(ids, path, gs, gcAge) {
 function normalizeIds(idOrIds) {
   if (Array.isArray(idOrIds)) {
     const res = [...idOrIds];
-    res.sort();
+    res.sort((a, b) => a.toString().localeCompare(b.toString()));
     return res;
   }
   return [idOrIds];
@@ -97,25 +95,45 @@ function useHeap(ids, path, loader, gs) {
     // Initialization.
     const reload = async customLoader => {
       const heap2 = ref.current;
-      const localLoader = customLoader || heap2.loader;
+      const localLoader = customLoader !== null && customLoader !== void 0 ? customLoader : heap2.loader;
+      // TODO: Revise - not sure all related typing is 100% correct,
+      // thus let's keep this runtime assertion.
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!localLoader || !heap2.globalState || !heap2.ids) {
         throw Error('Internal error');
       }
-      for (let i = 0; i < heap2.ids.length; ++i) {
-        const id = heap2.ids[i];
+      for (const id of heap2.ids) {
         const itemPath = heap2.path ? `${heap2.path}.${id}` : `${id}`;
-
-        // eslint-disable-next-line no-await-in-loop
-        await load(itemPath, (oldData, meta) => localLoader(id, oldData, meta), heap2.globalState);
+        await load(itemPath,
+        // TODO: Revise! Most probably we don't have fully correct loader
+        // typing, as it may return either promise or value, and those two
+        // cases call for different runtime behavior, which in turns only
+        // happens if the outer function on the next line matches the same
+        // async / sync signature.
+        // eslint-disable-next-line @typescript-eslint/promise-function-async
+        (oldData, meta) => localLoader(id, oldData, meta), heap2.globalState);
       }
     };
     heap = {
       globalState: gs,
       ids,
-      path,
       loader,
+      path,
       reload,
-      reloadSingle: customLoader => ref.current.reload(customLoader && function (id) {
+      // TODO: Revise! Most probably we don't have fully correct loader
+      // typing, as it may return either promise or value, and those two
+      // cases call for different runtime behavior, which in turns only
+      // happens if the outer function on the next line matches the same
+      // async / sync signature.
+      // eslint-disable-next-line @typescript-eslint/promise-function-async
+      reloadSingle: customLoader => ref.current.reload(
+      // TODO: Revise! Most probably we don't have fully correct loader
+      // typing, as it may return either promise or value, and those two
+      // cases call for different runtime behavior, which in turns only
+      // 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];
         }
@@ -135,6 +153,7 @@ function useHeap(ids, path, loader, gs) {
 // 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.
+// eslint-disable-next-line complexity
 function useAsyncCollection(idOrIds, path, loader) {
   var _options$maxage, _options$refreshAge, _options$garbageColle;
   let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
@@ -148,14 +167,20 @@ function useAsyncCollection(idOrIds, path, loader) {
   // Server-side logic.
   if (globalState.ssrContext && !options.noSSR) {
     const operationId = `S${uuid()}`;
-    for (let i = 0; i < ids.length; ++i) {
-      const id = ids[i];
+    for (const id of ids) {
       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 () {
+        globalState.ssrContext.pending.push(
+        // TODO: Revise! Most probably we don't have fully correct loader
+        // typing, as it may return either promise or value, and those two
+        // cases call for different runtime behavior, which in turns only
+        // happens if the outer function on the next line matches the same
+        // async / sync signature.
+        // eslint-disable-next-line @typescript-eslint/promise-function-async
+        load(itemPath, function () {
           for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
             args[_key2] = arguments[_key2];
           }
@@ -178,7 +203,9 @@ function useAsyncCollection(idOrIds, path, loader) {
     useEffect(() => {
       // eslint-disable-line react-hooks/rules-of-hooks
       gcOnWithhold(ids, path, globalState);
-      return () => gcOnRelease(ids, path, globalState, garbageCollectAge);
+      return () => {
+        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.
@@ -191,20 +218,23 @@ function useAsyncCollection(idOrIds, path, loader) {
     // Data loading and refreshing.
     useEffect(() => {
       // eslint-disable-line react-hooks/rules-of-hooks
-      (async () => {
-        for (let i = 0; i < ids.length; ++i) {
+      void (async () => {
+        for (const id of ids) {
           var _state2$timestamp;
-          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 === 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.charAt(0) === 'S')) {
+          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);
-            // eslint-disable-next-line no-await-in-loop
-            await load(itemPath, function (old) {
+            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];
               }
@@ -221,6 +251,7 @@ function useAsyncCollection(idOrIds, path, loader) {
   const [localState] = useGlobalState(path, {});
   if (!Array.isArray(idOrIds)) {
     var _e$timestamp, _e$data;
+    // TODO: Revise related typings!
     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 {
@@ -236,9 +267,9 @@ function useAsyncCollection(idOrIds, path, loader) {
     reload: heap.reload,
     timestamp: Number.MAX_VALUE
   };
-  for (let i = 0; i < ids.length; ++i) {
+  for (const id of ids) {
     var _e$timestamp2, _e$data2;
-    const id = ids[i];
+    // TODO: Revise related typing. Should `localState` have a more specific type?
     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;
@@ -253,4 +284,6 @@ function useAsyncCollection(idOrIds, path, loader) {
   return res;
 }
 export default useAsyncCollection;
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 //# sourceMappingURL=useAsyncCollection.js.map

package/build/code/useAsyncCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncCollection.js","names":["useEffect","useRef","v4","uuid","getGlobalState","DEFAULT_MAXAGE","load","newAsyncDataEnvelope","useGlobalState","hash","isDebugMode","gcOnWithhold","ids","path","gs","collection","get","id","envelope","numRefs","set","idsToStringSet","res","Set","add","toString","gcOnRelease","gcAge","entries","Object","now","Date","idSet","toBeReleased","has","timestamp","process","env","NODE_ENV","console","log","normalizeIds","idOrIds","Array","isArray","sort","a","b","localeCompare","useHeap","loader","ref","undefined","heap","current","globalState","reload","customLoader","heap2","localLoader","Error","itemPath","oldData","meta","reloadSingle","_len","arguments","length","args","_key","useAsyncCollection","_options$maxage","_options$refreshAge","_options$garbageColle","options","maxage","refreshAge","garbageCollectAge","ssrContext","noSSR","operationId","state","initialValue","pending","push","_len2","_key2","data","idsHash","_state2$timestamp","state2","deps","hasChangedDependencies","startsWith","_state2$timestamp2","dropDependencies","old","_len3","_key3","localState","_e$timestamp","_e$data","e","loading","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 type 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  hash,\n  isDebugMode,\n} from './utils';\n\nexport type AsyncCollectionT<\n  DataT = unknown,\n  IdT extends number | string = number | string,\n> = Record<IdT, AsyncDataEnvelopeT<DataT>>;\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    setAbortCallback: (cb: () => void) => void;\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: Record<IdT, CollectionItemT<DataT>>;\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 | undefined;\n  loader: AsyncCollectionLoaderT<DataT, IdT>;\n  reload: AsyncCollectionReloaderT<DataT, IdT>;\n  reloadSingle: AsyncDataReloaderT<DataT>;\n};\n\n/**\n * GarbageCollector: the piece of logic executed on mounting of\n * an useAsyncCollection() hook, and on update of hook params, to update\n * the state according to the new param values. It increments by 1 `numRefs`\n * counters for the requested collection items.\n */\nfunction gcOnWithhold<IdT extends number | string>(\n  ids: IdT[],\n  path: null | string | undefined,\n  gs: GlobalState<unknown>,\n) {\n  const collection = { ...gs.get<ForceT, AsyncCollectionT>(path) };\n\n  for (const id of ids) {\n    let envelope = collection[id];\n    if (envelope) envelope = { ...envelope, numRefs: 1 + envelope.numRefs };\n    else envelope = newAsyncDataEnvelope<unknown>(null, { numRefs: 1 });\n    collection[id] = envelope;\n  }\n\n  gs.set<ForceT, AsyncCollectionT>(path, collection);\n}\n\nfunction idsToStringSet<IdT extends number | string>(ids: IdT[]): Set<string> {\n  const res = new Set<string>();\n  for (const id of ids) {\n    res.add(id.toString());\n  }\n  return res;\n}\n\n/**\n * GarbageCollector: the piece of logic executed on un-mounting of\n * an useAsyncCollection() hook, and on update of hook params, to clean-up\n * after the previous param values. It decrements by 1 `numRefs` counters\n * for previously requested collection items, and also drops from the state\n * stale records.\n */\nfunction gcOnRelease<IdT extends number | string>(\n  ids: IdT[],\n  path: null | string | undefined,\n  gs: GlobalState<unknown>,\n  gcAge: number,\n) {\n  type EnvelopeT = AsyncDataEnvelopeT<unknown>;\n\n  const entries = Object.entries<EnvelopeT | undefined>(\n    gs.get<ForceT, AsyncCollectionT>(path),\n  );\n\n  const now = Date.now();\n  const idSet = idsToStringSet(ids);\n  const collection: AsyncCollectionT = {};\n  for (const [id, envelope] of entries) {\n    if (envelope) {\n      const toBeReleased = idSet.has(id);\n\n      let { numRefs } = envelope;\n      if (toBeReleased) --numRefs;\n\n      if (gcAge > now - envelope.timestamp || numRefs > 0) {\n        collection[id as IdT] = toBeReleased\n          ? { ...envelope, numRefs }\n          : envelope;\n      } else if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n        // eslint-disable-next-line no-console\n        console.log(\n          `useAsyncCollection(): Garbage collected at the path \"${\n            path}\", ID = ${id}`,\n        );\n      }\n    }\n  }\n\n  gs.set<ForceT, AsyncCollectionT>(path, collection);\n}\n\nfunction normalizeIds<IdT extends number | string>(\n  idOrIds: IdT | IdT[],\n): IdT[] {\n  if (Array.isArray(idOrIds)) {\n    const res = [...idOrIds];\n    res.sort((a, b) => a.toString().localeCompare(b.toString()));\n    return res;\n  }\n  return [idOrIds];\n}\n\n/**\n * Inits/updates, and returns the heap.\n */\nfunction useHeap<\n  DataT,\n  IdT extends number | string,\n>(\n  ids: IdT[],\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<DataT, IdT>,\n  gs: GlobalState<unknown>,\n): HeapT<DataT, IdT> {\n  const ref = useRef<HeapT<DataT, IdT>>(undefined);\n\n  let heap = ref.current;\n\n  if (heap) {\n    // Update.\n    heap.ids = ids;\n    heap.path = path;\n    heap.loader = loader;\n    heap.globalState = gs;\n  } else {\n    // Initialization.\n    const reload = async (\n      customLoader?: AsyncCollectionLoaderT<DataT, IdT>,\n    ) => {\n      const heap2 = ref.current!;\n\n      const localLoader = customLoader ?? heap2.loader;\n      // TODO: Revise - not sure all related typing is 100% correct,\n      // thus let's keep this runtime assertion.\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (!localLoader || !heap2.globalState || !heap2.ids) {\n        throw Error('Internal error');\n      }\n\n      for (const id of heap2.ids) {\n        const itemPath = heap2.path ? `${heap2.path}.${id}` : `${id}`;\n\n        await load(\n          itemPath,\n          // TODO: Revise! Most probably we don't have fully correct loader\n          // typing, as it may return either promise or value, and those two\n          // cases call for different runtime behavior, which in turns only\n          // happens if the outer function on the next line matches the same\n          // async / sync signature.\n          // eslint-disable-next-line @typescript-eslint/promise-function-async\n          (oldData: DataT | null, meta) => localLoader(id, oldData, meta),\n          heap2.globalState,\n        );\n      }\n    };\n    heap = {\n      globalState: gs,\n      ids,\n      loader,\n      path,\n      reload,\n      // TODO: Revise! Most probably we don't have fully correct loader\n      // typing, as it may return either promise or value, and those two\n      // cases call for different runtime behavior, which in turns only\n      // happens if the outer function on the next line matches the same\n      // async / sync signature.\n      // eslint-disable-next-line @typescript-eslint/promise-function-async\n      reloadSingle: (customLoader) => ref.current!.reload(\n        // TODO: Revise! Most probably we don't have fully correct loader\n        // typing, as it may return either promise or value, and those two\n        // cases call for different runtime behavior, which in turns only\n        // happens if the outer function on the next line matches the same\n        // async / sync signature.\n        // eslint-disable-next-line @typescript-eslint/promise-function-async\n        customLoader && ((id, ...args) => customLoader(...args)),\n      ),\n    };\n    ref.current = heap;\n  }\n\n  return heap;\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}`> = 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}`> = 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\nfunction useAsyncCollection<\n  StateT,\n  PathT extends null | string | undefined,\n  IdT extends number | string,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> = DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>,\n>(\n  id: IdT | IdT[],\n  path: PathT,\n  loader: AsyncCollectionLoaderT<DataT, IdT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT> | 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.\n// eslint-disable-next-line complexity\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 = normalizeIds(idOrIds);\n  const maxage: number = options.maxage ?? DEFAULT_MAXAGE;\n  const refreshAge: number = options.refreshAge ?? maxage;\n  const garbageCollectAge: number = options.garbageCollectAge ?? maxage;\n\n  const globalState = getGlobalState();\n\n  const heap = useHeap(ids, path, loader, globalState);\n\n  // Server-side logic.\n  if (globalState.ssrContext && !options.noSSR) {\n    const operationId: OperationIdT = `S${uuid()}`;\n    for (const id of ids) {\n      const itemPath = path ? `${path}.${id}` : `${id}`;\n      const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(\n        itemPath,\n        {\n          initialValue: newAsyncDataEnvelope<DataT>(),\n        },\n      );\n      if (!state.timestamp && !state.operationId) {\n        globalState.ssrContext.pending.push(\n          // TODO: Revise! Most probably we don't have fully correct loader\n          // typing, as it may return either promise or value, and those two\n          // cases call for different runtime behavior, which in turns only\n          // happens if the outer function on the next line matches the same\n          // async / sync signature.\n          // eslint-disable-next-line @typescript-eslint/promise-function-async\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    const idsHash = hash(ids);\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      gcOnWithhold(ids, path, globalState);\n      return () => {\n        gcOnRelease(ids, path, globalState, garbageCollectAge);\n      };\n\n      // `ids` are represented in the dependencies array by `idsHash` value,\n      // as useEffect() hook requires a constant size of dependencies array.\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n      garbageCollectAge,\n      globalState,\n      idsHash,\n      path,\n    ]);\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    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      void (async () => {\n        for (const id of ids) {\n          const itemPath = path ? `${path}.${id}` : `${id}`;\n\n          type EnvT = AsyncDataEnvelopeT<DataT> | undefined;\n          const state2: EnvT = globalState.get<ForceT, EnvT>(itemPath);\n\n          const { deps } = options;\n          if (\n            (deps && globalState.hasChangedDependencies(itemPath, deps))\n            || (\n              refreshAge < Date.now() - (state2?.timestamp ?? 0)\n              && (!state2?.operationId || state2.operationId.startsWith('S'))\n            )\n          ) {\n            if (!deps) globalState.dropDependencies(itemPath);\n            await load(\n              itemPath,\n              // TODO: I guess, the loader is not correctly typed here -\n              // it can be synchronous, and in that case the following method\n              // should be kept synchronous to not alter the sync logic.\n              // eslint-disable-next-line @typescript-eslint/promise-function-async\n              (old, ...args) => loader(id, old as DataT, ...args),\n              globalState,\n              {\n                data: state2?.data,\n                timestamp: state2?.timestamp ?? 0,\n              },\n            );\n          }\n        }\n      })();\n    });\n  }\n\n  const [localState] = useGlobalState<\n    ForceT, Record<string, AsyncDataEnvelopeT<DataT>>\n  >(path, {});\n\n  if (!Array.isArray(idOrIds)) {\n    // TODO: Revise related typings!\n    const e = localState[idOrIds as string];\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.reloadSingle,\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 (const id of ids) {\n    // TODO: Revise related typing. Should `localState` have a more specific type?\n    const e = localState[id as string];\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\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\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  <PathT extends null | string | undefined, IdT extends number | string>(\n    id: IdT | IdT[],\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>\n    | UseAsyncCollectionResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/{module → code}/useAsyncData.js

@@ -41,7 +41,7 @@ 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: async data (re-)loading. Path: "${path || ''}"`);
+    console.log(`ReactGlobalState: async data (re-)loading. Path: "${path !== null && path !== void 0 ? path : ''}"`);
     /* eslint-enable no-console */
   }
   const operationIdPath = path ? `${path}.operationId` : 'operationId';
@@ -87,7 +87,7 @@ export async function load(path, loader, globalState, old) {
   if (operationId === (state === null || state === void 0 ? void 0 : state.operationId)) {
     if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
       /* eslint-disable no-console */
-      console.groupCollapsed(`ReactGlobalState: async data (re-)loaded. Path: "${path || ''}"`);
+      console.groupCollapsed(`ReactGlobalState: async data (re-)loaded. Path: "${path !== null && path !== void 0 ? path : ''}"`);
       console.log('Data:', cloneDeepForLog(data, path !== null && path !== void 0 ? path : ''));
       /* eslint-enable no-console */
     }
@@ -111,7 +111,7 @@ export async function load(path, loader, globalState, old) {
  */
 
 function useAsyncData(path, loader) {
-  var _options$maxage, _options$refreshAge, _options$garbageColle;
+  var _options$maxage, _options$refreshAge, _options$garbageColle, _heap$reload;
   let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   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;
@@ -129,13 +129,11 @@ function useAsyncData(path, loader) {
   heap.globalState = globalState;
   heap.path = path;
   heap.loader = loader;
-  if (!heap.reload) {
-    heap.reload = customLoader => {
-      const localLoader = customLoader || heap.loader;
-      if (!localLoader || !heap.globalState) throw Error('Internal error');
-      return load(heap.path, localLoader, heap.globalState);
-    };
-  }
+  (_heap$reload = heap.reload) !== null && _heap$reload !== void 0 ? _heap$reload : heap.reload = async customLoader => {
+    const localLoader = customLoader !== null && customLoader !== void 0 ? customLoader : heap.loader;
+    if (!localLoader || !heap.globalState) throw Error('Internal error');
+    return load(heap.path, localLoader, heap.globalState);
+  };
   if (globalState.ssrContext) {
     if (!options.disabled && !options.noSSR && !state.operationId && !state.timestamp) {
       globalState.ssrContext.pending.push(load(path, loader, globalState, {
@@ -170,17 +168,19 @@ function useAsyncData(path, loader) {
           if (state2.numRefs === 1 && garbageCollectAge < Date.now() - state2.timestamp) {
             if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
               /* eslint-disable no-console */
-              console.log(`ReactGlobalState - useAsyncData garbage collected at path ${path || ''}`);
+              console.log(`ReactGlobalState - useAsyncData garbage collected at path ${path !== null && path !== void 0 ? path : ''}`);
               /* eslint-enable no-console */
             }
-            globalState.dropDependencies(path || '');
+            globalState.dropDependencies(path !== null && path !== void 0 ? path : '');
             globalState.set(path, {
               ...state2,
               data: null,
               numRefs: 0,
               timestamp: 0
             });
-          } else globalState.set(numRefsPath, state2.numRefs - 1);
+          } else {
+            globalState.set(numRefsPath, state2.numRefs - 1);
+          }
         }
       };
     }, [disabled, garbageCollectAge, globalState, path]);
@@ -199,12 +199,12 @@ function useAsyncData(path, loader) {
         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)
+        deps && globalState.hasChangedDependencies(path !== null && path !== void 0 ? 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')) {
-          if (!deps) globalState.dropDependencies(path || '');
-          load(path, loader, globalState, {
+        || refreshAge < Date.now() - state2.timestamp && (!state2.operationId || state2.operationId.startsWith('S'))) {
+          if (!deps) globalState.dropDependencies(path !== null && path !== void 0 ? path : '');
+          void load(path, loader, globalState, {
             data: state2.data,
             timestamp: state2.timestamp
           });
@@ -221,4 +221,6 @@ function useAsyncData(path, loader) {
   };
 }
 export { useAsyncData };
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 //# sourceMappingURL=useAsyncData.js.map