@dr.pogodin/react-global-state 0.20.0 → 0.21.0

package/build/cjs/useAsyncData.js

@@ -1,273 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DEFAULT_MAXAGE = void 0;
-exports.load = load;
-exports.newAsyncDataEnvelope = newAsyncDataEnvelope;
-exports.useAsyncData = useAsyncData;
-var _react = require("react");
-var _uuid = require("uuid");
-var _jsUtils = require("@dr.pogodin/js-utils");
-var _GlobalStateProvider = require("./GlobalStateProvider");
-var _useGlobalState = _interopRequireDefault(require("./useGlobalState"));
-var _utils = require("./utils");
-/**
- * Loads and uses async data into the GlobalState path.
- */
-
-const DEFAULT_MAXAGE = exports.DEFAULT_MAXAGE = 5 * _jsUtils.MIN_MS; // 5 minutes.
-
-// NOTE: Here, and below it is important whether a loader and related
-// (re-)loading handlers return a promise or a value, as returning promises
-// mean the async mode, in which related global state values are updated
-// asynchronously (the new value comes into effect in a next rendering cycle),
-// while returning a non-promise value means a synchronous mode, in which
-// related global state values are updated immediately, within the current
-// rendering cycle.
-
-function newAsyncDataEnvelope(initialData = null, {
-  numRefs = 0,
-  timestamp = 0
-} = {}) {
-  return {
-    data: initialData,
-    numRefs,
-    operationId: '',
-    timestamp
-  };
-}
-/**
- * Writes data into the global state, and prints console messages in the debug
- * mode.
- */
-function setState(data, path, gs, prevState = gs.get(path)) {
-  if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-    /* eslint-disable no-console */
-    console.groupCollapsed(`ReactGlobalState: async data (re-)loaded. Path: "${path ?? ''}"`);
-    console.log('Data:', (0, _utils.cloneDeepForLog)(data, path ?? ''));
-    /* eslint-enable no-console */
-  }
-  gs.set(path, {
-    ...prevState,
-    data,
-    operationId: '',
-    timestamp: Date.now()
-  });
-  if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-    /* eslint-disable no-console */
-    console.groupEnd();
-    /* eslint-enable no-console */
-  }
-}
-function finalizeLoad(data, path, gs, operationId) {
-  // NOTE: We don't really mean that it hasn't been aborted,
-  // the "false" flag rather says we don't need to trigger "on aborted"
-  // callback for this operation, if any is registered - just drop it.
-  //
-  // Also, in the synchronous state update mode, we don't really need to set up
-  // the abort callback at all (as there is no way to use it), but for now it is
-  // set up, thus it should be cleaned out here.
-  gs.asyncDataLoadDone(operationId, false);
-  const state = gs.get(path);
-  if (operationId === state?.operationId) setState(data, path, gs, state);
-}
-
-/**
- * Executes the data loading operation.
- * @param path Data segment path inside the global state.
- * @param loader Data loader.
- * @param globalState The global state instance.
- * @param oldData Optional. Previously fetched data, currently stored in
- *  the state, if already fetched by the caller; otherwise, they will be fetched
- *  by the load() function itself.
- * @param opIdPrefix operationId prefix to use, which should be
- * 'C' at the client-side (default), or 'S' at the server-side (within SSR
- * context).
- * @return Resolves once the operation is done.
- * @ignore
- */
-function load(path, loader, globalState, old,
-// TODO: Should this parameter be just a binary flag (client or server),
-// and UUID always generated inside this function? Or do we need it in
-// the caller methods as well, in some cases (see useAsyncCollection()
-// use case as well).
-operationId = `C${(0, _uuid.v4)()}`) {
-  if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-    /* eslint-disable no-console */
-    console.log(`ReactGlobalState: async data (re-)loading. Path: "${path ?? ''}"`);
-    /* eslint-enable no-console */
-  }
-  const operationIdPath = path ? `${path}.operationId` : 'operationId';
-  {
-    const prevOperationId = globalState.get(operationIdPath);
-    if (prevOperationId) globalState.asyncDataLoadDone(prevOperationId, true);
-  }
-  globalState.set(operationIdPath, operationId);
-  let definedOld = old;
-  if (!definedOld) {
-    // TODO: Can we improve the typing, to avoid ForceT?
-    const e = globalState.get(path);
-    definedOld = {
-      data: e.data,
-      timestamp: e.timestamp
-    };
-  }
-  const dataOrPromise = loader(definedOld.data, {
-    isAborted: () => {
-      // TODO: Can we improve the typing, to avoid ForceT?
-      const opid = globalState.get(path).operationId;
-      return opid !== operationId;
-    },
-    oldDataTimestamp: definedOld.timestamp,
-    setAbortCallback(cb) {
-      const opid = globalState.get(path).operationId;
-      if (opid !== operationId) {
-        throw Error(`Operation #${operationId} has completed already`);
-      }
-      globalState.setAsyncDataAbortCallback(operationId, cb);
-    }
-  });
-  if (dataOrPromise instanceof Promise) {
-    return dataOrPromise.then(data => {
-      finalizeLoad(data, path, globalState, operationId);
-    }).finally(() => {
-      // NOTE: We don't really mean that it hasn't been aborted,
-      // the "false" flag rather says we don't need to trigger "on aborted"
-      // callback for this operation, if any is registered - just drop it.
-      globalState.asyncDataLoadDone(operationId, false);
-    });
-  }
-  finalizeLoad(dataOrPromise, path, globalState, operationId);
-  return undefined;
-}
-
-/**
- * Resolves asynchronous data, and stores them at given `path` of global
- * state.
- */
-
-// TODO: Perhaps split the heap management to a dedicated hook,
-// as it is done inside useAsyncCollection().
-
-function useAsyncData(path, loader, options = {}) {
-  const maxage = options.maxage ?? DEFAULT_MAXAGE;
-  const refreshAge = options.refreshAge ?? maxage;
-  const garbageCollectAge = options.garbageCollectAge ?? maxage;
-
-  // Note: here we can't depend on useGlobalState() to init the initial value,
-  // because that way we'll have issues with SSR (see details below).
-  const globalState = (0, _GlobalStateProvider.getGlobalState)();
-  const state = globalState.get(path, {
-    initialValue: newAsyncDataEnvelope()
-  });
-  const {
-    current: heap
-  } = (0, _react.useRef)({});
-  heap.globalState = globalState;
-  heap.path = path;
-  heap.loader = loader;
-  heap.reload ??= customLoader => {
-    const localLoader = customLoader ?? heap.loader;
-    if (!localLoader || !heap.globalState) throw Error('Internal error');
-    return load(heap.path, localLoader, heap.globalState);
-  };
-  heap.set ??= data => {
-    if (!heap.globalState) throw Error('Internal error');
-    setState(data, heap.path, heap.globalState);
-  };
-  if (globalState.ssrContext) {
-    if (!options.disabled && !options.noSSR && !state.operationId && !state.timestamp) {
-      const promiseOrVoid = load(path, loader, globalState, {
-        data: state.data,
-        timestamp: state.timestamp
-      }, `S${(0, _uuid.v4)()}`);
-      if (promiseOrVoid instanceof Promise) {
-        globalState.ssrContext.pending.push(promiseOrVoid);
-      }
-    }
-  } else {
-    const {
-      disabled
-    } = options;
-
-    // This takes care about the client-side reference counting, and garbage
-    // collection.
-    //
-    // Note: the Rules of Hook below are violated by conditional call to a hook,
-    // but as the condition is actually server-side or client-side environment,
-    // it is effectively non-conditional at the runtime.
-    //
-    // TODO: Though, maybe there is a way to refactor it into a cleaner code.
-    // The same applies to other useEffect() hooks below.
-    (0, _react.useEffect)(() => {
-      // eslint-disable-line react-hooks/rules-of-hooks
-      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';
-      if (!disabled) {
-        const numRefs = globalState.get(numRefsPath);
-        globalState.set(numRefsPath, numRefs + 1);
-      }
-      return () => {
-        if (!disabled) {
-          const state2 = globalState.get(path);
-          if (state2.numRefs === 1 && garbageCollectAge < Date.now() - state2.timestamp) {
-            if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-              /* eslint-disable no-console */
-              console.log(`ReactGlobalState - useAsyncData garbage collected at path ${path ?? ''}`);
-              /* eslint-enable no-console */
-            }
-            globalState.dropDependencies(path ?? '');
-            globalState.set(path, {
-              ...state2,
-              data: null,
-              numRefs: 0,
-              timestamp: 0
-            });
-          } else {
-            globalState.set(numRefsPath, state2.numRefs - 1);
-          }
-        }
-      };
-    }, [disabled, garbageCollectAge, globalState, 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.
-
-    // Data loading and refreshing.
-    (0, _react.useEffect)(() => {
-      // eslint-disable-line react-hooks/rules-of-hooks
-      if (!disabled) {
-        const state2 = globalState.get(path);
-        const {
-          deps
-        } = options;
-        if (
-        // The hook is called with a list of dependencies, that mismatch
-        // dependencies last used to retrieve the data at given path.
-        deps && globalState.hasChangedDependencies(path ?? '', deps)
-
-        // Data at the path are stale, and are not being loaded.
-        || refreshAge < Date.now() - state2.timestamp && (!state2.operationId || state2.operationId.startsWith('S'))) {
-          if (!deps) globalState.dropDependencies(path ?? '');
-          void load(path, loader, globalState, {
-            data: state2.data,
-            timestamp: state2.timestamp
-          });
-        }
-      }
-    });
-  }
-  const [localState] = (0, _useGlobalState.default)(path, newAsyncDataEnvelope());
-  return {
-    data: maxage < Date.now() - localState.timestamp ? null : localState.data,
-    loading: Boolean(localState.operationId),
-    reload: heap.reload,
-    set: heap.set,
-    timestamp: localState.timestamp
-  };
-}
-
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-//# sourceMappingURL=useAsyncData.js.map

package/build/cjs/useAsyncData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAsyncData.js","names":["_react","require","_uuid","_jsUtils","_GlobalStateProvider","_useGlobalState","_interopRequireDefault","_utils","DEFAULT_MAXAGE","exports","MIN_MS","newAsyncDataEnvelope","initialData","numRefs","timestamp","data","operationId","setState","path","gs","prevState","get","process","env","NODE_ENV","isDebugMode","console","groupCollapsed","log","cloneDeepForLog","set","Date","now","groupEnd","finalizeLoad","asyncDataLoadDone","state","load","loader","globalState","old","uuid","operationIdPath","prevOperationId","definedOld","e","dataOrPromise","isAborted","opid","oldDataTimestamp","setAbortCallback","cb","Error","setAsyncDataAbortCallback","Promise","then","finally","undefined","useAsyncData","options","maxage","refreshAge","garbageCollectAge","getGlobalState","initialValue","current","heap","useRef","reload","customLoader","localLoader","ssrContext","disabled","noSSR","promiseOrVoid","pending","push","useEffect","numRefsPath","state2","dropDependencies","deps","hasChangedDependencies","startsWith","localState","useGlobalState","loading","Boolean"],"sources":["../../src/useAsyncData.ts"],"sourcesContent":["/**\n * Loads and uses async data into the GlobalState path.\n */\n\nimport { useEffect, useRef } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport { MIN_MS } from '@dr.pogodin/js-utils';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport useGlobalState from './useGlobalState';\n\nimport {\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  cloneDeepForLog,\n  isDebugMode,\n} from './utils';\n\nimport type GlobalState from './GlobalState';\nimport type SsrContext from './SsrContext';\n\nexport const DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.\n\n// NOTE: Here, and below it is important whether a loader and related\n// (re-)loading handlers return a promise or a value, as returning promises\n// mean the async mode, in which related global state values are updated\n// asynchronously (the new value comes into effect in a next rendering cycle),\n// while returning a non-promise value means a synchronous mode, in which\n// related global state values are updated immediately, within the current\n// rendering cycle.\n\nexport type AsyncDataLoaderT<DataT>\n  = (oldData: null | DataT, meta: {\n    isAborted: () => boolean;\n    oldDataTimestamp: number;\n    setAbortCallback: (cb: () => void) => void;\n  }) => DataT | null | Promise<DataT | null>;\n\nexport type AsyncDataReloaderT<DataT>\n  = (loader?: AsyncDataLoaderT<DataT>) => void | Promise<void>;\n\nexport type AsyncDataEnvelopeT<DataT> = {\n  data: null | DataT;\n  numRefs: number;\n  operationId: string;\n  timestamp: number;\n};\n\nexport type OperationIdT = `${'C' | 'S'}${string}`;\n\nexport function newAsyncDataEnvelope<DataT>(\n  initialData: DataT | null = null,\n  { numRefs = 0, timestamp = 0 } = {},\n): AsyncDataEnvelopeT<DataT> {\n  return {\n    data: initialData,\n    numRefs,\n    operationId: '',\n    timestamp,\n  };\n}\n\nexport type UseAsyncDataOptionsT = {\n  deps?: unknown[];\n  disabled?: boolean;\n  garbageCollectAge?: number;\n  maxage?: number;\n  noSSR?: boolean;\n  refreshAge?: number;\n};\n\nexport type UseAsyncDataResT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  reload: AsyncDataReloaderT<DataT>;\n  set: (data: DataT | null) => void;\n  timestamp: number;\n};\n\n/**\n * Writes data into the global state, and prints console messages in the debug\n * mode.\n */\nfunction setState<\n  DataT,\n  EnvT extends AsyncDataEnvelopeT<DataT>,\n>(\n  data: DataT,\n  path: string | null | undefined,\n  gs: GlobalState<unknown, SsrContext<unknown>>,\n  prevState: EnvT = gs.get<ForceT, EnvT>(path),\n) {\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.groupCollapsed(\n      `ReactGlobalState: async data (re-)loaded. Path: \"${\n        path ?? ''\n      }\"`,\n    );\n    console.log('Data:', cloneDeepForLog(data, path ?? ''));\n    /* eslint-enable no-console */\n  }\n\n  gs.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n    ...prevState,\n    data,\n    operationId: '',\n    timestamp: Date.now(),\n  });\n\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.groupEnd();\n    /* eslint-enable no-console */\n  }\n}\n\nfunction finalizeLoad<DataT>(\n  data: DataT,\n  path: null | string | undefined,\n  gs: GlobalState<unknown, SsrContext<unknown>>,\n  operationId: OperationIdT,\n): void {\n  // NOTE: We don't really mean that it hasn't been aborted,\n  // the \"false\" flag rather says we don't need to trigger \"on aborted\"\n  // callback for this operation, if any is registered - just drop it.\n  //\n  // Also, in the synchronous state update mode, we don't really need to set up\n  // the abort callback at all (as there is no way to use it), but for now it is\n  // set up, thus it should be cleaned out here.\n  gs.asyncDataLoadDone(operationId, false);\n\n  type EnvT = AsyncDataEnvelopeT<DataT> | undefined;\n  const state: EnvT = gs.get<ForceT, EnvT>(path);\n\n  if (operationId === state?.operationId) setState(data, path, gs, state);\n}\n\n/**\n * Executes the data loading operation.\n * @param path Data segment path inside the global state.\n * @param loader Data loader.\n * @param globalState The global state instance.\n * @param oldData Optional. Previously fetched data, currently stored in\n *  the state, if already fetched by the caller; otherwise, they will be fetched\n *  by the load() function itself.\n * @param opIdPrefix operationId prefix to use, which should be\n * 'C' at the client-side (default), or 'S' at the server-side (within SSR\n * context).\n * @return Resolves once the operation is done.\n * @ignore\n */\nexport function load<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  globalState: GlobalState<unknown, SsrContext<unknown>>,\n  old?: { data: DataT | null; timestamp: number },\n\n  // TODO: Should this parameter be just a binary flag (client or server),\n  // and UUID always generated inside this function? Or do we need it in\n  // the caller methods as well, in some cases (see useAsyncCollection()\n  // use case as well).\n  operationId: OperationIdT = `C${uuid()}`,\n): void | Promise<void> {\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.log(\n      `ReactGlobalState: async data (re-)loading. Path: \"${path ?? ''}\"`,\n    );\n    /* eslint-enable no-console */\n  }\n\n  const operationIdPath = path ? `${path}.operationId` : 'operationId';\n  {\n    const prevOperationId = globalState.get<ForceT, string>(operationIdPath);\n    if (prevOperationId) globalState.asyncDataLoadDone(prevOperationId, true);\n  }\n  globalState.set<ForceT, string>(operationIdPath, operationId);\n\n  let definedOld = old;\n  if (!definedOld) {\n    // TODO: Can we improve the typing, to avoid ForceT?\n    const e = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path);\n    definedOld = { data: e.data, timestamp: e.timestamp };\n  }\n\n  const dataOrPromise = loader(definedOld.data, {\n    isAborted: () => {\n      // TODO: Can we improve the typing, to avoid ForceT?\n      const opid = globalState.get<\n        ForceT, AsyncDataEnvelopeT<DataT>>(path).operationId;\n      return opid !== operationId;\n    },\n    oldDataTimestamp: definedOld.timestamp,\n    setAbortCallback(cb: () => void) {\n      const opid = globalState.get<\n        ForceT, AsyncDataEnvelopeT<DataT>>(path).operationId;\n      if (opid !== operationId) {\n        throw Error(`Operation #${operationId} has completed already`);\n      }\n      globalState.setAsyncDataAbortCallback(operationId, cb);\n    },\n  });\n\n  if (dataOrPromise instanceof Promise) {\n    return dataOrPromise.then((data) => {\n      finalizeLoad(data, path, globalState, operationId);\n    }).finally(() => {\n      // NOTE: We don't really mean that it hasn't been aborted,\n      // the \"false\" flag rather says we don't need to trigger \"on aborted\"\n      // callback for this operation, if any is registered - just drop it.\n      globalState.asyncDataLoadDone(operationId, false);\n    });\n  }\n\n  finalizeLoad(dataOrPromise, path, globalState, operationId);\n  return undefined;\n}\n\n/**\n * Resolves asynchronous data, and stores them at given `path` of global\n * state.\n */\n\nexport type DataInEnvelopeAtPathT<\n  StateT,\n  PathT extends null | string | undefined,\n> = Exclude<Extract<ValueAtPathT<StateT, PathT, void>, AsyncDataEnvelopeT<unknown>>['data'], null>;\n\n// TODO: Perhaps split the heap management to a dedicated hook,\n// as it is done inside useAsyncCollection().\ntype HeapT<DataT> = {\n  // Note: these heap fields are necessary to make reload() a stable function.\n  globalState?: GlobalState<unknown>;\n  path?: null | string;\n  loader?: AsyncDataLoaderT<DataT>;\n  reload?: AsyncDataReloaderT<DataT>;\n  set?: (data: DataT | null) => void;\n};\n\nfunction useAsyncData<\n  StateT,\n  PathT extends null | string | undefined,\n\n  DataT extends DataInEnvelopeAtPathT<\n    StateT, PathT> = DataInEnvelopeAtPathT<StateT, PathT>,\n>(\n  path: PathT,\n  loader: AsyncDataLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncData<\n  Forced extends ForceT | LockT = LockT,\n  DataT = void,\n>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncData<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const maxage: number = options.maxage ?? DEFAULT_MAXAGE;\n  const refreshAge: number = options.refreshAge ?? maxage;\n  const garbageCollectAge: number = options.garbageCollectAge ?? maxage;\n\n  // Note: here we can't depend on useGlobalState() to init the initial value,\n  // because that way we'll have issues with SSR (see details below).\n  const globalState = getGlobalState();\n  const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n    initialValue: newAsyncDataEnvelope<DataT>(),\n  });\n\n  const { current: heap } = useRef<HeapT<DataT>>({});\n  heap.globalState = globalState;\n  heap.path = path;\n  heap.loader = loader;\n\n  heap.reload ??= (\n    customLoader?: AsyncDataLoaderT<DataT>,\n  ): void | Promise<void> => {\n    const localLoader = customLoader ?? heap.loader;\n    if (!localLoader || !heap.globalState) throw Error('Internal error');\n    return load(heap.path, localLoader, heap.globalState);\n  };\n\n  heap.set ??= (data: DataT | null) => {\n    if (!heap.globalState) throw Error('Internal error');\n    setState(data, heap.path, heap.globalState);\n  };\n\n  if (globalState.ssrContext) {\n    if (\n      !options.disabled && !options.noSSR\n      && !state.operationId && !state.timestamp\n    ) {\n      const promiseOrVoid = load(path, loader, globalState, {\n        data: state.data,\n        timestamp: state.timestamp,\n      }, `S${uuid()}`);\n      if (promiseOrVoid instanceof Promise) {\n        globalState.ssrContext.pending.push(promiseOrVoid);\n      }\n    }\n  } else {\n    const { disabled } = options;\n\n    // This takes care about the client-side reference counting, and garbage\n    // collection.\n    //\n    // Note: the Rules of Hook below are violated by conditional call to a hook,\n    // but as the condition is actually server-side or client-side environment,\n    // it is effectively non-conditional at the runtime.\n    //\n    // TODO: Though, maybe there is a way to refactor it into a cleaner code.\n    // The same applies to other useEffect() hooks below.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';\n      if (!disabled) {\n        const numRefs = globalState.get<ForceT, number>(numRefsPath);\n        globalState.set<ForceT, number>(numRefsPath, numRefs + 1);\n      }\n      return () => {\n        if (!disabled) {\n          const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n            ForceT, AsyncDataEnvelopeT<DataT>>(\n            path,\n          );\n          if (\n            state2.numRefs === 1\n            && garbageCollectAge < Date.now() - state2.timestamp\n          ) {\n            if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n              /* eslint-disable no-console */\n              console.log(\n                `ReactGlobalState - useAsyncData garbage collected at path ${\n                  path ?? ''\n                }`,\n              );\n              /* eslint-enable no-console */\n            }\n            globalState.dropDependencies(path ?? '');\n            globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n              ...state2,\n              data: null,\n              numRefs: 0,\n              timestamp: 0,\n            });\n          } else {\n            globalState.set<ForceT, number>(numRefsPath, state2.numRefs - 1);\n          }\n        }\n      };\n    }, [disabled, garbageCollectAge, globalState, path]);\n\n    // Note: a bunch of Rules of Hooks ignored belows because in our very\n    // special case the otherwise wrong behavior is actually what we need.\n\n    // Data loading and refreshing.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      if (!disabled) {\n        const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n          ForceT, AsyncDataEnvelopeT<DataT>>(path);\n\n        const { deps } = options;\n        if (\n          // The hook is called with a list of dependencies, that mismatch\n          // dependencies last used to retrieve the data at given path.\n          (deps && globalState.hasChangedDependencies(path ?? '', deps))\n\n          // Data at the path are stale, and are not being loaded.\n          || (\n            refreshAge < Date.now() - state2.timestamp\n            && (!state2.operationId || state2.operationId.startsWith('S'))\n          )\n        ) {\n          if (!deps) globalState.dropDependencies(path ?? '');\n          void load(path, loader, globalState, {\n            data: state2.data,\n            timestamp: state2.timestamp,\n          });\n        }\n      }\n    });\n  }\n\n  const [localState] = useGlobalState<ForceT, AsyncDataEnvelopeT<DataT>>(\n    path,\n    newAsyncDataEnvelope<DataT>(),\n  );\n\n  return {\n    data: maxage < Date.now() - localState.timestamp ? null : localState.data,\n    loading: Boolean(localState.operationId),\n    reload: heap.reload,\n    set: heap.set,\n    timestamp: localState.timestamp,\n  };\n}\n\nexport { useAsyncData };\n\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport interface UseAsyncDataI<StateT> {\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/cjs/useGlobalState.js

@@ -1,148 +0,0 @@
-"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)(null);
-  const [stable] = (0, _react.useState)(() => {
-    const emitter = new _jsUtils.Emitter();
-    const setter = value => {
-      const rc = ref.current;
-      if (!rc) throw Error('Internal error');
-      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.prevValue) emitter.emit();
-    };
-    const subscribe = emitter.addListener.bind(emitter);
-    return {
-      emitter,
-      setter,
-      subscribe
-    };
-  });
-  const value = (0, _react.useSyncExternalStore)(stable.subscribe, () => globalState.get(path, {
-    initialValue
-  }), () => globalState.get(path, {
-    initialState: true,
-    initialValue
-  }));
-  ref.current ??= {
-    globalState,
-    path,
-    prevValue: value
-  };
-  (0, _react.useEffect)(() => {
-    ref.current = {
-      globalState,
-      path,
-      prevValue: ref.current.prevValue
-    };
-    const watcher = () => {
-      const nextValue = globalState.get(path);
-      if (ref.current.prevValue !== nextValue) {
-        ref.current.prevValue = nextValue;
-        stable.emitter.emit();
-      }
-    };
-    globalState.watch(watcher);
-    watcher();
-    return () => {
-      globalState.unWatch(watcher);
-    };
-  }, [globalState, stable.emitter, path]);
-  return [value, stable.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

@@ -1 +0,0 @@
-{"version":3,"file":"useGlobalState.js","names":["_lodash","require","_react","_jsUtils","_GlobalStateProvider","_utils","useGlobalState","path","initialValue","globalState","getGlobalState","ref","useRef","stable","useState","emitter","Emitter","setter","value","rc","current","Error","newState","isFunction","get","process","env","NODE_ENV","isDebugMode","console","groupCollapsed","log","cloneDeepForLog","groupEnd","set","prevValue","emit","subscribe","addListener","bind","useSyncExternalStore","initialState","useEffect","watcher","nextValue","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  useState,\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 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 CurrentT = {\n  globalState: GlobalState<unknown>;\n  path: null | string | undefined;\n  prevValue: unknown;\n};\n\ntype StableT = {\n  emitter: Emitter<[]>;\n  setter: SetterT<unknown>;\n  subscribe: (listener: ListenerT) => () => void;\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<CurrentT>(null);\n\n  const [stable] = useState<StableT>(() => {\n    const emitter = new Emitter();\n    const setter = (value: unknown) => {\n      const rc = ref.current;\n      if (!rc) throw Error('Internal error');\n\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.prevValue) emitter.emit();\n    };\n    const subscribe = emitter.addListener.bind(emitter);\n    return { emitter, setter, subscribe };\n  });\n\n  const value = useSyncExternalStore(\n    stable.subscribe,\n    () => globalState.get<ForceT, unknown>(path, { initialValue }),\n\n    () => globalState.get<ForceT, unknown>(\n      path,\n      { initialState: true, initialValue },\n    ),\n  );\n\n  ref.current ??= {\n    globalState,\n    path,\n    prevValue: value,\n  };\n\n  useEffect(() => {\n    ref.current = {\n      globalState,\n      path,\n      prevValue: ref.current!.prevValue,\n    };\n\n    const watcher = () => {\n      const nextValue = globalState.get<ForceT, unknown>(path);\n      if (ref.current!.prevValue !== nextValue) {\n        ref.current!.prevValue = nextValue;\n        stable.emitter.emit();\n      }\n    };\n\n    globalState.watch(watcher);\n    watcher();\n\n    return () => {\n      globalState.unWatch(watcher);\n    };\n  }, [globalState, stable.emitter, path]);\n\n  return [value, stable.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

@@ -1,91 +0,0 @@
-"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

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