@dr.pogodin/react-global-state 0.9.3 → 0.10.0-alpha.2

package/build/node/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["_GlobalStateProvider","_interopRequireWildcard","require","_useAsyncCollection","_interopRequireDefault","_useAsyncData","_useGlobalState","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Promise","allSettled","promises","all","map","p","finally"],"sources":["../../src/index.js"],"sourcesContent":["// TODO: This is a temporary polyfill for `Promise.allSettled(..)` method,\n// which is supported natively by NodeJS >= v12.9.0. As earlier NodeJS version\n// are still in a wide use, this polyfill is added here, and it is to be dropped\n// some time later.\nif (!Promise.allSettled) {\n  Promise.allSettled = (promises) => Promise.all(\n    promises.map((p) => (p instanceof Promise ? p.finally(() => null) : p)),\n  );\n}\n\nexport {\n  default as GlobalStateProvider,\n  getGlobalState,\n  getSsrContext,\n} from './GlobalStateProvider';\n\nexport { default as useAsyncCollection } from './useAsyncCollection';\nexport { default as useAsyncData } from './useAsyncData';\nexport { default as useGlobalState } from './useGlobalState';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,IAAAA,oBAAA,GAAAC,uBAAA,CAAAC,OAAA;AAMA,IAAAC,mBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,aAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,eAAA,GAAAF,sBAAA,CAAAF,OAAA;AAA6D,SAAAK,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAP,wBAAAW,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,oBAAAA,GAAA,wBAAAA,GAAA,4BAAAE,OAAA,EAAAF,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,CAAAJ,OAAA,GAAAF,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AAlB7D;AACA;AACA;AACA;AACA,IAAI,CAACW,OAAO,CAACC,UAAU,EAAE;EACvBD,OAAO,CAACC,UAAU,GAAIC,QAAQ,IAAKF,OAAO,CAACG,GAAG,CAC5CD,QAAQ,CAACE,GAAG,CAAEC,CAAC,IAAMA,CAAC,YAAYL,OAAO,GAAGK,CAAC,CAACC,OAAO,CAAC,MAAM,IAAI,CAAC,GAAGD,CAAE,CAAC,CACxE;AACH"}

package/build/node/useAsyncCollection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAsyncCollection.js","names":["_useAsyncData","_interopRequireDefault","require","useAsyncCollection","id","path","loader","options","itemPath","useAsyncData","oldData"],"sources":["../../src/useAsyncCollection.js"],"sourcesContent":["/**\n * Loads and uses an item in an async collection.\n */\n\nimport useAsyncData from './useAsyncData';\n\n/**\n * Resolves and stores at the given `path` of global state elements of\n * an asynchronous data collection. In other words, it is an auxiliar wrapper\n * around {@link useAsyncData}, which uses a loader which resolves to different\n * data, based on ID argument passed in, and stores data fetched for different\n * IDs in the state.\n * @param {string} id ID of the collection item to load & use.\n * @param {string} path The global state path where entire collection should be\n *  stored.\n * @param {AsyncCollectionLoader} loader A loader function, which takes an\n * ID of data to load, and resolves to the corresponding data.\n * @param {object} [options] Additional options.\n * @param {any[]} [options.deps=[]] An array of dependencies, which trigger\n * data reload when changed. Given dependency changes are watched shallowly\n * (similarly to the standard React's\n * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).\n * @param {boolean} [options.noSSR] If `true`, this hook won't load data during\n * server-side rendering.\n * @param {number} [options.garbageCollectAge=maxage] The maximum age of data\n * (in milliseconds), after which they are dropped from the state when the last\n * component referencing them via `useAsyncData()` hook unmounts. Defaults to\n * `maxage` option value.\n * @param {number} [options.maxage=5 x 60 x 1000] The maximum age of\n * data (in milliseconds) acceptable to the hook's caller. If loaded data are\n * older than this value, `null` is returned instead. Defaults to 5 minutes.\n * @param {number} [options.refreshAge=maxage] The maximum age of data\n * (in milliseconds), after which their refreshment will be triggered when\n * any component referencing them via `useAsyncData()` hook (re-)renders.\n * Defaults to `maxage` value.\n * @return {{\n *   data: any,\n *   loading: boolean,\n *   timestamp: number\n * }} Returns an object with three fields: `data` holds the actual result of\n * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`\n * is a boolean flag, which is `true` if data are being loaded (the hook is\n * waiting for `loader` function resolution); `timestamp` (in milliseconds)\n * is Unix timestamp of related data currently loaded into the global state.\n *\n * Note that loaded data, if any, are stored at the given `path` of global state\n * along with related meta-information, using slightly different state segment\n * structure (see {@link AsyncDataEnvelope}). That segment of the global state\n * can be accessed, and even modified using other hooks,\n * _e.g._ {@link useGlobalState}, but doing so you may interfere with related\n * `useAsyncData()` hooks logic.\n */\nexport default function useAsyncCollection(\n  id,\n  path,\n  loader,\n  options = {},\n) {\n  const itemPath = path ? `${path}.${id}` : id;\n  return useAsyncData(itemPath, (oldData) => loader(id, oldData), options);\n}\n"],"mappings":";;;;;;;AAIA,IAAAA,aAAA,GAAAC,sBAAA,CAAAC,OAAA;AAJA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,kBAAkBA,CACxCC,EAAE,EACFC,IAAI,EACJC,MAAM,EACNC,OAAO,GAAG,CAAC,CAAC,EACZ;EACA,MAAMC,QAAQ,GAAGH,IAAI,GAAI,GAAEA,IAAK,IAAGD,EAAG,EAAC,GAAGA,EAAE;EAC5C,OAAO,IAAAK,qBAAY,EAACD,QAAQ,EAAGE,OAAO,IAAKJ,MAAM,CAACF,EAAE,EAAEM,OAAO,CAAC,EAAEH,OAAO,CAAC;AAC1E"}

package/build/node/useAsyncData.js

@@ -1,211 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = useAsyncData;
-var _lodash = require("lodash");
-var _react = require("react");
-var _uuid = require("uuid");
-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 = 5 * 60 * 1000; // 5 minutes.
-
-/**
- * Executes the data loading operation.
- * @param {string} path Data segment path inside the global state.
- * @param {function} loader Data loader.
- * @param {GlobalState} globalState The global state instance.
- * @param {any} [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 {string} [opIdPrefix='C'] operationId prefix to use, which should be
- * 'C' at the client-side (default), or 'S' at the server-side (within SSR
- * context).
- * @return {Promise} Resolves once the operation is done.
- * @ignore
- */
-async function load(path, loader, globalState, oldData, opIdPrefix = 'C') {
-  if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-    /* eslint-disable no-console */
-    console.log(`ReactGlobalState: useAsyncData data (re-)loading. Path: "${path || ''}"`);
-    /* eslint-enable no-console */
-  }
-
-  const operationId = opIdPrefix + (0, _uuid.v4)();
-  const operationIdPath = path ? `${path}.operationId` : 'operationId';
-  globalState.set(operationIdPath, operationId);
-  const data = await loader(oldData || globalState.get(path).data);
-  const state = globalState.get(path);
-  if (operationId === state.operationId) {
-    if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-      /* eslint-disable no-console */
-      console.groupCollapsed(`ReactGlobalState: useAsyncData data (re-)loaded. Path: "${path || ''}"`);
-      console.log('Data:', (0, _lodash.cloneDeep)(data));
-      /* eslint-enable no-console */
-    }
-
-    globalState.set(path, {
-      ...state,
-      data,
-      operationId: '',
-      timestamp: Date.now()
-    });
-    if (process.env.NODE_ENV !== 'production' && (0, _utils.isDebugMode)()) {
-      /* eslint-disable no-console */
-      console.groupEnd();
-      /* eslint-enable no-console */
-    }
-  }
-}
-
-/**
- * Resolves asynchronous data, and stores them at given `path` of global
- * state. When multiple components rely on asynchronous data at the same `path`,
- * the data are resolved once, and reused until their age is within specified
- * bounds. Once the data are stale, the hook allows to refresh them. It also
- * garbage-collects stale data from the global state when the last component
- * relying on them is unmounted.
- * @param {string} path Dot-delimitered state path, where data envelop is
- * stored.
- * @param {AsyncDataLoader} loader Asynchronous function which resolves (loads)
- * data, which should be stored at the global state `path`. When multiple
- * components
- * use `useAsyncData()` hook for the same `path`, the library assumes that all
- * hook instances are called with the same `loader` (_i.e._ whichever of these
- * loaders is used to resolve async data, the result is acceptable to be reused
- * in all related components).
- * @param {object} [options] Additional options.
- * @param {any[]}  [options.deps=[]] An array of dependencies, which trigger
- * data reload when changed. Given dependency changes are watched shallowly
- * (similarly to the standard React's
- * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).
- * @param {boolean} [options.noSSR] If `true`, this hook won't load data during
- * server-side rendering.
- * @param {number} [options.garbageCollectAge=maxage] The maximum age of data
- * (in milliseconds), after which they are dropped from the state when the last
- * component referencing them via `useAsyncData()` hook unmounts. Defaults to
- * `maxage` option value.
- * @param {number} [options.maxage=5 x 60 x 1000] The maximum age of
- * data (in milliseconds) acceptable to the hook's caller. If loaded data are
- * older than this value, `null` is returned instead. Defaults to 5 minutes.
- * @param {number} [options.refreshAge=maxage] The maximum age of data
- * (in milliseconds), after which their refreshment will be triggered when
- * any component referencing them via `useAsyncData()` hook (re-)renders.
- * Defaults to `maxage` value.
- * @return {{
- *   data: any,
- *   loading: boolean,
- *   timestamp: number
- * }} Returns an object with three fields: `data` holds the actual result of
- * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`
- * is a boolean flag, which is `true` if data are being loaded (the hook is
- * waiting for `loader` function resolution); `timestamp` (in milliseconds)
- * is Unix timestamp of related data currently loaded into the global state.
- *
- * Note that loaded data, if any, are stored at the given `path` of global state
- * along with related meta-information, using slightly different state segment
- * structure (see {@link AsyncDataEnvelope}). That segment of the global state
- * can be accessed, and even modified using other hooks,
- * _e.g._ {@link useGlobalState}, but doing so you may interfere with related
- * `useAsyncData()` hooks logic.
- */
-function useAsyncData(path, loader, options = {}) {
-  let {
-    garbageCollectAge,
-    maxage,
-    refreshAge
-  } = options;
-  if (maxage === undefined) maxage = DEFAULT_MAXAGE;
-  if (refreshAge === undefined) refreshAge = maxage;
-  if (garbageCollectAge === undefined) 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: {
-      data: null,
-      numRefs: 0,
-      operationId: '',
-      timestamp: 0
-    }
-  });
-  if (globalState.ssrContext && !options.noSSR) {
-    if (!state.timestamp && !state.operationId) {
-      globalState.ssrContext.pending.push(load(path, loader, globalState, state.data, 'S'));
-    }
-  } else {
-    // 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';
-      const numRefs = globalState.get(numRefsPath);
-      globalState.set(numRefsPath, numRefs + 1);
-      return () => {
-        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.set(path, {
-            ...state2,
-            data: null,
-            numRefs: 0,
-            timestamp: 0
-          });
-        } else globalState.set(numRefsPath, state2.numRefs - 1);
-      };
-    }, [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.
-    let loadTriggered = false;
-    (0, _react.useEffect)(() => {
-      // eslint-disable-line react-hooks/rules-of-hooks
-      const state2 = globalState.get(path);
-      if (refreshAge < Date.now() - state2.timestamp && (!state2.operationId || state2.operationId.charAt() === 'S')) {
-        load(path, loader, globalState, state2.data);
-        loadTriggered = true; // eslint-disable-line react-hooks/exhaustive-deps
-      }
-    });
-
-    const deps = options.deps || [];
-    (0, _react.useEffect)(() => {
-      // eslint-disable-line react-hooks/rules-of-hooks
-      if (!loadTriggered && deps.length) load(path, loader, globalState);
-    }, deps); // eslint-disable-line react-hooks/exhaustive-deps
-  }
-
-  const [localState] = (0, _useGlobalState.default)(path, {
-    data: null,
-    numRefs: 0,
-    operationId: '',
-    timestamp: 0
-  });
-  return {
-    data: maxage < Date.now() - localState.timestamp ? null : localState.data,
-    loading: Boolean(localState.operationId),
-    timestamp: localState.timestamp
-  };
-}
-//# sourceMappingURL=useAsyncData.js.map

package/build/node/useAsyncData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAsyncData.js","names":["_lodash","require","_react","_uuid","_GlobalStateProvider","_useGlobalState","_interopRequireDefault","_utils","DEFAULT_MAXAGE","load","path","loader","globalState","oldData","opIdPrefix","process","env","NODE_ENV","isDebugMode","console","log","operationId","uuid","operationIdPath","set","data","get","state","groupCollapsed","cloneDeep","timestamp","Date","now","groupEnd","useAsyncData","options","garbageCollectAge","maxage","refreshAge","undefined","getGlobalState","initialValue","numRefs","ssrContext","noSSR","pending","push","useEffect","numRefsPath","state2","loadTriggered","charAt","deps","length","localState","useGlobalState","loading","Boolean"],"sources":["../../src/useAsyncData.js"],"sourcesContent":["/**\n * Loads and uses async data into the GlobalState path.\n */\n\nimport { cloneDeep } from 'lodash';\nimport { useEffect } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport useGlobalState from './useGlobalState';\nimport { isDebugMode } from './utils';\n\nconst DEFAULT_MAXAGE = 5 * 60 * 1000; // 5 minutes.\n\n/**\n * Executes the data loading operation.\n * @param {string} path Data segment path inside the global state.\n * @param {function} loader Data loader.\n * @param {GlobalState} globalState The global state instance.\n * @param {any} [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 {string} [opIdPrefix='C'] 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 {Promise} Resolves once the operation is done.\n * @ignore\n */\nasync function load(path, loader, globalState, oldData, opIdPrefix = 'C') {\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.log(\n      `ReactGlobalState: useAsyncData data (re-)loading. Path: \"${path || ''}\"`,\n    );\n    /* eslint-enable no-console */\n  }\n  const operationId = opIdPrefix + uuid();\n  const operationIdPath = path ? `${path}.operationId` : 'operationId';\n  globalState.set(operationIdPath, operationId);\n  const data = await loader(oldData || globalState.get(path).data);\n  const state = globalState.get(path);\n  if (operationId === state.operationId) {\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupCollapsed(\n        `ReactGlobalState: useAsyncData data (re-)loaded. Path: \"${\n          path || ''\n        }\"`,\n      );\n      console.log('Data:', cloneDeep(data));\n      /* eslint-enable no-console */\n    }\n    globalState.set(path, {\n      ...state,\n      data,\n      operationId: '',\n      timestamp: Date.now(),\n    });\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n  }\n}\n\n/**\n * Resolves asynchronous data, and stores them at given `path` of global\n * state. When multiple components rely on asynchronous data at the same `path`,\n * the data are resolved once, and reused until their age is within specified\n * bounds. Once the data are stale, the hook allows to refresh them. It also\n * garbage-collects stale data from the global state when the last component\n * relying on them is unmounted.\n * @param {string} path Dot-delimitered state path, where data envelop is\n * stored.\n * @param {AsyncDataLoader} loader Asynchronous function which resolves (loads)\n * data, which should be stored at the global state `path`. When multiple\n * components\n * use `useAsyncData()` hook for the same `path`, the library assumes that all\n * hook instances are called with the same `loader` (_i.e._ whichever of these\n * loaders is used to resolve async data, the result is acceptable to be reused\n * in all related components).\n * @param {object} [options] Additional options.\n * @param {any[]}  [options.deps=[]] An array of dependencies, which trigger\n * data reload when changed. Given dependency changes are watched shallowly\n * (similarly to the standard React's\n * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).\n * @param {boolean} [options.noSSR] If `true`, this hook won't load data during\n * server-side rendering.\n * @param {number} [options.garbageCollectAge=maxage] The maximum age of data\n * (in milliseconds), after which they are dropped from the state when the last\n * component referencing them via `useAsyncData()` hook unmounts. Defaults to\n * `maxage` option value.\n * @param {number} [options.maxage=5 x 60 x 1000] The maximum age of\n * data (in milliseconds) acceptable to the hook's caller. If loaded data are\n * older than this value, `null` is returned instead. Defaults to 5 minutes.\n * @param {number} [options.refreshAge=maxage] The maximum age of data\n * (in milliseconds), after which their refreshment will be triggered when\n * any component referencing them via `useAsyncData()` hook (re-)renders.\n * Defaults to `maxage` value.\n * @return {{\n *   data: any,\n *   loading: boolean,\n *   timestamp: number\n * }} Returns an object with three fields: `data` holds the actual result of\n * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`\n * is a boolean flag, which is `true` if data are being loaded (the hook is\n * waiting for `loader` function resolution); `timestamp` (in milliseconds)\n * is Unix timestamp of related data currently loaded into the global state.\n *\n * Note that loaded data, if any, are stored at the given `path` of global state\n * along with related meta-information, using slightly different state segment\n * structure (see {@link AsyncDataEnvelope}). That segment of the global state\n * can be accessed, and even modified using other hooks,\n * _e.g._ {@link useGlobalState}, but doing so you may interfere with related\n * `useAsyncData()` hooks logic.\n */\nexport default function useAsyncData(\n  path,\n  loader,\n  options = {},\n) {\n  let { garbageCollectAge, maxage, refreshAge } = options;\n  if (maxage === undefined) maxage = DEFAULT_MAXAGE;\n  if (refreshAge === undefined) refreshAge = maxage;\n  if (garbageCollectAge === undefined) 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(path, {\n    initialValue: {\n      data: null,\n      numRefs: 0,\n      operationId: '',\n      timestamp: 0,\n    },\n  });\n\n  if (globalState.ssrContext && !options.noSSR) {\n    if (!state.timestamp && !state.operationId) {\n      globalState.ssrContext.pending.push(\n        load(path, loader, globalState, state.data, 'S'),\n      );\n    }\n  } else {\n    // This takes care about the client-side reference counting, and garbage\n    // collection.\n    //\n    // Note: the Rules of Hook below are violated by conditional call to a hook,\n    // but as the condition is actually server-side or client-side environment,\n    // it is effectively non-conditional at the runtime.\n    //\n    // TODO: Though, maybe there is a way to refactor it into a cleaner code.\n    // The same applies to other useEffect() hooks below.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';\n      const numRefs = globalState.get(numRefsPath);\n      globalState.set(numRefsPath, numRefs + 1);\n      return () => {\n        const state2 = globalState.get(path);\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.set(path, {\n            ...state2,\n            data: null,\n            numRefs: 0,\n            timestamp: 0,\n          });\n        } else globalState.set(numRefsPath, state2.numRefs - 1);\n      };\n    }, [garbageCollectAge, globalState, path]);\n\n    // Note: a bunch of Rules of Hooks ignored belows because in our very\n    // special case the otherwise wrong behavior is actually what we need.\n\n    // Data loading and refreshing.\n    let loadTriggered = false;\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const state2 = globalState.get(path);\n      if (refreshAge < Date.now() - state2.timestamp\n      && (!state2.operationId || state2.operationId.charAt() === 'S')) {\n        load(path, loader, globalState, state2.data);\n        loadTriggered = true; // eslint-disable-line react-hooks/exhaustive-deps\n      }\n    });\n\n    const deps = options.deps || [];\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      if (!loadTriggered && deps.length) load(path, loader, globalState);\n    }, deps); // eslint-disable-line react-hooks/exhaustive-deps\n  }\n\n  const [localState] = useGlobalState(path, {\n    data: null,\n    numRefs: 0,\n    operationId: '',\n    timestamp: 0,\n  });\n\n  return {\n    data: maxage < Date.now() - localState.timestamp ? null : localState.data,\n    loading: Boolean(localState.operationId),\n    timestamp: localState.timestamp,\n  };\n}\n"],"mappings":"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"}

package/build/node/useGlobalState.js

@@ -1,114 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = useGlobalState;
-var _lodash = require("lodash");
-var _react = require("react");
-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 {string} [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 {any} [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 {Array} 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.
- */
-function useGlobalState(path, initialValue) {
-  const ref = (0, _react.useRef)();
-  if (!ref.current) {
-    ref.current = {
-      callbacks: [],
-      setter: value => {
-        const rc = ref.current;
-        const newState = (0, _lodash.isFunction)(value) ? value(rc.state) : 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, _lodash.cloneDeep)(newState));
-          console.groupEnd();
-          /* eslint-enable no-console */
-        }
-
-        rc.globalState.set(rc.path, newState);
-      },
-      watcher: () => {
-        const rc = ref.current;
-        const state = rc.globalState.get(rc.path);
-        if (state !== rc.state) {
-          for (let i = 0; i < rc.callbacks.length; ++i) {
-            rc.callbacks[i]();
-          }
-        }
-      }
-    };
-  }
-  const rc = ref.current;
-  const globalState = (0, _GlobalStateProvider.getGlobalState)();
-  rc.globalState = globalState;
-  rc.path = path;
-  rc.state = (0, _react.useSyncExternalStore)(cb => {
-    rc.callbacks.push(cb);
-  }, () => rc.globalState.get(rc.path, {
-    initialValue
-  }), () => rc.globalState.get(rc.path, {
-    initialValue,
-    initialState: true
-  }));
-  (0, _react.useEffect)(() => {
-    globalState.watch(rc.watcher);
-    rc.watcher();
-    return () => globalState.unWatch(rc.watcher);
-  }, [globalState, rc]);
-  (0, _react.useEffect)(() => {
-    rc.watcher();
-  }, [path, rc]);
-  return [rc.state, rc.setter];
-}
-//# sourceMappingURL=useGlobalState.js.map

package/build/node/useGlobalState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useGlobalState.js","names":["_lodash","require","_react","_GlobalStateProvider","_utils","useGlobalState","path","initialValue","ref","useRef","current","callbacks","setter","value","rc","newState","isFunction","state","process","env","NODE_ENV","isDebugMode","console","groupCollapsed","log","cloneDeep","groupEnd","globalState","set","watcher","get","i","length","getGlobalState","useSyncExternalStore","cb","push","initialState","useEffect","watch","unWatch"],"sources":["../../src/useGlobalState.js"],"sourcesContent":["// Hook for updates of global state.\n\nimport { cloneDeep, isFunction } from 'lodash';\nimport { useEffect, useRef, useSyncExternalStore } from 'react';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport { isDebugMode } from './utils';\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 {string} [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 {any} [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 {Array} 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 */\nexport default function useGlobalState(path, initialValue) {\n  const ref = useRef();\n  if (!ref.current) {\n    ref.current = {\n      callbacks: [],\n      setter: (value) => {\n        const rc = ref.current;\n        const newState = isFunction(value) ? value(rc.state) : value;\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:', cloneDeep(newState));\n          console.groupEnd();\n          /* eslint-enable no-console */\n        }\n        rc.globalState.set(rc.path, newState);\n      },\n      watcher: () => {\n        const rc = ref.current;\n        const state = rc.globalState.get(rc.path);\n        if (state !== rc.state) {\n          for (let i = 0; i < rc.callbacks.length; ++i) {\n            rc.callbacks[i]();\n          }\n        }\n      },\n    };\n  }\n\n  const rc = ref.current;\n  const globalState = getGlobalState();\n  rc.globalState = globalState;\n  rc.path = path;\n\n  rc.state = useSyncExternalStore(\n    (cb) => { rc.callbacks.push(cb); },\n    () => rc.globalState.get(rc.path, { initialValue }),\n    () => rc.globalState.get(rc.path, { initialValue, initialState: true }),\n  );\n\n  useEffect(() => {\n    globalState.watch(rc.watcher);\n    rc.watcher();\n    return () => globalState.unWatch(rc.watcher);\n  }, [globalState, rc]);\n\n  useEffect(() => {\n    rc.watcher();\n  }, [path, rc]);\n\n  return [rc.state, rc.setter];\n}\n"],"mappings":"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"}

package/build/node/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":["isDebugMode","process","env","NODE_ENV","REACT_GLOBAL_STATE_DEBUG","error","_default","exports","default"],"sources":["../../src/utils.js"],"sourcesContent":["// Auxiliary stuff.\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 {boolean}\n * @ignore\n */\nexport function isDebugMode() {\n  try {\n    return process.env.NODE_ENV !== 'production'\n      && !!process.env.REACT_GLOBAL_STATE_DEBUG;\n  } catch (error) {\n    return false;\n  }\n}\n\nexport default null;\n"],"mappings":";;;;;;;AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,WAAWA,CAAA,EAAG;EAC5B,IAAI;IACF,OAAOC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,IACvC,CAAC,CAACF,OAAO,CAACC,GAAG,CAACE,wBAAwB;EAC7C,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,OAAO,KAAK;EACd;AACF;AAAC,IAAAC,QAAA,GAEc,IAAI;AAAAC,OAAA,CAAAC,OAAA,GAAAF,QAAA"}

package/index.d.ts

@@ -1,70 +0,0 @@
-import React from "react";
-
-interface IAsyncDataEnvelope<DataT> {
-  data: null|DataT,
-  loading: boolean,
-  timestamp: number,
-}
-
-interface ISsrContext<StateT> {
-  dirty: boolean;
-  pending: Array<Promise<any>>;
-  state: StateT;
-}
-
-interface IGlobalState<StateT> {
-  constructor: new (
-    initialState: StateT,
-    ssrContext: ISsrContext<StateT>,
-  ) => IGlobalState<StateT>;
-
-  get<T>(path?: string): T;
-  set<T>(path: string|undefined, value: T): T;
-  unWatch(callback: () => void);
-  watch(callback: () => void);
-}
-
-type GlobalStateProviderProps<StateT> = {
-  children?: React.ReactNode;
-  initialState?: StateT;
-  ssrContext?: ISsrContext<StateT>;
-  stateProxy?: true|IGlobalState<StateT>;
-};
-
-export function GlobalStateProvider<StateT>(
-  props: GlobalStateProviderProps<StateT>
-): JSX.Element;
-
-export function getSsrContext<StateT>(throwWithoutSsrContext: boolean):
-  ISsrContext<StateT>|undefined;
-
-export function getGlobalState<StateT>(): IGlobalState<StateT>;
-
-export function useGlobalState<T>(
-  path: string|undefined,
-  initialValue: T | (() => T),
-): [
-  value: T,
-  setValue: (value: T | ((value: T) => T)) => void,
-];
-
-type UseAsyncOptionsType = {
-  deps?: Array<any>,
-  noSSR?: boolean,
-  garbageCollectAge?: number,
-  maxage?: number,
-  refreshAge?: number,
-};
-
-export function useAsyncData<DataT>(
-  path: string|undefined,
-  loader: (prevData: DataT|null) => DataT | Promise<DataT>,
-  options?: UseAsyncOptionsType,
-): IAsyncDataEnvelope<DataT>
-
-export function useAsyncCollection<DataT>(
-  id: string,
-  path: string|undefined,
-  loader: (id: string, prevData: DataT|null) => DataT | Promise<DataT>,
-  options?: UseAsyncOptionsType,
-): IAsyncDataEnvelope<DataT>