@dr.pogodin/react-global-state 0.14.0 → 0.14.2

package/build/module/GlobalStateProvider.js

@@ -88,7 +88,4 @@ export default function GlobalStateProvider(_ref) {
     children: children
   });
 }
-GlobalStateProvider.defaultProps = {
-  children: undefined
-};
 //# sourceMappingURL=GlobalStateProvider.js.map

package/build/module/GlobalStateProvider.js.map

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

package/build/module/index.js

@@ -2,9 +2,10 @@ import GlobalState from "./GlobalState";
 import GlobalStateProvider, { getGlobalState, getSsrContext } from "./GlobalStateProvider";
 import SsrContext from "./SsrContext";
 import useAsyncCollection from "./useAsyncCollection";
-import useAsyncData, { newAsyncDataEnvelope } from "./useAsyncData";
+import { newAsyncDataEnvelope, useAsyncData } from "./useAsyncData";
 import useGlobalState from "./useGlobalState";
-export { getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, newAsyncDataEnvelope, SsrContext, useAsyncCollection, useAsyncData, useGlobalState };
+export * from "./useAsyncData";
+export { getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, SsrContext, useAsyncCollection, useGlobalState };
 const api = {
   getGlobalState,
   getSsrContext,

package/build/module/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["GlobalState","GlobalStateProvider","getGlobalState","getSsrContext","SsrContext","useAsyncCollection","useAsyncData","newAsyncDataEnvelope","useGlobalState","api","withGlobalStateType"],"sources":["../../src/index.ts"],"sourcesContent":["import GlobalState from './GlobalState';\n\nimport GlobalStateProvider, {\n  getGlobalState,\n  getSsrContext,\n} from './GlobalStateProvider';\n\nimport SsrContext from './SsrContext';\n\nimport useAsyncCollection, {\n  type UseAsyncCollectionI,\n} from './useAsyncCollection';\n\nimport useAsyncData, {\n  type UseAsyncDataI,\n  newAsyncDataEnvelope,\n} from './useAsyncData';\n\nimport useGlobalState, { type UseGlobalStateI } from './useGlobalState';\n\nexport type { AsyncCollectionLoaderT } from './useAsyncCollection';\n\nexport type {\n  AsyncDataEnvelopeT,\n  AsyncDataLoaderT,\n  UseAsyncDataOptionsT,\n  UseAsyncDataResT,\n} from './useAsyncData';\n\nexport type { SetterT, UseGlobalStateResT } from './useGlobalState';\n\nexport type { ForceT, ValueOrInitializerT } from './utils';\n\nexport {\n  getGlobalState,\n  getSsrContext,\n  GlobalState,\n  GlobalStateProvider,\n  newAsyncDataEnvelope,\n  SsrContext,\n  useAsyncCollection,\n  useAsyncData,\n  useGlobalState,\n};\n\ninterface API<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n> {\n  getGlobalState: typeof getGlobalState<StateT, SsrContextT>;\n  getSsrContext: typeof getSsrContext<SsrContextT>,\n  GlobalState: typeof GlobalState<StateT, SsrContextT>,\n  GlobalStateProvider: typeof GlobalStateProvider<StateT, SsrContextT>,\n  newAsyncDataEnvelope: typeof newAsyncDataEnvelope,\n  SsrContext: typeof SsrContext<StateT>,\n  useAsyncCollection: UseAsyncCollectionI<StateT>,\n  useAsyncData: UseAsyncDataI<StateT>,\n  useGlobalState: UseGlobalStateI<StateT>,\n}\n\nconst api = {\n  getGlobalState,\n  getSsrContext,\n  GlobalState,\n  GlobalStateProvider,\n  newAsyncDataEnvelope,\n  SsrContext,\n  useAsyncCollection,\n  useAsyncData,\n  useGlobalState,\n};\n\nexport function withGlobalStateType<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>() {\n  return api as API<StateT, SsrContextT>;\n}\n"],"mappings":"AAAA,OAAOA,WAAW;AAElB,OAAOC,mBAAmB,IACxBC,cAAc,EACdC,aAAa;AAGf,OAAOC,UAAU;AAEjB,OAAOC,kBAAkB;AAIzB,OAAOC,YAAY,IAEjBC,oBAAoB;AAGtB,OAAOC,cAAc;AAerB,SACEN,cAAc,EACdC,aAAa,EACbH,WAAW,EACXC,mBAAmB,EACnBM,oBAAoB,EACpBH,UAAU,EACVC,kBAAkB,EAClBC,YAAY,EACZE,cAAc;AAkBhB,MAAMC,GAAG,GAAG;EACVP,cAAc;EACdC,aAAa;EACbH,WAAW;EACXC,mBAAmB;EACnBM,oBAAoB;EACpBH,UAAU;EACVC,kBAAkB;EAClBC,YAAY;EACZE;AACF,CAAC;AAED,OAAO,SAASE,mBAAmBA,CAAA,EAG/B;EACF,OAAOD,GAAG;AACZ","ignoreList":[]}
+{"version":3,"file":"index.js","names":["GlobalState","GlobalStateProvider","getGlobalState","getSsrContext","SsrContext","useAsyncCollection","newAsyncDataEnvelope","useAsyncData","useGlobalState","api","withGlobalStateType"],"sources":["../../src/index.ts"],"sourcesContent":["import GlobalState from './GlobalState';\n\nimport GlobalStateProvider, {\n  getGlobalState,\n  getSsrContext,\n} from './GlobalStateProvider';\n\nimport SsrContext from './SsrContext';\n\nimport useAsyncCollection, {\n  type UseAsyncCollectionI,\n} from './useAsyncCollection';\n\nimport {\n  type UseAsyncDataI,\n  newAsyncDataEnvelope,\n  useAsyncData,\n} from './useAsyncData';\n\nimport useGlobalState, { type UseGlobalStateI } from './useGlobalState';\n\nexport type { AsyncCollectionLoaderT } from './useAsyncCollection';\n\nexport * from './useAsyncData';\n\nexport type { SetterT, UseGlobalStateResT } from './useGlobalState';\n\nexport type { ForceT, ValueOrInitializerT } from './utils';\n\nexport {\n  getGlobalState,\n  getSsrContext,\n  GlobalState,\n  GlobalStateProvider,\n  SsrContext,\n  useAsyncCollection,\n  useGlobalState,\n};\n\ninterface API<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n> {\n  getGlobalState: typeof getGlobalState<StateT, SsrContextT>;\n  getSsrContext: typeof getSsrContext<SsrContextT>,\n  GlobalState: typeof GlobalState<StateT, SsrContextT>,\n  GlobalStateProvider: typeof GlobalStateProvider<StateT, SsrContextT>,\n  newAsyncDataEnvelope: typeof newAsyncDataEnvelope,\n  SsrContext: typeof SsrContext<StateT>,\n  useAsyncCollection: UseAsyncCollectionI<StateT>,\n  useAsyncData: UseAsyncDataI<StateT>,\n  useGlobalState: UseGlobalStateI<StateT>,\n}\n\nconst api = {\n  getGlobalState,\n  getSsrContext,\n  GlobalState,\n  GlobalStateProvider,\n  newAsyncDataEnvelope,\n  SsrContext,\n  useAsyncCollection,\n  useAsyncData,\n  useGlobalState,\n};\n\nexport function withGlobalStateType<\n  StateT,\n  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,\n>() {\n  return api as API<StateT, SsrContextT>;\n}\n"],"mappings":"AAAA,OAAOA,WAAW;AAElB,OAAOC,mBAAmB,IACxBC,cAAc,EACdC,aAAa;AAGf,OAAOC,UAAU;AAEjB,OAAOC,kBAAkB;AAIzB,SAEEC,oBAAoB,EACpBC,YAAY;AAGd,OAAOC,cAAc;AAIrB;AAMA,SACEN,cAAc,EACdC,aAAa,EACbH,WAAW,EACXC,mBAAmB,EACnBG,UAAU,EACVC,kBAAkB,EAClBG,cAAc;AAkBhB,MAAMC,GAAG,GAAG;EACVP,cAAc;EACdC,aAAa;EACbH,WAAW;EACXC,mBAAmB;EACnBK,oBAAoB;EACpBF,UAAU;EACVC,kBAAkB;EAClBE,YAAY;EACZC;AACF,CAAC;AAED,OAAO,SAASE,mBAAmBA,CAAA,EAG/B;EACF,OAAOD,GAAG;AACZ","ignoreList":[]}

package/build/module/useAsyncCollection.js

@@ -2,7 +2,7 @@
  * Loads and uses an item in an async collection.
  */
 
-import useAsyncData from "./useAsyncData";
+import { useAsyncData } from "./useAsyncData";
 
 /**
  * Resolves and stores at the given `path` of global state elements of

package/build/module/useAsyncCollection.js.map

@@ -1 +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 LockT, 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  DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> =\n  DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>,\n>(\n  id: IdT,\n  path: PathT,\n  loader: AsyncCollectionLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncCollection<\n  Forced extends ForceT | LockT = LockT,\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\nexport interface UseAsyncCollectionI<StateT> {\n  <PathT extends null | string | undefined, IdT extends string>(\n    id: IdT,\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\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}\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;;AA0BA,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","ignoreList":[]}
+{"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 {\n  type DataInEnvelopeAtPathT,\n  type UseAsyncDataOptionsT,\n  type UseAsyncDataResT,\n  useAsyncData,\n} from './useAsyncData';\n\nimport { type ForceT, type LockT, 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  DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> =\n  DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>,\n>(\n  id: IdT,\n  path: PathT,\n  loader: AsyncCollectionLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncCollection<\n  Forced extends ForceT | LockT = LockT,\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\nexport interface UseAsyncCollectionI<StateT> {\n  <PathT extends null | string | undefined, IdT extends string>(\n    id: IdT,\n    path: PathT,\n    loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\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}\n"],"mappings":"AAAA;AACA;AACA;;AAEA,SAIEA,YAAY;;AAQd;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;;AA0BA,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,GAAG,GAAGA,IAAI,IAAID,EAAE,EAAE,GAAGA,EAAE;EAC5C,OAAOF,YAAY,CACjBS,QAAQ,EACPC,OAAqB,IAAKN,MAAM,CAACF,EAAE,EAAEQ,OAAO,CAAC,EAC9CL,OACF,CAAC;AACH;AAEA,eAAeJ,kBAAkB","ignoreList":[]}

package/build/module/useAsyncData.js

@@ -3,7 +3,7 @@
  */
 
 import { cloneDeep } from 'lodash';
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
 import { v4 as uuid } from 'uuid';
 import { MIN_MS } from '@dr.pogodin/js-utils';
 import { getGlobalState } from "./GlobalStateProvider";
@@ -48,7 +48,8 @@ async function load(path, loader, globalState, oldData) {
   const operationId = opIdPrefix + uuid();
   const operationIdPath = path ? `${path}.operationId` : 'operationId';
   globalState.set(operationIdPath, operationId);
-  const data = await loader(oldData || globalState.get(path).data);
+  const dataOrLoader = loader(oldData || globalState.get(path).data);
+  const data = dataOrLoader instanceof Promise ? await dataOrLoader : dataOrLoader;
   const state = globalState.get(path);
   if (operationId === state.operationId) {
     if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
@@ -131,6 +132,19 @@ function useAsyncData(path, loader) {
   const state = globalState.get(path, {
     initialValue: newAsyncDataEnvelope()
   });
+  const {
+    current: heap
+  } = useRef({});
+  heap.globalState = globalState;
+  heap.path = path;
+  heap.loader = loader;
+  if (!heap.reload) {
+    heap.reload = customLoader => {
+      const localLoader = customLoader || heap.loader;
+      if (!localLoader || !heap.globalState) throw Error('Internal error');
+      return load(heap.path, localLoader, heap.globalState, null);
+    };
+  }
   if (globalState.ssrContext && !options.noSSR) {
     if (!state.timestamp && !state.operationId) {
       globalState.ssrContext.pending.push(load(path, loader, globalState, state.data, 'S'));
@@ -200,9 +214,9 @@ function useAsyncData(path, loader) {
   return {
     data: maxage < Date.now() - localState.timestamp ? null : localState.data,
     loading: Boolean(localState.operationId),
-    reload: customLoader => load(path, customLoader || loader, globalState, null),
+    reload: heap.reload,
     timestamp: localState.timestamp
   };
 }
-export default useAsyncData;
+export { useAsyncData };
 //# sourceMappingURL=useAsyncData.js.map

package/build/module/useAsyncData.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAsyncData.js","names":["cloneDeep","useEffect","v4","uuid","MIN_MS","getGlobalState","useGlobalState","isDebugMode","DEFAULT_MAXAGE","newAsyncDataEnvelope","initialData","arguments","length","undefined","numRefs","timestamp","data","operationId","load","path","loader","globalState","oldData","opIdPrefix","process","env","NODE_ENV","console","log","operationIdPath","set","get","state","groupCollapsed","Date","now","groupEnd","useAsyncData","options","maxage","refreshAge","garbageCollectAge","initialValue","ssrContext","noSSR","pending","push","numRefsPath","state2","dropDependencies","loadTriggered","charAt","deps","hasChangedDependencies","localState","loading","Boolean","reload","customLoader"],"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 LockT,\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  { numRefs = 0, timestamp = 0 } = {},\n): AsyncDataEnvelopeT<DataT> {\n  return {\n    data: initialData,\n    numRefs,\n    operationId: '',\n    timestamp,\n  };\n}\n\nexport type UseAsyncDataOptionsT = {\n  deps?: unknown[];\n  garbageCollectAge?: number;\n  maxage?: number;\n  noSSR?: boolean;\n  refreshAge?: number;\n};\n\nexport type UseAsyncDataResT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  reload: (loader?: AsyncDataLoaderT<DataT>) => Promise<void>;\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  DataT extends DataInEnvelopeAtPathT<StateT, PathT> =\n  DataInEnvelopeAtPathT<StateT, PathT>,\n>(\n  path: PathT,\n  loader: AsyncDataLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncData<\n  Forced extends ForceT | LockT = LockT,\n  DataT = void,\n>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncData<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const maxage: number = options.maxage === 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.dropDependencies(path || '');\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    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const { deps } = options;\n      if (deps && globalState.hasChangedDependencies(path || '', deps) && !loadTriggered) {\n        load(path, loader, globalState, null);\n      }\n\n    // Here we need to default to empty array, so that this hook is re-evaluated\n    // only when dependencies specified in options change, and it should not be\n    // re-evaluated at all if no `deps` option is used.\n    }, options.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\n    reload: (customLoader?: AsyncDataLoaderT<DataT>) => load(\n      path,\n      customLoader || loader,\n      globalState,\n      null,\n    ),\n\n    timestamp: localState.timestamp,\n  };\n}\n\nexport default useAsyncData;\n\nexport interface UseAsyncDataI<StateT> {\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"useAsyncData.js","names":["cloneDeep","useEffect","useRef","v4","uuid","MIN_MS","getGlobalState","useGlobalState","isDebugMode","DEFAULT_MAXAGE","newAsyncDataEnvelope","initialData","arguments","length","undefined","numRefs","timestamp","data","operationId","load","path","loader","globalState","oldData","opIdPrefix","process","env","NODE_ENV","console","log","operationIdPath","set","dataOrLoader","get","Promise","state","groupCollapsed","Date","now","groupEnd","useAsyncData","options","maxage","refreshAge","garbageCollectAge","initialValue","current","heap","reload","customLoader","localLoader","Error","ssrContext","noSSR","pending","push","numRefsPath","state2","dropDependencies","loadTriggered","charAt","deps","hasChangedDependencies","localState","loading","Boolean"],"sources":["../../src/useAsyncData.ts"],"sourcesContent":["/**\n * Loads and uses async data into the GlobalState path.\n */\n\nimport { cloneDeep } from 'lodash';\nimport { useEffect, useRef } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport { MIN_MS } from '@dr.pogodin/js-utils';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport useGlobalState from './useGlobalState';\n\nimport {\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  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 AsyncDataReloaderT<DataT>\n= (loader?: AsyncDataLoaderT<DataT>) => Promise<void>;\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  { numRefs = 0, timestamp = 0 } = {},\n): AsyncDataEnvelopeT<DataT> {\n  return {\n    data: initialData,\n    numRefs,\n    operationId: '',\n    timestamp,\n  };\n}\n\nexport type UseAsyncDataOptionsT = {\n  deps?: unknown[];\n  garbageCollectAge?: number;\n  maxage?: number;\n  noSSR?: boolean;\n  refreshAge?: number;\n};\n\nexport type UseAsyncDataResT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  reload: AsyncDataReloaderT<DataT>;\n  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\n  const dataOrLoader = loader(\n    oldData || (globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path)).data,\n  );\n\n  const data: DataT = dataOrLoader instanceof Promise\n    ? await dataOrLoader : dataOrLoader;\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\ntype HeapT<DataT> = {\n  // Note: these heap fields are necessary to make reload() a stable function.\n  globalState?: GlobalState<unknown>;\n  path?: null | string;\n  loader?: AsyncDataLoaderT<DataT>;\n  reload?: AsyncDataReloaderT<DataT>;\n};\n\nfunction useAsyncData<\n  StateT,\n  PathT extends null | string | undefined,\n\n  DataT extends DataInEnvelopeAtPathT<StateT, PathT> =\n  DataInEnvelopeAtPathT<StateT, PathT>,\n>(\n  path: PathT,\n  loader: AsyncDataLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncData<\n  Forced extends ForceT | LockT = LockT,\n  DataT = void,\n>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncData<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const maxage: number = options.maxage === 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  const { current: heap } = useRef<HeapT<DataT>>({});\n  heap.globalState = globalState;\n  heap.path = path;\n  heap.loader = loader;\n\n  if (!heap.reload) {\n    heap.reload = (customLoader?: AsyncDataLoaderT<DataT>) => {\n      const localLoader = customLoader || heap.loader;\n      if (!localLoader || !heap.globalState) throw Error('Internal error');\n      return load(heap.path, localLoader, heap.globalState, null);\n    };\n  }\n\n  if (globalState.ssrContext && !options.noSSR) {\n    if (!state.timestamp && !state.operationId) {\n      globalState.ssrContext.pending.push(\n        load(path, loader, globalState, state.data, 'S'),\n      );\n    }\n  } else {\n    // This takes care about the client-side reference counting, and garbage\n    // collection.\n    //\n    // Note: the Rules of Hook below are violated by conditional call to a hook,\n    // but as the condition is actually server-side or client-side environment,\n    // it is effectively non-conditional at the runtime.\n    //\n    // TODO: Though, maybe there is a way to refactor it into a cleaner code.\n    // The same applies to other useEffect() hooks below.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';\n      const numRefs = globalState.get<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.dropDependencies(path || '');\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    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const { deps } = options;\n      if (deps && globalState.hasChangedDependencies(path || '', deps) && !loadTriggered) {\n        load(path, loader, globalState, null);\n      }\n\n    // Here we need to default to empty array, so that this hook is re-evaluated\n    // only when dependencies specified in options change, and it should not be\n    // re-evaluated at all if no `deps` option is used.\n    }, options.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    reload: heap.reload,\n    timestamp: localState.timestamp,\n  };\n}\n\nexport { useAsyncData };\n\nexport interface UseAsyncDataI<StateT> {\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/module/useGlobalState.js.map

@@ -1 +1 @@
-{"version":3,"file":"useGlobalState.js","names":["cloneDeep","isFunction","useEffect","useRef","useSyncExternalStore","Emitter","getGlobalState","isDebugMode","useGlobalState","path","initialValue","globalState","ref","rc","current","emitter","setter","value","newState","get","process","env","NODE_ENV","console","groupCollapsed","log","groupEnd","set","state","emit","subscribe","addListener","bind","watcher","initialState","watch","unWatch"],"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 LockT,\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 ListenerT = () => void;\n\ntype GlobalStateRef = {\n  emitter: Emitter<[]>;\n  globalState: GlobalState<unknown>;\n  path: null | string | undefined;\n  setter: SetterT<unknown>;\n  subscribe: (listener: ListenerT) => () => void;\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\n// \"Enforced type overload\"\nfunction useGlobalState<\n  Forced extends ForceT | LockT = LockT,\n  ValueT = void,\n>(\n  path: null | string | undefined,\n  initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n\n// \"Entire state overload\"\nfunction useGlobalState<StateT>(): UseGlobalStateResT<StateT>;\n\n// \"State evaluation overload\"\nfunction useGlobalState<\n  StateT,\n  PathT extends null | string | undefined,\n>(\n  path: PathT,\n  initialValue?: ValueOrInitializerT<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\n  let rc: GlobalStateRef;\n  if (!ref.current) {\n    const emitter = new Emitter();\n    ref.current = {\n      emitter,\n      globalState,\n      path,\n      setter: (value) => {\n        const newState = isFunction(value)\n          ? value(rc!.globalState.get(rc!.path))\n          : value;\n\n        if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n          /* eslint-disable no-console */\n          console.groupCollapsed(\n            `ReactGlobalState - useGlobalState setter triggered for path ${\n              rc!.path || ''\n            }`,\n          );\n          console.log('New value:', cloneDeep(newState));\n          console.groupEnd();\n          /* eslint-enable no-console */\n        }\n        rc!.globalState.set<ForceT, unknown>(rc!.path, newState);\n\n        // NOTE: The regular global state's update notifications, automatically\n        // triggered by the rc.globalState.set() call above, are batched, and\n        // scheduled to fire asynchronosuly at a later time, which is problematic\n        // for managed text inputs - if they have their value update delayed to\n        // future render cycles, it will result in reset of their cursor position\n        // to the value end. Calling the rc.emitter.emit() below causes a sooner\n        // state update for the current component, thus working around the issue.\n        // For additional details see the original issue:\n        // https://github.com/birdofpreyru/react-global-state/issues/22\n        if (newState !== rc!.state) rc!.emitter.emit();\n      },\n      state: isFunction(initialValue) ? initialValue() : initialValue,\n      subscribe: emitter.addListener.bind(emitter),\n      watcher: () => {\n        const state = rc!.globalState.get(rc!.path);\n        if (state !== rc!.state) rc!.emitter.emit();\n      },\n    };\n  }\n  rc = ref.current!;\n\n  rc.globalState = globalState;\n  rc.path = path;\n\n  rc.state = useSyncExternalStore(\n    rc.subscribe,\n    () => rc!.globalState.get<ForceT, unknown>(rc!.path, { initialValue }),\n\n    () => rc!.globalState.get<ForceT, unknown>(\n      rc!.path,\n      { initialValue, initialState: true },\n    ),\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\nexport interface UseGlobalStateI<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 | LockT = LockT, ValueT = unknown>(\n    path: null | string | undefined,\n    initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n  ): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"useGlobalState.js","names":["cloneDeep","isFunction","useEffect","useRef","useSyncExternalStore","Emitter","getGlobalState","isDebugMode","useGlobalState","path","initialValue","globalState","ref","rc","current","emitter","setter","value","newState","get","process","env","NODE_ENV","console","groupCollapsed","log","groupEnd","set","state","emit","subscribe","addListener","bind","watcher","initialState","watch","unWatch"],"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 LockT,\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 ListenerT = () => void;\n\ntype GlobalStateRef = {\n  emitter: Emitter<[]>;\n  globalState: GlobalState<unknown>;\n  path: null | string | undefined;\n  setter: SetterT<unknown>;\n  subscribe: (listener: ListenerT) => () => void;\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\n// \"Enforced type overload\"\nfunction useGlobalState<\n  Forced extends ForceT | LockT = LockT,\n  ValueT = void,\n>(\n  path: null | string | undefined,\n  initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n\n// \"Entire state overload\"\nfunction useGlobalState<StateT>(): UseGlobalStateResT<StateT>;\n\n// \"State evaluation overload\"\nfunction useGlobalState<\n  StateT,\n  PathT extends null | string | undefined,\n>(\n  path: PathT,\n  initialValue?: ValueOrInitializerT<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\n  let rc: GlobalStateRef;\n  if (!ref.current) {\n    const emitter = new Emitter();\n    ref.current = {\n      emitter,\n      globalState,\n      path,\n      setter: (value) => {\n        const newState = isFunction(value)\n          ? value(rc!.globalState.get(rc!.path))\n          : value;\n\n        if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n          /* eslint-disable no-console */\n          console.groupCollapsed(\n            `ReactGlobalState - useGlobalState setter triggered for path ${\n              rc!.path || ''\n            }`,\n          );\n          console.log('New value:', cloneDeep(newState));\n          console.groupEnd();\n          /* eslint-enable no-console */\n        }\n        rc!.globalState.set<ForceT, unknown>(rc!.path, newState);\n\n        // NOTE: The regular global state's update notifications, automatically\n        // triggered by the rc.globalState.set() call above, are batched, and\n        // scheduled to fire asynchronosuly at a later time, which is problematic\n        // for managed text inputs - if they have their value update delayed to\n        // future render cycles, it will result in reset of their cursor position\n        // to the value end. Calling the rc.emitter.emit() below causes a sooner\n        // state update for the current component, thus working around the issue.\n        // For additional details see the original issue:\n        // https://github.com/birdofpreyru/react-global-state/issues/22\n        if (newState !== rc!.state) rc!.emitter.emit();\n      },\n      state: isFunction(initialValue) ? initialValue() : initialValue,\n      subscribe: emitter.addListener.bind(emitter),\n      watcher: () => {\n        const state = rc!.globalState.get(rc!.path);\n        if (state !== rc!.state) rc!.emitter.emit();\n      },\n    };\n  }\n  rc = ref.current!;\n\n  rc.globalState = globalState;\n  rc.path = path;\n\n  rc.state = useSyncExternalStore(\n    rc.subscribe,\n    () => rc!.globalState.get<ForceT, unknown>(rc!.path, { initialValue }),\n\n    () => rc!.globalState.get<ForceT, unknown>(\n      rc!.path,\n      { initialValue, initialState: true },\n    ),\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\nexport interface UseGlobalStateI<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 | LockT = LockT, ValueT = unknown>(\n    path: null | string | undefined,\n    initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n  ): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/types/GlobalStateProvider.d.ts

@@ -46,10 +46,5 @@ type GlobalStateProviderProps<StateT, SsrContextT extends SsrContext<StateT>> =
  * - If `GlobalState` instance, it will be used by this provider.
  * - If not given, a new `GlobalState` instance will be created and used.
  */
-declare function GlobalStateProvider<StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>>({ children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>): import("react/jsx-runtime").JSX.Element;
-declare namespace GlobalStateProvider {
-    var defaultProps: {
-        children: undefined;
-    };
-}
-export default GlobalStateProvider;
+export default function GlobalStateProvider<StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>>({ children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/types/index.d.ts

@@ -2,13 +2,13 @@ import GlobalState from './GlobalState';
 import GlobalStateProvider, { getGlobalState, getSsrContext } from './GlobalStateProvider';
 import SsrContext from './SsrContext';
 import useAsyncCollection, { type UseAsyncCollectionI } from './useAsyncCollection';
-import useAsyncData, { type UseAsyncDataI, newAsyncDataEnvelope } from './useAsyncData';
+import { type UseAsyncDataI, newAsyncDataEnvelope } from './useAsyncData';
 import useGlobalState, { type UseGlobalStateI } from './useGlobalState';
 export type { AsyncCollectionLoaderT } from './useAsyncCollection';
-export type { AsyncDataEnvelopeT, AsyncDataLoaderT, UseAsyncDataOptionsT, UseAsyncDataResT, } from './useAsyncData';
+export * from './useAsyncData';
 export type { SetterT, UseGlobalStateResT } from './useGlobalState';
 export type { ForceT, ValueOrInitializerT } from './utils';
-export { getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, newAsyncDataEnvelope, SsrContext, useAsyncCollection, useAsyncData, useGlobalState, };
+export { getGlobalState, getSsrContext, GlobalState, GlobalStateProvider, SsrContext, useAsyncCollection, useGlobalState, };
 interface API<StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>> {
     getGlobalState: typeof getGlobalState<StateT, SsrContextT>;
     getSsrContext: typeof getSsrContext<SsrContextT>;

package/build/types/useAsyncData.d.ts

@@ -3,6 +3,7 @@
  */
 import { type ForceT, type LockT, type TypeLock, type ValueAtPathT } from './utils';
 export type AsyncDataLoaderT<DataT> = (oldData: null | DataT) => DataT | Promise<DataT>;
+export type AsyncDataReloaderT<DataT> = (loader?: AsyncDataLoaderT<DataT>) => Promise<void>;
 export type AsyncDataEnvelopeT<DataT> = {
     data: null | DataT;
     numRefs: number;
@@ -23,7 +24,7 @@ export type UseAsyncDataOptionsT = {
 export type UseAsyncDataResT<DataT> = {
     data: DataT | null;
     loading: boolean;
-    reload: (loader?: AsyncDataLoaderT<DataT>) => Promise<void>;
+    reload: AsyncDataReloaderT<DataT>;
     timestamp: number;
 };
 /**
@@ -76,7 +77,7 @@ export type UseAsyncDataResT<DataT> = {
 export type DataInEnvelopeAtPathT<StateT, PathT extends null | string | undefined> = ValueAtPathT<StateT, PathT, never> extends AsyncDataEnvelopeT<unknown> ? Exclude<ValueAtPathT<StateT, PathT, never>['data'], null> : void;
 declare function useAsyncData<StateT, PathT extends null | string | undefined, DataT extends DataInEnvelopeAtPathT<StateT, PathT> = DataInEnvelopeAtPathT<StateT, PathT>>(path: PathT, loader: AsyncDataLoaderT<DataT>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataT>;
 declare function useAsyncData<Forced extends ForceT | LockT = LockT, DataT = void>(path: null | string | undefined, loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;
-export default useAsyncData;
+export { useAsyncData };
 export interface UseAsyncDataI<StateT> {
     <PathT extends null | string | undefined>(path: PathT, loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;
     <Forced extends ForceT | LockT = LockT, DataT = unknown>(path: null | string | undefined, loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dr.pogodin/react-global-state",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "Hook-based global state for React",
   "main": "./build/common/index.js",
   "react-native": "src/index.ts",
@@ -18,7 +18,7 @@
     "build:types": "rimraf build/types && tsc --project tsconfig.types.json",
     "jest": "npm run jest:types && npm run jest:logic",
     "jest:logic": "jest --config jest/config.json -w 1",
-    "jest:types": "jest --config jest/config-types.json",
+    "jest:types": "tstyche",
     "lint": "eslint --ext .js,.jsx,.ts,.tsx .",
     "test": "npm run lint && npm run typecheck && npm run jest",
     "typecheck": "tsc --project __tests__/tsconfig.json"
@@ -43,52 +43,50 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@babel/runtime": "^7.24.1",
-    "@dr.pogodin/js-utils": "^0.0.9",
-    "@types/lodash": "^4.17.0",
+    "@babel/runtime": "^7.24.6",
+    "@dr.pogodin/js-utils": "^0.0.12",
+    "@types/lodash": "^4.17.4",
     "lodash": "^4.17.21",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@babel/cli": "^7.24.1",
-    "@babel/core": "^7.24.3",
-    "@babel/eslint-parser": "^7.24.1",
-    "@babel/eslint-plugin": "^7.23.5",
-    "@babel/node": "^7.23.9",
-    "@babel/plugin-transform-runtime": "^7.24.3",
-    "@babel/preset-env": "^7.24.3",
-    "@babel/preset-react": "^7.24.1",
-    "@babel/preset-typescript": "^7.24.1",
-    "@tsconfig/recommended": "^1.0.5",
-    "@tsd/typescript": "^5.4.3",
+    "@babel/cli": "^7.24.6",
+    "@babel/core": "^7.24.6",
+    "@babel/eslint-parser": "^7.24.6",
+    "@babel/eslint-plugin": "^7.24.6",
+    "@babel/node": "^7.24.6",
+    "@babel/plugin-transform-runtime": "^7.24.6",
+    "@babel/preset-env": "^7.24.6",
+    "@babel/preset-react": "^7.24.6",
+    "@babel/preset-typescript": "^7.24.6",
+    "@tsconfig/recommended": "^1.0.6",
     "@types/jest": "^29.5.12",
     "@types/pretty": "^2.0.3",
-    "@types/react": "^18.2.73",
-    "@types/react-dom": "^18.2.23",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
     "@types/uuid": "^9.0.8",
-    "typescript-eslint": "^7.4.0",
     "babel-jest": "^29.7.0",
-    "babel-plugin-module-resolver": "^5.0.0",
+    "babel-plugin-module-resolver": "^5.0.2",
     "eslint": "^8.57.0",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-airbnb-typescript": "^18.0.0",
     "eslint-import-resolver-babel-module": "^5.3.2",
     "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jest": "^27.9.0",
+    "eslint-plugin-jest": "^28.5.0",
     "eslint-plugin-jsx-a11y": "^6.8.0",
-    "eslint-plugin-react": "^7.34.1",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react": "^7.34.2",
+    "eslint-plugin-react-hooks": "^4.6.2",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
-    "jest-runner-tsd": "^6.0.0",
     "mockdate": "^3.0.5",
     "pretty": "^2.0.0",
-    "rimraf": "^5.0.1",
-    "tsd-lite": "^0.9.0",
-    "typescript": "^5.4.3"
+    "rimraf": "^5.0.7",
+    "tstyche": "^1.1.0",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.11.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   }
 }

package/src/GlobalStateProvider.tsx

@@ -121,7 +121,3 @@ export default function GlobalStateProvider<
     </context.Provider>
   );
 }
-
-GlobalStateProvider.defaultProps = {
-  children: undefined,
-};

package/src/index.ts

@@ -11,21 +11,17 @@ import useAsyncCollection, {
   type UseAsyncCollectionI,
 } from './useAsyncCollection';
 
-import useAsyncData, {
+import {
   type UseAsyncDataI,
   newAsyncDataEnvelope,
+  useAsyncData,
 } from './useAsyncData';
 
 import useGlobalState, { type UseGlobalStateI } from './useGlobalState';
 
 export type { AsyncCollectionLoaderT } from './useAsyncCollection';
 
-export type {
-  AsyncDataEnvelopeT,
-  AsyncDataLoaderT,
-  UseAsyncDataOptionsT,
-  UseAsyncDataResT,
-} from './useAsyncData';
+export * from './useAsyncData';
 
 export type { SetterT, UseGlobalStateResT } from './useGlobalState';
 
@@ -36,10 +32,8 @@ export {
   getSsrContext,
   GlobalState,
   GlobalStateProvider,
-  newAsyncDataEnvelope,
   SsrContext,
   useAsyncCollection,
-  useAsyncData,
   useGlobalState,
 };
 

package/src/useAsyncCollection.ts

@@ -2,10 +2,11 @@
  * Loads and uses an item in an async collection.
  */
 
-import useAsyncData, {
+import {
   type DataInEnvelopeAtPathT,
   type UseAsyncDataOptionsT,
   type UseAsyncDataResT,
+  useAsyncData,
 } from './useAsyncData';
 
 import { type ForceT, type LockT, type TypeLock } from './utils';