@dr.pogodin/react-global-state 0.10.0-alpha.1 → 0.10.0-alpha.3

package/build/common/GlobalStateProvider.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = GlobalStateProvider;
+exports.getGlobalState = getGlobalState;
+exports.getSsrContext = getSsrContext;
+var _lodash = require("lodash");
+var _react = require("react");
+var _GlobalState = _interopRequireDefault(require("./GlobalState"));
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable react/prop-types */
+
+const context = /*#__PURE__*/(0, _react.createContext)(null);
+
+/**
+ * Gets {@link GlobalState} instance from the context. In most cases
+ * you should use {@link useGlobalState}, and other hooks to interact with
+ * the global state, instead of accessing it directly.
+ * @return
+ */
+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 */
+  const globalState = (0, _react.useContext)(context);
+  /* eslint-enable react-hooks/rules-of-hooks */
+  if (!globalState) throw new Error('Missing GlobalStateProvider');
+  return globalState;
+}
+
+/**
+ * @category Hooks
+ * @desc Gets SSR context.
+ * @param throwWithoutSsrContext If `true` (default),
+ * this hook will throw if no SSR context is attached to the global state;
+ * set `false` to not throw in such case. In either case the hook will throw
+ * if the {@link <GlobalStateProvider>} (hence the state) is missing.
+ * @returns SSR context.
+ * @throws
+ * - If current component has no parent {@link <GlobalStateProvider>}
+ *   in the rendered React tree.
+ * - If `throwWithoutSsrContext` is `true`, and there is no SSR context attached
+ *   to the global state provided by {@link <GlobalStateProvider>}.
+ */
+function getSsrContext(throwWithoutSsrContext = true) {
+  const {
+    ssrContext
+  } = getGlobalState();
+  if (!ssrContext && throwWithoutSsrContext) {
+    throw new Error('No SSR context found');
+  }
+  return ssrContext;
+}
+/**
+ * Provides global state to its children.
+ * @param prop.children Component children, which will be provided with
+ * the global state, and rendered in place of the provider.
+ * @param prop.initialState Initial content of the global state.
+ * @param prop.ssrContext Server-side rendering (SSR) context.
+ * @param prop.stateProxy This option is useful for code
+ * splitting and SSR implementation:
+ * - If `true`, this provider instance will fetch and reuse the global state
+ *   from a parent provider.
+ * - If `GlobalState` instance, it will be used by this provider.
+ * - If not given, a new `GlobalState` instance will be created and used.
+ */
+function GlobalStateProvider({
+  children,
+  ...rest
+}) {
+  const state = (0, _react.useRef)();
+  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 {
+        initialState,
+        ssrContext
+      } = rest;
+      state.current = new _GlobalState.default((0, _lodash.isFunction)(initialState) ? initialState() : initialState, ssrContext);
+    }
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(context.Provider, {
+    value: state.current,
+    children: children
+  });
+}
+GlobalStateProvider.defaultProps = {
+  children: undefined
+};
+//# sourceMappingURL=GlobalStateProvider.js.map

package/build/common/GlobalStateProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalStateProvider.js","names":["_lodash","require","_react","_GlobalState","_interopRequireDefault","_jsxRuntime","context","createContext","getGlobalState","globalState","useContext","Error","getSsrContext","throwWithoutSsrContext","ssrContext","GlobalStateProvider","children","rest","state","useRef","current","stateProxy","initialState","GlobalState","isFunction","jsx","Provider","value","defaultProps","undefined"],"sources":["../../src/GlobalStateProvider.tsx"],"sourcesContent":["/* eslint-disable react/prop-types */\n\nimport { isFunction } from 'lodash';\n\nimport {\n  type ReactNode,\n  createContext,\n  useContext,\n  useRef,\n} from 'react';\n\nimport GlobalState from './GlobalState';\nimport 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  // Here Rules of Hooks are violated because \"getGlobalState()\" does not follow\n  // convention that hook names should start with use... This is intentional in\n  // our case, as getGlobalState() hook is intended for advance scenarious,\n  // while the normal interaction with the global state should happen via\n  // another hook, useGlobalState().\n  /* eslint-disable react-hooks/rules-of-hooks */\n  const globalState = useContext(context);\n  /* eslint-enable react-hooks/rules-of-hooks */\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 */\nexport default function GlobalStateProvider<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(\n  { children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>,\n) {\n  const state = useRef<GlobalState<StateT, SsrContextT>>();\n  if (!state.current) {\n    // NOTE: The last part of condition, \"&& rest.stateProxy\", is needed for\n    // graceful compatibility with JavaScript - if \"undefined\" stateProxy value\n    // is given, we want to follow the second branch, which creates a new\n    // GlobalState with whatever intiialState given.\n    if ('stateProxy' in rest && rest.stateProxy) {\n      if (rest.stateProxy === true) state.current = getGlobalState();\n      else state.current = rest.stateProxy;\n    } else {\n      const { initialState, ssrContext } = rest as NewStateProps<StateT, SsrContextT>;\n\n      state.current = new GlobalState<StateT, SsrContextT>(\n        isFunction(initialState) ? initialState() : initialState,\n        ssrContext,\n      );\n    }\n  }\n  return (\n    <context.Provider value={state.current}>\n      {children}\n    </context.Provider>\n  );\n}\n\nGlobalStateProvider.defaultProps = {\n  children: undefined,\n};\n"],"mappings":";;;;;;;;;AAEA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAOA,IAAAE,YAAA,GAAAC,sBAAA,CAAAH,OAAA;AAAwC,IAAAI,WAAA,GAAAJ,OAAA;AAXxC;;AAgBA,MAAMK,OAAO,gBAAG,IAAAC,oBAAa,EAA8B,IAAI,CAAC;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,cAAcA,CAAA,EAGQ;EACpC;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,WAAW,GAAG,IAAAC,iBAAU,EAACJ,OAAO,CAAC;EACvC;EACA,IAAI,CAACG,WAAW,EAAE,MAAM,IAAIE,KAAK,CAAC,6BAA6B,CAAC;EAChE,OAAOF,WAAW;AACpB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,aAAaA,CAG3BC,sBAAsB,GAAG,IAAI,EACJ;EACzB,MAAM;IAAEC;EAAW,CAAC,GAAGN,cAAc,CAAoC,CAAC;EAC1E,IAAI,CAACM,UAAU,IAAID,sBAAsB,EAAE;IACzC,MAAM,IAAIF,KAAK,CAAC,sBAAsB,CAAC;EACzC;EACA,OAAOG,UAAU;AACnB;AAgBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,mBAAmBA,CAIzC;EAAEC,QAAQ;EAAE,GAAGC;AAAoD,CAAC,EACpE;EACA,MAAMC,KAAK,GAAG,IAAAC,aAAM,EAAmC,CAAC;EACxD,IAAI,CAACD,KAAK,CAACE,OAAO,EAAE;IAClB;IACA;IACA;IACA;IACA,IAAI,YAAY,IAAIH,IAAI,IAAIA,IAAI,CAACI,UAAU,EAAE;MAC3C,IAAIJ,IAAI,CAACI,UAAU,KAAK,IAAI,EAAEH,KAAK,CAACE,OAAO,GAAGZ,cAAc,CAAC,CAAC,CAAC,KAC1DU,KAAK,CAACE,OAAO,GAAGH,IAAI,CAACI,UAAU;IACtC,CAAC,MAAM;MACL,MAAM;QAAEC,YAAY;QAAER;MAAW,CAAC,GAAGG,IAA0C;MAE/EC,KAAK,CAACE,OAAO,GAAG,IAAIG,oBAAW,CAC7B,IAAAC,kBAAU,EAACF,YAAY,CAAC,GAAGA,YAAY,CAAC,CAAC,GAAGA,YAAY,EACxDR,UACF,CAAC;IACH;EACF;EACA,oBACE,IAAAT,WAAA,CAAAoB,GAAA,EAACnB,OAAO,CAACoB,QAAQ;IAACC,KAAK,EAAET,KAAK,CAACE,OAAQ;IAAAJ,QAAA,EACpCA;EAAQ,CACO,CAAC;AAEvB;AAEAD,mBAAmB,CAACa,YAAY,GAAG;EACjCZ,QAAQ,EAAEa;AACZ,CAAC"}

package/build/common/SsrContext.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class SsrContext {
+  dirty = false;
+  pending = [];
+  constructor(state) {
+    this.state = state;
+  }
+}
+exports.default = SsrContext;
+//# sourceMappingURL=SsrContext.js.map

package/build/common/SsrContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SsrContext.js","names":["SsrContext","dirty","pending","constructor","state","exports","default"],"sources":["../../src/SsrContext.ts"],"sourcesContent":["export default class SsrContext<StateT> {\n  dirty: boolean = false;\n\n  pending: Promise<void>[] = [];\n\n  state?: StateT;\n\n  constructor(state?: StateT) {\n    this.state = state;\n  }\n}\n"],"mappings":";;;;;;AAAe,MAAMA,UAAU,CAAS;EACtCC,KAAK,GAAY,KAAK;EAEtBC,OAAO,GAAoB,EAAE;EAI7BC,WAAWA,CAACC,KAAc,EAAE;IAC1B,IAAI,CAACA,KAAK,GAAGA,KAAK;EACpB;AACF;AAACC,OAAA,CAAAC,OAAA,GAAAN,UAAA"}

package/build/common/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GlobalState", {
+  enumerable: true,
+  get: function () {
+    return _GlobalState.default;
+  }
+});
+Object.defineProperty(exports, "GlobalStateProvider", {
+  enumerable: true,
+  get: function () {
+    return _GlobalStateProvider.default;
+  }
+});
+Object.defineProperty(exports, "SsrContext", {
+  enumerable: true,
+  get: function () {
+    return _SsrContext.default;
+  }
+});
+Object.defineProperty(exports, "getGlobalState", {
+  enumerable: true,
+  get: function () {
+    return _GlobalStateProvider.getGlobalState;
+  }
+});
+Object.defineProperty(exports, "getSsrContext", {
+  enumerable: true,
+  get: function () {
+    return _GlobalStateProvider.getSsrContext;
+  }
+});
+Object.defineProperty(exports, "newAsyncDataEnvelope", {
+  enumerable: true,
+  get: function () {
+    return _useAsyncData.newAsyncDataEnvelope;
+  }
+});
+Object.defineProperty(exports, "useAsyncCollection", {
+  enumerable: true,
+  get: function () {
+    return _useAsyncCollection.default;
+  }
+});
+Object.defineProperty(exports, "useAsyncData", {
+  enumerable: true,
+  get: function () {
+    return _useAsyncData.default;
+  }
+});
+Object.defineProperty(exports, "useGlobalState", {
+  enumerable: true,
+  get: function () {
+    return _useGlobalState.default;
+  }
+});
+Object.defineProperty(exports, "withGlobalStateType", {
+  enumerable: true,
+  get: function () {
+    return _withGlobalStateType.default;
+  }
+});
+var _GlobalState = _interopRequireDefault(require("./GlobalState"));
+var _GlobalStateProvider = _interopRequireWildcard(require("./GlobalStateProvider"));
+var _SsrContext = _interopRequireDefault(require("./SsrContext"));
+var _useAsyncCollection = _interopRequireDefault(require("./useAsyncCollection"));
+var _useAsyncData = _interopRequireWildcard(require("./useAsyncData"));
+var _useGlobalState = _interopRequireDefault(require("./useGlobalState"));
+var _withGlobalStateType = _interopRequireDefault(require("./withGlobalStateType"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+//# sourceMappingURL=index.js.map

package/build/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_GlobalState","_interopRequireDefault","require","_GlobalStateProvider","_interopRequireWildcard","_SsrContext","_useAsyncCollection","_useAsyncData","_useGlobalState","_withGlobalStateType","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","prototype","hasOwnProperty","call","i","set"],"sources":["../../src/index.ts"],"sourcesContent":["export { default as GlobalState } from './GlobalState';\n\nexport {\n  default as GlobalStateProvider,\n  getGlobalState,\n  getSsrContext,\n} from './GlobalStateProvider';\n\nexport { default as SsrContext } from './SsrContext';\n\nexport {\n  type AsyncCollectionLoaderT,\n  default as useAsyncCollection,\n} from './useAsyncCollection';\n\nexport {\n  type AsyncDataEnvelopeT,\n  type AsyncDataLoaderT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n  default as useAsyncData,\n  newAsyncDataEnvelope,\n} from './useAsyncData';\n\nexport {\n  type SetterT,\n  type UseGlobalStateResT,\n  default as useGlobalState,\n} from './useGlobalState';\n\nexport { type ForceT, type ValueOrInitializerT } from './utils';\n\nexport { default as withGlobalStateType } from './withGlobalStateType';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,oBAAA,GAAAC,uBAAA,CAAAF,OAAA;AAMA,IAAAG,WAAA,GAAAJ,sBAAA,CAAAC,OAAA;AAEA,IAAAI,mBAAA,GAAAL,sBAAA,CAAAC,OAAA;AAKA,IAAAK,aAAA,GAAAH,uBAAA,CAAAF,OAAA;AASA,IAAAM,eAAA,GAAAP,sBAAA,CAAAC,OAAA;AAQA,IAAAO,oBAAA,GAAAR,sBAAA,CAAAC,OAAA;AAAuE,SAAAQ,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAP,wBAAAO,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,WAAAK,OAAA,EAAAL,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAI,GAAA,CAAAP,CAAA,OAAAQ,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAd,CAAA,oBAAAc,CAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAjB,CAAA,EAAAc,CAAA,SAAAI,CAAA,GAAAR,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAc,CAAA,UAAAI,CAAA,KAAAA,CAAA,CAAAX,GAAA,IAAAW,CAAA,CAAAC,GAAA,IAAAR,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAI,CAAA,IAAAV,CAAA,CAAAM,CAAA,IAAAd,CAAA,CAAAc,CAAA,YAAAN,CAAA,CAAAH,OAAA,GAAAL,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAgB,GAAA,CAAAnB,CAAA,EAAAQ,CAAA,GAAAA,CAAA"}

package/build/common/useAsyncCollection.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _useAsyncData = _interopRequireDefault(require("./useAsyncData"));
+/**
+ * Loads and uses an item in an async collection.
+ */
+
+/**
+ * Resolves and stores at the given `path` of global state elements of
+ * an asynchronous data collection. In other words, it is an auxiliar wrapper
+ * around {@link useAsyncData}, which uses a loader which resolves to different
+ * data, based on ID argument passed in, and stores data fetched for different
+ * IDs in the state.
+ * @param id ID of the collection item to load & use.
+ * @param path The global state path where entire collection should be
+ *  stored.
+ * @param loader A loader function, which takes an
+ * ID of data to load, and resolves to the corresponding data.
+ * @param options Additional options.
+ * @param options.deps An array of dependencies, which trigger
+ * data reload when changed. Given dependency changes are watched shallowly
+ * (similarly to the standard React's
+ * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).
+ * @param options.noSSR If `true`, this hook won't load data during
+ * server-side rendering.
+ * @param options.garbageCollectAge The maximum age of data
+ * (in milliseconds), after which they are dropped from the state when the last
+ * component referencing them via `useAsyncData()` hook unmounts. Defaults to
+ * `maxage` option value.
+ * @param options.maxage The maximum age of
+ * data (in milliseconds) acceptable to the hook's caller. If loaded data are
+ * older than this value, `null` is returned instead. Defaults to 5 minutes.
+ * @param options.refreshAge The maximum age of data
+ * (in milliseconds), after which their refreshment will be triggered when
+ * any component referencing them via `useAsyncData()` hook (re-)renders.
+ * Defaults to `maxage` value.
+ * @return Returns an object with three fields: `data` holds the actual result of
+ * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`
+ * is a boolean flag, which is `true` if data are being loaded (the hook is
+ * waiting for `loader` function resolution); `timestamp` (in milliseconds)
+ * is Unix timestamp of related data currently loaded into the global state.
+ *
+ * Note that loaded data, if any, are stored at the given `path` of global state
+ * along with related meta-information, using slightly different state segment
+ * structure (see {@link AsyncDataEnvelope}). That segment of the global state
+ * can be accessed, and even modified using other hooks,
+ * _e.g._ {@link useGlobalState}, but doing so you may interfere with related
+ * `useAsyncData()` hooks logic.
+ */
+
+function useAsyncCollection(id, path, loader, options = {}) {
+  const itemPath = path ? `${path}.${id}` : id;
+  return (0, _useAsyncData.default)(itemPath, oldData => loader(id, oldData), options);
+}
+var _default = exports.default = useAsyncCollection;
+//# sourceMappingURL=useAsyncCollection.js.map

package/build/common/useAsyncCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncCollection.js","names":["_useAsyncData","_interopRequireDefault","require","useAsyncCollection","id","path","loader","options","itemPath","useAsyncData","oldData","_default","exports","default"],"sources":["../../src/useAsyncCollection.ts"],"sourcesContent":["/**\n * Loads and uses an item in an async collection.\n */\n\nimport useAsyncData, {\n  type DataInEnvelopeAtPathT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n} from './useAsyncData';\n\nimport { type ForceT, type TypeLock } from './utils';\n\nexport type AsyncCollectionLoaderT<DataT> =\n  (id: string, oldData: null | DataT) => DataT | Promise<DataT>;\n\n/**\n * Resolves and stores at the given `path` of global state elements of\n * an asynchronous data collection. In other words, it is an auxiliar wrapper\n * around {@link useAsyncData}, which uses a loader which resolves to different\n * data, based on ID argument passed in, and stores data fetched for different\n * IDs in the state.\n * @param id ID of the collection item to load & use.\n * @param path The global state path where entire collection should be\n *  stored.\n * @param loader A loader function, which takes an\n * ID of data to load, and resolves to the corresponding data.\n * @param options Additional options.\n * @param options.deps An array of dependencies, which trigger\n * data reload when changed. Given dependency changes are watched shallowly\n * (similarly to the standard React's\n * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).\n * @param options.noSSR If `true`, this hook won't load data during\n * server-side rendering.\n * @param options.garbageCollectAge The maximum age of data\n * (in milliseconds), after which they are dropped from the state when the last\n * component referencing them via `useAsyncData()` hook unmounts. Defaults to\n * `maxage` option value.\n * @param options.maxage The maximum age of\n * data (in milliseconds) acceptable to the hook's caller. If loaded data are\n * older than this value, `null` is returned instead. Defaults to 5 minutes.\n * @param options.refreshAge The maximum age of data\n * (in milliseconds), after which their refreshment will be triggered when\n * any component referencing them via `useAsyncData()` hook (re-)renders.\n * Defaults to `maxage` value.\n * @return Returns an object with three fields: `data` holds the actual result of\n * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`\n * is a boolean flag, which is `true` if data are being loaded (the hook is\n * waiting for `loader` function resolution); `timestamp` (in milliseconds)\n * is Unix timestamp of related data currently loaded into the global state.\n *\n * Note that loaded data, if any, are stored at the given `path` of global state\n * along with related meta-information, using slightly different state segment\n * structure (see {@link AsyncDataEnvelope}). That segment of the global state\n * can be accessed, and even modified using other hooks,\n * _e.g._ {@link useGlobalState}, but doing so you may interfere with related\n * `useAsyncData()` hooks logic.\n */\n\nfunction useAsyncCollection<\n  StateT,\n  PathT extends null | string | undefined,\n  IdT extends string,\n>(\n  id: IdT,\n  path: PathT,\n  loader: AsyncCollectionLoaderT<\n  DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>\n  >,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;\n\nfunction useAsyncCollection<\n  Forced extends ForceT | false = false,\n  DataT = unknown,\n>(\n  id: string,\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncCollection<DataT>(\n  id: string,\n  path: null | string | undefined,\n  loader: AsyncCollectionLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const itemPath = path ? `${path}.${id}` : id;\n  return useAsyncData<ForceT, DataT>(\n    itemPath,\n    (oldData: null | DataT) => loader(id, oldData),\n    options,\n  );\n}\n\nexport default useAsyncCollection;\n"],"mappings":";;;;;;;AAIA,IAAAA,aAAA,GAAAC,sBAAA,CAAAC,OAAA;AAJA;AACA;AACA;;AAaA;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;;AAyBA,SAASC,kBAAkBA,CACzBC,EAAU,EACVC,IAA+B,EAC/BC,MAAqC,EACrCC,OAA6B,GAAG,CAAC,CAAC,EACT;EACzB,MAAMC,QAAQ,GAAGH,IAAI,GAAI,GAAEA,IAAK,IAAGD,EAAG,EAAC,GAAGA,EAAE;EAC5C,OAAO,IAAAK,qBAAY,EACjBD,QAAQ,EACPE,OAAqB,IAAKJ,MAAM,CAACF,EAAE,EAAEM,OAAO,CAAC,EAC9CH,OACF,CAAC;AACH;AAAC,IAAAI,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEcV,kBAAkB"}

package/build/common/useAsyncData.js

@@ -0,0 +1,204 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.newAsyncDataEnvelope = newAsyncDataEnvelope;
+var _lodash = require("lodash");
+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 = 5 * _jsUtils.MIN_MS; // 5 minutes.
+
+function newAsyncDataEnvelope(initialData = null) {
+  return {
+    data: initialData,
+    numRefs: 0,
+    operationId: '',
+    timestamp: 0
+  };
+}
+/**
+ * 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
+ */
+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 path Dot-delimitered state path, where data envelop is
+ * stored.
+ * @param loader Asynchronous function which resolves (loads)
+ * data, which should be stored at the global state `path`. When multiple
+ * components
+ * use `useAsyncData()` hook for the same `path`, the library assumes that all
+ * hook instances are called with the same `loader` (_i.e._ whichever of these
+ * loaders is used to resolve async data, the result is acceptable to be reused
+ * in all related components).
+ * @param options Additional options.
+ * @param options.deps An array of dependencies, which trigger
+ * data reload when changed. Given dependency changes are watched shallowly
+ * (similarly to the standard React's
+ * [useEffect()](https://reactjs.org/docs/hooks-reference.html#useeffect)).
+ * @param options.noSSR If `true`, this hook won't load data during
+ * server-side rendering.
+ * @param options.garbageCollectAge The maximum age of data
+ * (in milliseconds), after which they are dropped from the state when the last
+ * component referencing them via `useAsyncData()` hook unmounts. Defaults to
+ * `maxage` option value.
+ * @param options.maxage The maximum age of
+ * data (in milliseconds) acceptable to the hook's caller. If loaded data are
+ * older than this value, `null` is returned instead. Defaults to 5 minutes.
+ * @param options.refreshAge The maximum age of data
+ * (in milliseconds), after which their refreshment will be triggered when
+ * any component referencing them via `useAsyncData()` hook (re-)renders.
+ * Defaults to `maxage` value.
+ * @return Returns an object with three fields: `data` holds the actual result of
+ * last `loader` invokation, if any, and if satisfies `maxage` limit; `loading`
+ * is a boolean flag, which is `true` if data are being loaded (the hook is
+ * waiting for `loader` function resolution); `timestamp` (in milliseconds)
+ * is Unix timestamp of related data currently loaded into the global state.
+ *
+ * Note that loaded data, if any, are stored at the given `path` of global state
+ * along with related meta-information, using slightly different state segment
+ * structure (see {@link AsyncDataEnvelopeT}). That segment of the global state
+ * can be accessed, and even modified using other hooks,
+ * _e.g._ {@link useGlobalState}, but doing so you may interfere with related
+ * `useAsyncData()` hooks logic.
+ */
+
+function useAsyncData(path, loader, options = {}) {
+  const maxage = options.maxage === undefined ? DEFAULT_MAXAGE : options.maxage;
+  const refreshAge = options.refreshAge === undefined ? maxage : options.refreshAge;
+  const garbageCollectAge = options.garbageCollectAge === undefined ? maxage : options.garbageCollectAge;
+
+  // 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()
+  });
+  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(0) === '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, null);
+    }, deps); // eslint-disable-line react-hooks/exhaustive-deps
+  }
+
+  const [localState] = (0, _useGlobalState.default)(path, newAsyncDataEnvelope());
+  return {
+    data: maxage < Date.now() - localState.timestamp ? null : localState.data,
+    loading: Boolean(localState.operationId),
+    timestamp: localState.timestamp
+  };
+}
+var _default = exports.default = useAsyncData;
+//# sourceMappingURL=useAsyncData.js.map

package/build/common/useAsyncData.js.map

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

package/build/common/useGlobalState.js

@@ -0,0 +1,113 @@
+"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.
+ */
+
+function useGlobalState(path, initialValue) {
+  const globalState = (0, _GlobalStateProvider.getGlobalState)();
+  const ref = (0, _react.useRef)();
+  const rc = ref.current || {
+    emitter: new _jsUtils.Emitter(),
+    globalState,
+    path,
+    setter: value => {
+      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);
+    },
+    state: (0, _lodash.isFunction)(initialValue) ? initialValue() : initialValue,
+    watcher: () => {
+      const state = rc.globalState.get(rc.path);
+      if (state !== rc.state) rc.emitter.emit();
+    }
+  };
+  ref.current = rc;
+  rc.globalState = globalState;
+  rc.path = path;
+  rc.state = (0, _react.useSyncExternalStore)(cb => rc.emitter.addListener(cb), () => rc.globalState.get(rc.path, {
+    initialValue
+  }), () => rc.globalState.get(rc.path, {
+    initialValue,
+    initialState: true
+  }));
+  (0, _react.useEffect)(() => {
+    const {
+      watcher
+    } = ref.current;
+    globalState.watch(watcher);
+    watcher();
+    return () => globalState.unWatch(watcher);
+  }, [globalState]);
+  (0, _react.useEffect)(() => {
+    ref.current.watcher();
+  }, [path]);
+  return [rc.state, rc.setter];
+}
+var _default = exports.default = useGlobalState;
+//# sourceMappingURL=useGlobalState.js.map