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

package/build/common/useGlobalState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlobalState.js","names":["_lodash","require","_react","_jsUtils","_GlobalStateProvider","_utils","useGlobalState","path","initialValue","globalState","getGlobalState","ref","useRef","rc","current","emitter","Emitter","setter","value","newState","isFunction","state","process","env","NODE_ENV","isDebugMode","console","groupCollapsed","log","cloneDeep","groupEnd","set","watcher","get","emit","useSyncExternalStore","cb","addListener","initialState","useEffect","watch","unWatch","_default","exports","default"],"sources":["../../src/useGlobalState.ts"],"sourcesContent":["// Hook for updates of global state.\n\nimport { cloneDeep, isFunction } from 'lodash';\nimport { useEffect, useRef, useSyncExternalStore } from 'react';\n\nimport { Emitter } from '@dr.pogodin/js-utils';\n\nimport GlobalState from './GlobalState';\nimport { getGlobalState } from './GlobalStateProvider';\n\nimport {\n  type CallbackT,\n  type ForceT,\n  type TypeLock,\n  type ValueAtPathT,\n  type ValueOrInitializerT,\n  isDebugMode,\n} from './utils';\n\nexport type SetterT<T> = React.Dispatch<React.SetStateAction<T>>;\n\ntype GlobalStateRef = {\n  emitter: Emitter<[]>;\n  globalState: GlobalState<unknown>;\n  path: null | string | undefined;\n  setter: SetterT<unknown>;\n  state: unknown;\n  watcher: CallbackT;\n};\n\nexport type UseGlobalStateResT<T> = [T, SetterT<T>];\n\n/**\n * The primary hook for interacting with the global state, modeled after\n * the standard React's\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate).\n * It subscribes a component to a given `path` of global state, and provides\n * a function to update it. Each time the value at `path` changes, the hook\n * triggers re-render of its host component.\n *\n * **Note:**\n * - For performance, the library does not copy objects written to / read from\n *   global state paths. You MUST NOT manually mutate returned state values,\n *   or change objects already written into the global state, without explicitly\n *   clonning them first yourself.\n * - State update notifications are asynchronous. When your code does multiple\n *   global state updates in the same React rendering cycle, all state update\n *   notifications are queued and dispatched together, after the current\n *   rendering cycle. In other words, in any given rendering cycle the global\n *   state values are \"fixed\", and all changes becomes visible at once in the\n *   next triggered rendering pass.\n *\n * @param path Dot-delimitered state path. It can be undefined to\n * subscribe for entire state.\n *\n * Under-the-hood state values are read and written using `lodash`\n * [_.get()](https://lodash.com/docs/4.17.15#get) and\n * [_.set()](https://lodash.com/docs/4.17.15#set) methods, thus it is safe\n * to access state paths which have not been created before.\n * @param initialValue Initial value to set at the `path`, or its\n * factory:\n * - If a function is given, it will act similar to\n *   [the lazy initial state of the standard React's useState()](https://reactjs.org/docs/hooks-reference.html#lazy-initial-state):\n *   only if the value at `path` is `undefined`, the function will be executed,\n *   and the value it returns will be written to the `path`.\n * - Otherwise, the given value itself will be written to the `path`,\n *   if the current value at `path` is `undefined`.\n * @return It returs an array with two elements: `[value, setValue]`:\n *\n * - The `value` is the current value at given `path`.\n *\n * - The `setValue()` is setter function to write a new value to the `path`.\n *\n *   Similar to the standard React's `useState()`, it supports\n *   [functional value updates](https://reactjs.org/docs/hooks-reference.html#functional-updates):\n *   if `setValue()` is called with a function as argument, that function will\n *   be called and its return value will be written to `path`. Otherwise,\n *   the argument of `setValue()` itself is written to `path`.\n *\n *   Also, similar to the standard React's state setters, `setValue()` is\n *   stable function: it does not change between component re-renders.\n */\n\nfunction useGlobalState<StateT>(): UseGlobalStateResT<StateT>;\n\nfunction useGlobalState<Forced extends ForceT | false = false, ValueT = unknown>(\n  path: null | string | undefined,\n  initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\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  initialValue?: ValueOrInitializerT<unknown>,\n): UseGlobalStateResT<any> {\n  const globalState = getGlobalState();\n\n  const ref = useRef<GlobalStateRef>();\n  const rc: GlobalStateRef = ref.current || {\n    emitter: new Emitter(),\n    globalState,\n    path,\n    setter: (value) => {\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<ForceT, unknown>(rc.path, newState);\n    },\n    state: isFunction(initialValue) ? initialValue() : initialValue,\n    watcher: () => {\n      const state = rc.globalState.get(rc.path);\n      if (state !== rc.state) rc.emitter.emit();\n    },\n  };\n  ref.current = rc;\n\n  rc.globalState = globalState;\n  rc.path = path;\n\n  rc.state = useSyncExternalStore(\n    (cb) => rc.emitter.addListener(cb),\n    () => rc.globalState.get<ForceT, unknown>(rc.path, { initialValue }),\n    () => rc.globalState.get<ForceT, unknown>(rc.path, { initialValue, initialState: true }),\n  );\n\n  useEffect(() => {\n    const { watcher } = ref.current!;\n    globalState.watch(watcher);\n    watcher();\n    return () => globalState.unWatch(watcher);\n  }, [globalState]);\n\n  useEffect(() => {\n    ref.current!.watcher();\n  }, [path]);\n\n  return [rc.state, rc.setter];\n}\n\nexport default useGlobalState;\n"],"mappings":"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"}

package/build/common/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDebugMode = isDebugMode;
+// TODO: This (ForceT & TypeLock) probably should be moved to JS Utils lib.
+
+// This type is used to "unlocked" special generic overrides around the library.
+
+/**
+ * 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 (error) {
+    return false;
+  }
+}
+//# sourceMappingURL=utils.js.map

package/build/common/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["isDebugMode","process","env","NODE_ENV","REACT_GLOBAL_STATE_DEBUG","error"],"sources":["../../src/utils.ts"],"sourcesContent":["import { type GetFieldType } from 'lodash';\n\nexport type CallbackT = () => void;\n\n// TODO: This (ForceT & TypeLock) probably should be moved to JS Utils lib.\n\n// This type is used to \"unlocked\" special generic overrides around the library.\ndeclare const force: unique symbol;\nexport type ForceT = typeof force;\n\nexport type TypeLock<\n  Unlocked extends ForceT | false,\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  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 (error) {\n    return false;\n  }\n}\n"],"mappings":";;;;;;AAIA;;AAEA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,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,OAAOC,KAAK,EAAE;IACd,OAAO,KAAK;EACd;AACF"}

package/build/common/withGlobalStateType.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = withGlobalStateType;
+var _GlobalStateProvider = _interopRequireWildcard(require("./GlobalStateProvider"));
+var _useGlobalState = _interopRequireDefault(require("./useGlobalState"));
+var _useAsyncCollection = _interopRequireDefault(require("./useAsyncCollection"));
+var _useAsyncData = _interopRequireDefault(require("./useAsyncData"));
+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; }
+function withGlobalStateType() {
+  // These wrap useGlobalState() with locked-in StateT type.
+
+  function useGlobalStateWrap(path, initialValue) {
+    return (0, _useGlobalState.default)(path, initialValue);
+  }
+
+  // These overloads & implementation wrap useAsyncData() hook to lock-in its
+  // underlying StateT.
+  function useAsyncDataWrap(path, loader, options = {}) {
+    return (0, _useAsyncData.default)(path, loader, options);
+  }
+
+  // These overloads & implementation wrap useAsyncCollection() hook to lock-in
+  // its underlying StateT.
+  function useAsyncCollectionWrap(id, path, loader, options = {}) {
+    return (0, _useAsyncCollection.default)(id, path, loader, options);
+  }
+  return {
+    getGlobalState: _GlobalStateProvider.getGlobalState,
+    getSsrContext: _GlobalStateProvider.getSsrContext,
+    GlobalStateProvider: _GlobalStateProvider.default,
+    // SsrContext, /* CustomSsrContext || SsrContext, */
+    useAsyncCollection: useAsyncCollectionWrap,
+    useAsyncData: useAsyncDataWrap,
+    useGlobalState: useGlobalStateWrap
+  };
+}
+//# sourceMappingURL=withGlobalStateType.js.map

package/build/common/withGlobalStateType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withGlobalStateType.js","names":["_GlobalStateProvider","_interopRequireWildcard","require","_useGlobalState","_interopRequireDefault","_useAsyncCollection","_useAsyncData","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","prototype","hasOwnProperty","call","i","set","withGlobalStateType","useGlobalStateWrap","path","initialValue","useGlobalState","useAsyncDataWrap","loader","options","useAsyncData","useAsyncCollectionWrap","id","useAsyncCollection","getGlobalState","getSsrContext","GlobalStateProvider"],"sources":["../../src/withGlobalStateType.ts"],"sourcesContent":["import {\n  type ForceT,\n  type TypeLock,\n  type ValueAtPathT,\n  type ValueOrInitializerT,\n} from './utils';\n\nimport GlobalStateProvider, {\n  getGlobalState,\n  getSsrContext,\n} from './GlobalStateProvider';\n\nimport SsrContext from './SsrContext';\n\nimport useGlobalState, {\n  type UseGlobalStateResT,\n} from './useGlobalState';\n\nimport useAsyncCollection, {\n  type AsyncCollectionLoaderT,\n} from './useAsyncCollection';\n\nimport useAsyncData, {\n  type AsyncDataLoaderT,\n  type DataInEnvelopeAtPathT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n} from './useAsyncData';\n\ninterface NarrowedUseGlobalStateI<StateT> {\n  (): UseGlobalStateResT<StateT>;\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 | false = false, ValueT = unknown>(\n    path: null | string | undefined,\n    initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n  ): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n}\n\ninterface NarrowedUseAsyncDataI<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 | false = false, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, never, DataT>>;\n}\n\ninterface NarrowedUseAsyncCollectionI<StateT> {\n  <PathT extends null | string | undefined>(\n    id: string,\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | false = false, DataT = unknown>(\n    id: string,\n    path: null | string | undefined,\n    loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataT>;\n}\n\ntype WithGlobalStateTypeResT<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n> = {\n  getGlobalState: typeof getGlobalState<StateT, SsrContextT>,\n  getSsrContext: typeof getSsrContext<SsrContextT>,\n  GlobalStateProvider: typeof GlobalStateProvider<StateT, SsrContextT>,\n  // SsrContext: SsrContext<StateT>,\n  useAsyncCollection: NarrowedUseAsyncCollectionI<StateT>,\n  useAsyncData: NarrowedUseAsyncDataI<StateT>,\n  useGlobalState: NarrowedUseGlobalStateI<StateT>,\n};\n\nexport default function withGlobalStateType<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>(): WithGlobalStateTypeResT<StateT, SsrContextT> {\n  // These wrap useGlobalState() with locked-in StateT type.\n\n  function useGlobalStateWrap(): UseGlobalStateResT<StateT>;\n\n  function useGlobalStateWrap<PathT extends null | string | undefined>(\n    path: PathT,\n    initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>,\n  ): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;\n\n  function useGlobalStateWrap<Forced extends ForceT | false = false, ValueT = unknown>(\n    path: null | string | undefined,\n    initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n  ): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n\n  function useGlobalStateWrap(\n    path?: null | string,\n    initialValue?: ValueOrInitializerT<unknown>,\n  ): UseGlobalStateResT<any> {\n    return useGlobalState<ForceT, unknown>(path, initialValue);\n  }\n\n  // These overloads & implementation wrap useAsyncData() hook to lock-in its\n  // underlying StateT.\n\n  function useAsyncDataWrap<PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  function useAsyncDataWrap<Forced extends ForceT | false = false, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, never, DataT>>;\n\n  function useAsyncDataWrap<DataT>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<DataT>,\n    options: UseAsyncDataOptionsT = {},\n  ): UseAsyncDataResT<DataT> {\n    return useAsyncData<ForceT, DataT>(path, loader, options);\n  }\n\n  // These overloads & implementation wrap useAsyncCollection() hook to lock-in\n  // its underlying StateT.\n\n  function useAsyncCollectionWrap<PathT extends null | string | undefined>(\n    id: string,\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  function useAsyncCollectionWrap<Forced extends ForceT | false = false, DataT = unknown>(\n    id: string,\n    path: null | string | undefined,\n    loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataT>;\n\n  function useAsyncCollectionWrap<DataT>(\n    id: string,\n    path: null | string | undefined,\n    loader: AsyncCollectionLoaderT<DataT>,\n    options: UseAsyncDataOptionsT = {},\n  ): UseAsyncDataResT<DataT> {\n    return useAsyncCollection<ForceT, DataT>(id, path, loader, options);\n  }\n\n  return {\n    getGlobalState: getGlobalState<StateT, SsrContextT>,\n    getSsrContext: getSsrContext<SsrContextT>,\n    GlobalStateProvider: GlobalStateProvider<StateT, SsrContextT>,\n    // SsrContext, /* CustomSsrContext || SsrContext, */\n    useAsyncCollection: useAsyncCollectionWrap,\n    useAsyncData: useAsyncDataWrap,\n    useGlobalState: useGlobalStateWrap,\n  };\n}\n"],"mappings":";;;;;;;AAOA,IAAAA,oBAAA,GAAAC,uBAAA,CAAAC,OAAA;AAOA,IAAAC,eAAA,GAAAC,sBAAA,CAAAF,OAAA;AAIA,IAAAG,mBAAA,GAAAD,sBAAA,CAAAF,OAAA;AAIA,IAAAI,aAAA,GAAAF,sBAAA,CAAAF,OAAA;AAKwB,SAAAK,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;AA2DT,SAASY,mBAAmBA,CAAA,EAGO;EAChD;;EAcA,SAASC,kBAAkBA,CACzBC,IAAoB,EACpBC,YAA2C,EAClB;IACzB,OAAO,IAAAC,uBAAc,EAAkBF,IAAI,EAAEC,YAAY,CAAC;EAC5D;;EAEA;EACA;EAcA,SAASE,gBAAgBA,CACvBH,IAA+B,EAC/BI,MAA+B,EAC/BC,OAA6B,GAAG,CAAC,CAAC,EACT;IACzB,OAAO,IAAAC,qBAAY,EAAgBN,IAAI,EAAEI,MAAM,EAAEC,OAAO,CAAC;EAC3D;;EAEA;EACA;EAgBA,SAASE,sBAAsBA,CAC7BC,EAAU,EACVR,IAA+B,EAC/BI,MAAqC,EACrCC,OAA6B,GAAG,CAAC,CAAC,EACT;IACzB,OAAO,IAAAI,2BAAkB,EAAgBD,EAAE,EAAER,IAAI,EAAEI,MAAM,EAAEC,OAAO,CAAC;EACrE;EAEA,OAAO;IACLK,cAAc,EAAEA,mCAAmC;IACnDC,aAAa,EAAEA,kCAA0B;IACzCC,mBAAmB,EAAEA,4BAAwC;IAC7D;IACAH,kBAAkB,EAAEF,sBAAsB;IAC1CD,YAAY,EAAEH,gBAAgB;IAC9BD,cAAc,EAAEH;EAClB,CAAC;AACH"}

package/build/module/GlobalState.js

@@ -0,0 +1,230 @@
+import _classPrivateFieldGet from "@babel/runtime/helpers/classPrivateFieldGet";
+import _classPrivateFieldSet from "@babel/runtime/helpers/classPrivateFieldSet";
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+import { cloneDeep, get, isFunction, isObject, isNil, set, toPath } from 'lodash';
+import { isDebugMode } from "./utils";
+const ERR_NO_SSR_WATCH = 'GlobalState must not be watched at server side';
+var _initialState = /*#__PURE__*/new WeakMap();
+var _watchers = /*#__PURE__*/new WeakMap();
+var _nextNotifierId = /*#__PURE__*/new WeakMap();
+var _currentState = /*#__PURE__*/new WeakMap();
+export default class GlobalState {
+  /**
+   * Creates a new global state object.
+   * @param initialState Intial global state content.
+   * @param ssrContext Server-side rendering context.
+   */
+  constructor(initialState, ssrContext) {
+    _classPrivateFieldInitSpec(this, _initialState, {
+      writable: true,
+      value: void 0
+    });
+    // TODO: It is tempting to replace watchers here by
+    // Emitter from @dr.pogodin/js-utils, but we need to clone
+    // current watchers for emitting later, and this is not something
+    // Emitter supports right now.
+    _classPrivateFieldInitSpec(this, _watchers, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec(this, _nextNotifierId, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _currentState, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _currentState, initialState);
+    _classPrivateFieldSet(this, _initialState, initialState);
+    if (ssrContext) {
+      /* eslint-disable no-param-reassign */
+      ssrContext.dirty = false;
+      ssrContext.pending = [];
+      ssrContext.state = _classPrivateFieldGet(this, _currentState);
+      /* eslint-enable no-param-reassign */
+
+      this.ssrContext = ssrContext;
+    }
+    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
+      /* eslint-disable no-console */
+      let msg = 'New ReactGlobalState created';
+      if (ssrContext) msg += ' (SSR mode)';
+      console.groupCollapsed(msg);
+      console.log('Initial state:', cloneDeep(initialState));
+      console.groupEnd();
+      /* eslint-enable no-console */
+    }
+  }
+
+  /**
+   * Gets entire state, the same way as .get(null, opts) would do.
+   * @param opts.initialState
+   * @param opts.initialValue
+   */
+  getEntireState(opts) {
+    let state = opts !== null && opts !== void 0 && opts.initialState ? _classPrivateFieldGet(this, _initialState) : _classPrivateFieldGet(this, _currentState);
+    if (state !== undefined || (opts === null || opts === void 0 ? void 0 : opts.initialValue) === undefined) return state;
+    const iv = opts.initialValue;
+    state = isFunction(iv) ? iv() : iv;
+    if (_classPrivateFieldGet(this, _currentState) === undefined) this.setEntireState(state);
+    return state;
+  }
+
+  /**
+   * Notifies all connected state watchers that a state update has happened.
+   */
+  notifyStateUpdate(path, value) {
+    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
+      /* eslint-disable no-console */
+      const p = typeof path === 'string' ? `"${path}"` : 'none (entire state update)';
+      console.groupCollapsed(`ReactGlobalState update. Path: ${p}`);
+      console.log('New value:', cloneDeep(value));
+      console.log('New state:', cloneDeep(_classPrivateFieldGet(this, _currentState)));
+      console.groupEnd();
+      /* eslint-enable no-console */
+    }
+
+    if (this.ssrContext) {
+      this.ssrContext.dirty = true;
+      this.ssrContext.state = _classPrivateFieldGet(this, _currentState);
+    } else if (!_classPrivateFieldGet(this, _nextNotifierId)) {
+      _classPrivateFieldSet(this, _nextNotifierId, setTimeout(() => {
+        _classPrivateFieldSet(this, _nextNotifierId, undefined);
+        const watchers = [..._classPrivateFieldGet(this, _watchers)];
+        for (let i = 0; i < watchers.length; ++i) {
+          watchers[i]();
+        }
+      }));
+    }
+  }
+
+  /**
+   * Sets entire state, the same way as .set(null, value) would do.
+   * @param value
+   */
+  setEntireState(value) {
+    if (_classPrivateFieldGet(this, _currentState) !== value) {
+      _classPrivateFieldSet(this, _currentState, value);
+      this.notifyStateUpdate(null, value);
+    }
+    return value;
+  }
+
+  /**
+   * Gets current or initial value at the specified "path" of the global state.
+   * @param path Dot-delimitered state path.
+   * @param options Additional options.
+   * @param options.initialState If "true" the value will be read
+   *  from the initial state instead of the current one.
+   * @param options.initialValue If the value read from the "path" is
+   *  "undefined", this "initialValue" will be returned instead. In such case
+   *  "initialValue" will also be written to the "path" of the current global
+   *  state (no matter "initialState" flag), if "undefined" is stored there.
+   * @return Retrieved value.
+   */
+
+  // .get() without arguments just falls back to .getEntireState().
+  // This variant attempts to automatically resolve and check the type of value
+  // at the given path, as precise as the actual state and path types permit.
+  // If the automatic path resolution is not possible, the ValueT fallsback
+  // to `never` (or to `undefined` in some cases), effectively forbidding
+  // to use this .get() variant.
+  // This variant is not callable by default (without generic arguments),
+  // otherwise it allows to set the correct ValueT directly.
+  get(path, opts) {
+    if (isNil(path)) {
+      const res = this.getEntireState(opts);
+      return res;
+    }
+    const state = opts !== null && opts !== void 0 && opts.initialState ? _classPrivateFieldGet(this, _initialState) : _classPrivateFieldGet(this, _currentState);
+    let res = get(state, path);
+    if (res !== undefined || (opts === null || opts === void 0 ? void 0 : opts.initialValue) === undefined) return res;
+    const iv = opts.initialValue;
+    res = isFunction(iv) ? iv() : iv;
+    if (!(opts !== null && opts !== void 0 && opts.initialState) || this.get(path) === undefined) {
+      this.set(path, res);
+    }
+    return res;
+  }
+
+  /**
+   * Writes the `value` to given global state `path`.
+   * @param path Dot-delimitered state path. If not given, entire
+   * global state content is replaced by the `value`.
+   * @param value The value.
+   * @return Given `value` itself.
+   */
+
+  // This variant attempts automatic value type resolution & checking.
+  // This variant is disabled by default, otherwise allows to give
+  // expected value type explicitly.
+  set(path, value) {
+    if (isNil(path)) return this.setEntireState(value);
+    if (value !== this.get(path)) {
+      const root = {
+        state: _classPrivateFieldGet(this, _currentState)
+      };
+      let segIdx = 0;
+      let pos = root;
+      const pathSegments = toPath(`state.${path}`);
+      for (; segIdx < pathSegments.length - 1; segIdx += 1) {
+        const seg = pathSegments[segIdx];
+        const next = pos[seg];
+        if (Array.isArray(next)) pos[seg] = [...next];else if (isObject(next)) pos[seg] = {
+          ...next
+        };else {
+          // We arrived to a state sub-segment, where the remaining part of
+          // the update path does not exist yet. We rely on lodash's set()
+          // function to create the remaining path, and set the value.
+          set(pos, pathSegments.slice(segIdx), value);
+          break;
+        }
+        pos = pos[seg];
+      }
+      if (segIdx === pathSegments.length - 1) {
+        pos[pathSegments[segIdx]] = value;
+      }
+      _classPrivateFieldSet(this, _currentState, root.state);
+      this.notifyStateUpdate(path, value);
+    }
+    return value;
+  }
+
+  /**
+   * Unsubscribes `callback` from watching state updates; no operation if
+   * `callback` is not subscribed to the state updates.
+   * @param callback
+   * @throws if {@link SsrContext} is attached to the state instance: the state
+   * watching functionality is intended for client-side (non-SSR) only.
+   */
+  unWatch(callback) {
+    if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);
+    const watchers = _classPrivateFieldGet(this, _watchers);
+    const pos = watchers.indexOf(callback);
+    if (pos >= 0) {
+      watchers[pos] = watchers[watchers.length - 1];
+      watchers.pop();
+    }
+  }
+
+  /**
+   * Subscribes `callback` to watch state updates; no operation if
+   * `callback` is already subscribed to this state instance.
+   * @param callback It will be called without any arguments every
+   * time the state content changes (note, howhever, separate state updates can
+   * be applied to the state at once, and watching callbacks will be called once
+   * after such bulk update).
+   * @throws if {@link SsrContext} is attached to the state instance: the state
+   * watching functionality is intended for client-side (non-SSR) only.
+   */
+  watch(callback) {
+    if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);
+    const watchers = _classPrivateFieldGet(this, _watchers);
+    if (watchers.indexOf(callback) < 0) {
+      watchers.push(callback);
+    }
+  }
+}
+//# sourceMappingURL=GlobalState.js.map

package/build/module/GlobalState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalState.js","names":["cloneDeep","get","isFunction","isObject","isNil","set","toPath","isDebugMode","ERR_NO_SSR_WATCH","_initialState","WeakMap","_watchers","_nextNotifierId","_currentState","GlobalState","constructor","initialState","ssrContext","_classPrivateFieldInitSpec","writable","value","_classPrivateFieldSet","dirty","pending","state","_classPrivateFieldGet","process","env","NODE_ENV","msg","console","groupCollapsed","log","groupEnd","getEntireState","opts","undefined","initialValue","iv","setEntireState","notifyStateUpdate","path","p","setTimeout","watchers","i","length","res","root","segIdx","pos","pathSegments","seg","next","Array","isArray","slice","unWatch","callback","Error","indexOf","pop","watch","push"],"sources":["../../src/GlobalState.ts"],"sourcesContent":["import {\n  cloneDeep,\n  get,\n  isFunction,\n  isObject,\n  isNil,\n  set,\n  toPath,\n} from 'lodash';\n\nimport SsrContext from './SsrContext';\n\nimport {\n  type CallbackT,\n  type ForceT,\n  type TypeLock,\n  type ValueAtPathT,\n  type ValueOrInitializerT,\n  isDebugMode,\n} from './utils';\n\nconst ERR_NO_SSR_WATCH = 'GlobalState must not be watched at server side';\n\ntype GetOptsT<T> = {\n  initialState?: boolean;\n  initialValue?: ValueOrInitializerT<T>;\n};\n\nexport default class GlobalState<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n> {\n  readonly ssrContext?: SsrContextT;\n\n  #initialState: StateT;\n\n  // TODO: It is tempting to replace watchers here by\n  // Emitter from @dr.pogodin/js-utils, but we need to clone\n  // current watchers for emitting later, and this is not something\n  // Emitter supports right now.\n  #watchers: CallbackT[] = [];\n\n  #nextNotifierId?: NodeJS.Timeout;\n\n  #currentState: StateT;\n\n  /**\n   * Creates a new global state object.\n   * @param initialState Intial global state content.\n   * @param ssrContext Server-side rendering context.\n   */\n  constructor(\n    initialState: StateT,\n    ssrContext?: SsrContextT,\n  ) {\n    this.#currentState = initialState;\n    this.#initialState = initialState;\n\n    if (ssrContext) {\n      /* eslint-disable no-param-reassign */\n      ssrContext.dirty = false;\n      ssrContext.pending = [];\n      ssrContext.state = this.#currentState;\n      /* eslint-enable no-param-reassign */\n\n      this.ssrContext = ssrContext;\n    }\n\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      let msg = 'New ReactGlobalState created';\n      if (ssrContext) msg += ' (SSR mode)';\n      console.groupCollapsed(msg);\n      console.log('Initial state:', cloneDeep(initialState));\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n  }\n\n  /**\n   * Gets entire state, the same way as .get(null, opts) would do.\n   * @param opts.initialState\n   * @param opts.initialValue\n   */\n  getEntireState(opts?: GetOptsT<StateT>): StateT {\n    let state = opts?.initialState ? this.#initialState : this.#currentState;\n    if (state !== undefined || opts?.initialValue === undefined) return state;\n\n    const iv = opts.initialValue;\n    state = isFunction(iv) ? iv() : iv;\n    if (this.#currentState === undefined) this.setEntireState(state);\n    return state;\n  }\n\n  /**\n   * Notifies all connected state watchers that a state update has happened.\n   */\n  private notifyStateUpdate(path: null | string | undefined, value: unknown) {\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      const p = typeof path === 'string'\n        ? `\"${path}\"` : 'none (entire state update)';\n      console.groupCollapsed(`ReactGlobalState update. Path: ${p}`);\n      console.log('New value:', cloneDeep(value));\n      console.log('New state:', cloneDeep(this.#currentState));\n      console.groupEnd();\n      /* eslint-enable no-console */\n    }\n\n    if (this.ssrContext) {\n      this.ssrContext.dirty = true;\n      this.ssrContext.state = this.#currentState;\n    } else if (!this.#nextNotifierId) {\n      this.#nextNotifierId = setTimeout(() => {\n        this.#nextNotifierId = undefined;\n        const watchers = [...this.#watchers];\n        for (let i = 0; i < watchers.length; ++i) {\n          watchers[i]();\n        }\n      });\n    }\n  }\n\n  /**\n   * Sets entire state, the same way as .set(null, value) would do.\n   * @param value\n   */\n  setEntireState(value: StateT): StateT {\n    if (this.#currentState !== value) {\n      this.#currentState = value;\n      this.notifyStateUpdate(null, value);\n    }\n    return value;\n  }\n\n  /**\n   * Gets current or initial value at the specified \"path\" of the global state.\n   * @param path Dot-delimitered state path.\n   * @param options Additional options.\n   * @param options.initialState If \"true\" the value will be read\n   *  from the initial state instead of the current one.\n   * @param options.initialValue If the value read from the \"path\" is\n   *  \"undefined\", this \"initialValue\" will be returned instead. In such case\n   *  \"initialValue\" will also be written to the \"path\" of the current global\n   *  state (no matter \"initialState\" flag), if \"undefined\" is stored there.\n   * @return Retrieved value.\n   */\n\n  // .get() without arguments just falls back to .getEntireState().\n  get(): StateT;\n\n  // This variant attempts to automatically resolve and check the type of value\n  // at the given path, as precise as the actual state and path types permit.\n  // If the automatic path resolution is not possible, the ValueT fallsback\n  // to `never` (or to `undefined` in some cases), effectively forbidding\n  // to use this .get() variant.\n  get<\n    PathT extends null | string | undefined,\n    ValueArgT extends ValueAtPathT<StateT, PathT, never>,\n    ValueResT extends ValueAtPathT<StateT, PathT, void>,\n  >(path: PathT, opts?: GetOptsT<ValueArgT>): ValueResT;\n\n  // This variant is not callable by default (without generic arguments),\n  // otherwise it allows to set the correct ValueT directly.\n  get<Forced extends ForceT | false = false, ValueT = void>(\n    path?: null | string,\n    opts?: GetOptsT<TypeLock<Forced, never, ValueT>>,\n  ): TypeLock<Forced, void, ValueT>;\n\n  get<ValueT>(path?: null | string, opts?: GetOptsT<ValueT>): ValueT {\n    if (isNil(path)) {\n      const res = this.getEntireState((opts as unknown) as GetOptsT<StateT>);\n      return (res as unknown) as ValueT;\n    }\n\n    const state = opts?.initialState ? this.#initialState : this.#currentState;\n\n    let res = get(state, path);\n    if (res !== undefined || opts?.initialValue === undefined) return res;\n\n    const iv = opts.initialValue;\n    res = isFunction(iv) ? iv() : iv;\n\n    if (!opts?.initialState || this.get(path) === undefined) {\n      this.set<ForceT, unknown>(path, res);\n    }\n\n    return res;\n  }\n\n  /**\n   * Writes the `value` to given global state `path`.\n   * @param path Dot-delimitered state path. If not given, entire\n   * global state content is replaced by the `value`.\n   * @param value The value.\n   * @return Given `value` itself.\n   */\n\n  // This variant attempts automatic value type resolution & checking.\n  set<\n    PathT extends null | string | undefined,\n    ValueArgT extends ValueAtPathT<StateT, PathT, never>,\n    ValueResT extends ValueAtPathT<StateT, PathT, void>,\n  >(path: PathT, value: ValueArgT): ValueResT;\n\n  // This variant is disabled by default, otherwise allows to give\n  // expected value type explicitly.\n  set<Forced extends ForceT | false = false, ValueT = never>(\n    path: null | string | undefined,\n    value: TypeLock<Forced, never, ValueT>,\n  ): TypeLock<Forced, void, ValueT>;\n\n  set(path: null | string | undefined, value: unknown): unknown {\n    if (isNil(path)) return this.setEntireState(value as StateT);\n\n    if (value !== this.get(path)) {\n      const root = { state: this.#currentState };\n      let segIdx = 0;\n      let pos: any = root;\n      const pathSegments = toPath(`state.${path}`);\n      for (; segIdx < pathSegments.length - 1; segIdx += 1) {\n        const seg = pathSegments[segIdx];\n        const next = pos[seg];\n        if (Array.isArray(next)) pos[seg] = [...next];\n        else if (isObject(next)) pos[seg] = { ...next };\n        else {\n          // We arrived to a state sub-segment, where the remaining part of\n          // the update path does not exist yet. We rely on lodash's set()\n          // function to create the remaining path, and set the value.\n          set(pos, pathSegments.slice(segIdx), value);\n          break;\n        }\n        pos = pos[seg];\n      }\n\n      if (segIdx === pathSegments.length - 1) {\n        pos[pathSegments[segIdx]] = value;\n      }\n\n      this.#currentState = root.state;\n\n      this.notifyStateUpdate(path, value);\n    }\n    return value;\n  }\n\n  /**\n   * Unsubscribes `callback` from watching state updates; no operation if\n   * `callback` is not subscribed to the state updates.\n   * @param callback\n   * @throws if {@link SsrContext} is attached to the state instance: the state\n   * watching functionality is intended for client-side (non-SSR) only.\n   */\n  unWatch(callback: CallbackT) {\n    if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);\n\n    const watchers = this.#watchers;\n    const pos = watchers.indexOf(callback);\n    if (pos >= 0) {\n      watchers[pos] = watchers[watchers.length - 1];\n      watchers.pop();\n    }\n  }\n\n  /**\n   * Subscribes `callback` to watch state updates; no operation if\n   * `callback` is already subscribed to this state instance.\n   * @param callback It will be called without any arguments every\n   * time the state content changes (note, howhever, separate state updates can\n   * be applied to the state at once, and watching callbacks will be called once\n   * after such bulk update).\n   * @throws if {@link SsrContext} is attached to the state instance: the state\n   * watching functionality is intended for client-side (non-SSR) only.\n   */\n  watch(callback: CallbackT) {\n    if (this.ssrContext) throw new Error(ERR_NO_SSR_WATCH);\n\n    const watchers = this.#watchers;\n    if (watchers.indexOf(callback) < 0) {\n      watchers.push(callback);\n    }\n  }\n}\n"],"mappings":"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"}

package/build/module/GlobalStateProvider.js

@@ -0,0 +1,94 @@
+/* eslint-disable react/prop-types */
+
+import { isFunction } from 'lodash';
+import { createContext, useContext, useRef } from 'react';
+import GlobalState from "./GlobalState";
+import { jsx as _jsx } from "react/jsx-runtime";
+const context = /*#__PURE__*/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
+ */
+export function getGlobalState() {
+  // Here Rules of Hooks are violated because "getGlobalState()" does not follow
+  // convention that hook names should start with use... This is intentional in
+  // our case, as getGlobalState() hook is intended for advance scenarious,
+  // while the normal interaction with the global state should happen via
+  // another hook, useGlobalState().
+  /* eslint-disable react-hooks/rules-of-hooks */
+  const globalState = 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>}.
+ */
+export function getSsrContext() {
+  let throwWithoutSsrContext = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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.
+ */
+export default function GlobalStateProvider(_ref) {
+  let {
+    children,
+    ...rest
+  } = _ref;
+  const state = 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(isFunction(initialState) ? initialState() : initialState, ssrContext);
+    }
+  }
+  return /*#__PURE__*/_jsx(context.Provider, {
+    value: state.current,
+    children: children
+  });
+}
+GlobalStateProvider.defaultProps = {
+  children: undefined
+};
+//# sourceMappingURL=GlobalStateProvider.js.map

package/build/module/GlobalStateProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalStateProvider.js","names":["isFunction","createContext","useContext","useRef","GlobalState","jsx","_jsx","context","getGlobalState","globalState","Error","getSsrContext","throwWithoutSsrContext","arguments","length","undefined","ssrContext","GlobalStateProvider","_ref","children","rest","state","current","stateProxy","initialState","Provider","value","defaultProps"],"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":"AAAA;;AAEA,SAASA,UAAU,QAAQ,QAAQ;AAEnC,SAEEC,aAAa,EACbC,UAAU,EACVC,MAAM,QACD,OAAO;AAEd,OAAOC,WAAW;AAAsB,SAAAC,GAAA,IAAAC,IAAA;AAKxC,MAAMC,OAAO,gBAAGN,aAAa,CAA8B,IAAI,CAAC;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASO,cAAcA,CAAA,EAGQ;EACpC;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,WAAW,GAAGP,UAAU,CAACK,OAAO,CAAC;EACvC;EACA,IAAI,CAACE,WAAW,EAAE,MAAM,IAAIC,KAAK,CAAC,6BAA6B,CAAC;EAChE,OAAOD,WAAW;AACpB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,aAAaA,CAAA,EAIF;EAAA,IADzBC,sBAAsB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,IAAI;EAE7B,MAAM;IAAEG;EAAW,CAAC,GAAGR,cAAc,CAAoC,CAAC;EAC1E,IAAI,CAACQ,UAAU,IAAIJ,sBAAsB,EAAE;IACzC,MAAM,IAAIF,KAAK,CAAC,sBAAsB,CAAC;EACzC;EACA,OAAOM,UAAU;AACnB;AAgBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,mBAAmBA,CAAAC,IAAA,EAKzC;EAAA,IADA;IAAEC,QAAQ;IAAE,GAAGC;EAAoD,CAAC,GAAAF,IAAA;EAEpE,MAAMG,KAAK,GAAGlB,MAAM,CAAmC,CAAC;EACxD,IAAI,CAACkB,KAAK,CAACC,OAAO,EAAE;IAClB;IACA;IACA;IACA;IACA,IAAI,YAAY,IAAIF,IAAI,IAAIA,IAAI,CAACG,UAAU,EAAE;MAC3C,IAAIH,IAAI,CAACG,UAAU,KAAK,IAAI,EAAEF,KAAK,CAACC,OAAO,GAAGd,cAAc,CAAC,CAAC,CAAC,KAC1Da,KAAK,CAACC,OAAO,GAAGF,IAAI,CAACG,UAAU;IACtC,CAAC,MAAM;MACL,MAAM;QAAEC,YAAY;QAAER;MAAW,CAAC,GAAGI,IAA0C;MAE/EC,KAAK,CAACC,OAAO,GAAG,IAAIlB,WAAW,CAC7BJ,UAAU,CAACwB,YAAY,CAAC,GAAGA,YAAY,CAAC,CAAC,GAAGA,YAAY,EACxDR,UACF,CAAC;IACH;EACF;EACA,oBACEV,IAAA,CAACC,OAAO,CAACkB,QAAQ;IAACC,KAAK,EAAEL,KAAK,CAACC,OAAQ;IAAAH,QAAA,EACpCA;EAAQ,CACO,CAAC;AAEvB;AAEAF,mBAAmB,CAACU,YAAY,GAAG;EACjCR,QAAQ,EAAEJ;AACZ,CAAC"}

package/build/module/SsrContext.js

@@ -0,0 +1,9 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export default class SsrContext {
+  constructor(state) {
+    _defineProperty(this, "dirty", false);
+    _defineProperty(this, "pending", []);
+    this.state = state;
+  }
+}
+//# sourceMappingURL=SsrContext.js.map

package/build/module/SsrContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SsrContext.js","names":["SsrContext","constructor","state","_defineProperty"],"sources":["../../src/SsrContext.ts"],"sourcesContent":["export default class SsrContext<StateT> {\n  dirty: boolean = false;\n\n  pending: Promise<void>[] = [];\n\n  state?: StateT;\n\n  constructor(state?: StateT) {\n    this.state = state;\n  }\n}\n"],"mappings":";AAAA,eAAe,MAAMA,UAAU,CAAS;EAOtCC,WAAWA,CAACC,KAAc,EAAE;IAAAC,eAAA,gBANX,KAAK;IAAAA,eAAA,kBAEK,EAAE;IAK3B,IAAI,CAACD,KAAK,GAAGA,KAAK;EACpB;AACF"}

package/build/module/index.js

@@ -0,0 +1,8 @@
+export { default as GlobalState } from "./GlobalState";
+export { default as GlobalStateProvider, getGlobalState, getSsrContext } from "./GlobalStateProvider";
+export { default as SsrContext } from "./SsrContext";
+export { default as useAsyncCollection } from "./useAsyncCollection";
+export { default as useAsyncData, newAsyncDataEnvelope } from "./useAsyncData";
+export { default as useGlobalState } from "./useGlobalState";
+export { default as withGlobalStateType } from "./withGlobalStateType";
+//# sourceMappingURL=index.js.map

package/build/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["default","GlobalState","GlobalStateProvider","getGlobalState","getSsrContext","SsrContext","useAsyncCollection","useAsyncData","newAsyncDataEnvelope","useGlobalState","withGlobalStateType"],"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,SAASA,OAAO,IAAIC,WAAW;AAE/B,SACED,OAAO,IAAIE,mBAAmB,EAC9BC,cAAc,EACdC,aAAa;AAGf,SAASJ,OAAO,IAAIK,UAAU;AAE9B,SAEEL,OAAO,IAAIM,kBAAkB;AAG/B,SAKEN,OAAO,IAAIO,YAAY,EACvBC,oBAAoB;AAGtB,SAGER,OAAO,IAAIS,cAAc;AAK3B,SAAST,OAAO,IAAIU,mBAAmB"}

package/build/module/useAsyncCollection.js

@@ -0,0 +1,56 @@
+/**
+ * Loads and uses an item in an async collection.
+ */
+
+import useAsyncData from "./useAsyncData";
+
+/**
+ * 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) {
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const itemPath = path ? `${path}.${id}` : id;
+  return useAsyncData(itemPath, oldData => loader(id, oldData), options);
+}
+export default useAsyncCollection;
+//# sourceMappingURL=useAsyncCollection.js.map

package/build/module/useAsyncCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncCollection.js","names":["useAsyncData","useAsyncCollection","id","path","loader","options","arguments","length","undefined","itemPath","oldData"],"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":"AAAA;AACA;AACA;;AAEA,OAAOA,YAAY;;AAWnB;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,EAEZ;EAAA,IADzBC,OAA6B,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAElC,MAAMG,QAAQ,GAAGN,IAAI,GAAI,GAAEA,IAAK,IAAGD,EAAG,EAAC,GAAGA,EAAE;EAC5C,OAAOF,YAAY,CACjBS,QAAQ,EACPC,OAAqB,IAAKN,MAAM,CAACF,EAAE,EAAEQ,OAAO,CAAC,EAC9CL,OACF,CAAC;AACH;AAEA,eAAeJ,kBAAkB"}