@dr.pogodin/react-global-state 0.18.0 → 0.19.0

package/build/code/useAsyncData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncData.js","names":["useEffect","useRef","v4","uuid","MIN_MS","getGlobalState","useGlobalState","cloneDeepForLog","isDebugMode","DEFAULT_MAXAGE","newAsyncDataEnvelope","initialData","arguments","length","undefined","numRefs","timestamp","data","operationId","load","path","loader","globalState","old","process","env","NODE_ENV","console","log","operationIdPath","prevOperationId","get","asyncDataLoadDone","set","definedOld","e","dataOrPromise","isAborted","opid","oldDataTimestamp","setAbortCallback","cb","Error","setAsyncDataAbortCallback","Promise","state","groupCollapsed","Date","now","groupEnd","useAsyncData","_options$maxage","_options$refreshAge","_options$garbageColle","_heap$reload","options","maxage","refreshAge","garbageCollectAge","initialValue","current","heap","reload","customLoader","localLoader","ssrContext","disabled","noSSR","pending","push","numRefsPath","state2","dropDependencies","deps","hasChangedDependencies","startsWith","localState","loading","Boolean"],"sources":["../../src/useAsyncData.ts"],"sourcesContent":["/**\n * Loads and uses async data into the GlobalState path.\n */\n\nimport { useEffect, useRef } from 'react';\nimport { v4 as uuid } from 'uuid';\n\nimport { MIN_MS } from '@dr.pogodin/js-utils';\n\nimport { getGlobalState } from './GlobalStateProvider';\nimport useGlobalState from './useGlobalState';\n\nimport {\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  cloneDeepForLog,\n  isDebugMode,\n} from './utils';\n\nimport type GlobalState from './GlobalState';\nimport type SsrContext from './SsrContext';\n\nexport const DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.\n\nexport type AsyncDataLoaderT<DataT>\n= (oldData: null | DataT, meta: {\n  isAborted: () => boolean;\n  oldDataTimestamp: number;\n  setAbortCallback: (cb: () => void) => void;\n}) => DataT | Promise<DataT | null> | null;\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 type OperationIdT = `${'C' | 'S'}${string}`;\n\nexport function newAsyncDataEnvelope<DataT>(\n  initialData: DataT | null = null,\n  { numRefs = 0, timestamp = 0 } = {},\n): AsyncDataEnvelopeT<DataT> {\n  return {\n    data: initialData,\n    numRefs,\n    operationId: '',\n    timestamp,\n  };\n}\n\nexport type UseAsyncDataOptionsT = {\n  deps?: unknown[];\n  disabled?: boolean;\n  garbageCollectAge?: number;\n  maxage?: number;\n  noSSR?: boolean;\n  refreshAge?: number;\n};\n\nexport type UseAsyncDataResT<DataT> = {\n  data: DataT | null;\n  loading: boolean;\n  reload: AsyncDataReloaderT<DataT>;\n  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 */\nexport async function load<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  globalState: GlobalState<unknown, SsrContext<unknown>>,\n  old?: { data: DataT | null; timestamp: number },\n\n  // TODO: Should this parameter be just a binary flag (client or server),\n  // and UUID always generated inside this function? Or do we need it in\n  // the caller methods as well, in some cases (see useAsyncCollection()\n  // use case as well).\n  operationId: OperationIdT = `C${uuid()}`,\n): Promise<void> {\n  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n    /* eslint-disable no-console */\n    console.log(\n      `ReactGlobalState: async data (re-)loading. Path: \"${path ?? ''}\"`,\n    );\n    /* eslint-enable no-console */\n  }\n\n  const operationIdPath = path ? `${path}.operationId` : 'operationId';\n  {\n    const prevOperationId = globalState.get<ForceT, string>(operationIdPath);\n    if (prevOperationId) globalState.asyncDataLoadDone(prevOperationId, true);\n  }\n  globalState.set<ForceT, string>(operationIdPath, operationId);\n\n  let definedOld = old;\n  if (!definedOld) {\n    // TODO: Can we improve the typing, to avoid ForceT?\n    const e = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path);\n    definedOld = { data: e.data, timestamp: e.timestamp };\n  }\n\n  const dataOrPromise = loader(definedOld.data, {\n    isAborted: () => {\n      // TODO: Can we improve the typing, to avoid ForceT?\n      const opid = globalState.get<\n        ForceT, AsyncDataEnvelopeT<DataT>>(path).operationId;\n      return opid !== operationId;\n    },\n    oldDataTimestamp: definedOld.timestamp,\n    setAbortCallback(cb: () => void) {\n      const opid = globalState.get<\n        ForceT, AsyncDataEnvelopeT<DataT>>(path).operationId;\n      if (opid !== operationId) {\n        throw Error(`Operation #${operationId} has completed already`);\n      }\n      globalState.setAsyncDataAbortCallback(operationId, cb);\n    },\n  });\n\n  let data: DataT | null;\n\n  try {\n    data = dataOrPromise instanceof Promise\n      ? await dataOrPromise : dataOrPromise;\n  } finally {\n    // NOTE: We don't really mean that it hasn't been aborted,\n    // the \"false\" flag rather says we don't need to trigger \"on aborted\"\n    // callback for this operation, if any is registered - just drop it.\n    globalState.asyncDataLoadDone(operationId, false);\n  }\n\n  type EnvT = AsyncDataEnvelopeT<DataT> | undefined;\n  const state: EnvT = globalState.get<ForceT, EnvT>(path);\n\n  if (operationId === state?.operationId) {\n    if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n      /* eslint-disable no-console */\n      console.groupCollapsed(\n        `ReactGlobalState: async data (re-)loaded. Path: \"${\n          path ?? ''\n        }\"`,\n      );\n      console.log('Data:', cloneDeepForLog(data, path ?? ''));\n      /* eslint-enable no-console */\n    }\n    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.\n */\n\nexport type DataInEnvelopeAtPathT<\n  StateT,\n  PathT extends null | string | undefined,\n> = Exclude<Extract<ValueAtPathT<StateT, PathT, void>, AsyncDataEnvelopeT<unknown>>['data'], null>;\n\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<\n    StateT, PathT> = DataInEnvelopeAtPathT<StateT, PathT>,\n>(\n  path: PathT,\n  loader: AsyncDataLoaderT<DataT>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<DataT>;\n\nfunction useAsyncData<\n  Forced extends ForceT | LockT = LockT,\n  DataT = void,\n>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n  options?: UseAsyncDataOptionsT,\n): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n\nfunction useAsyncData<DataT>(\n  path: null | string | undefined,\n  loader: AsyncDataLoaderT<DataT>,\n  options: UseAsyncDataOptionsT = {},\n): UseAsyncDataResT<DataT> {\n  const maxage: number = options.maxage ?? DEFAULT_MAXAGE;\n  const refreshAge: number = options.refreshAge ?? maxage;\n  const garbageCollectAge: number = options.garbageCollectAge ?? maxage;\n\n  // Note: here we can't depend on useGlobalState() to init the initial value,\n  // because that way we'll have issues with SSR (see details below).\n  const globalState = getGlobalState();\n  const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n    initialValue: newAsyncDataEnvelope<DataT>(),\n  });\n\n  const { current: heap } = useRef<HeapT<DataT>>({});\n  heap.globalState = globalState;\n  heap.path = path;\n  heap.loader = loader;\n\n  heap.reload ??= async (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);\n  };\n\n  if (globalState.ssrContext) {\n    if (\n      !options.disabled && !options.noSSR\n      && !state.operationId && !state.timestamp\n    ) {\n      globalState.ssrContext.pending.push(\n        load(path, loader, globalState, {\n          data: state.data,\n          timestamp: state.timestamp,\n        }, `S${uuid()}`),\n      );\n    }\n  } else {\n    const { disabled } = options;\n\n    // This takes care about the client-side reference counting, and garbage\n    // collection.\n    //\n    // Note: the Rules of Hook below are violated by conditional call to a hook,\n    // but as the condition is actually server-side or client-side environment,\n    // it is effectively non-conditional at the runtime.\n    //\n    // TODO: Though, maybe there is a way to refactor it into a cleaner code.\n    // The same applies to other useEffect() hooks below.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      const numRefsPath = path ? `${path}.numRefs` : 'numRefs';\n      if (!disabled) {\n        const numRefs = globalState.get<ForceT, number>(numRefsPath);\n        globalState.set<ForceT, number>(numRefsPath, numRefs + 1);\n      }\n      return () => {\n        if (!disabled) {\n          const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n            ForceT, AsyncDataEnvelopeT<DataT>>(\n            path,\n          );\n          if (\n            state2.numRefs === 1\n            && garbageCollectAge < Date.now() - state2.timestamp\n          ) {\n            if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n              /* eslint-disable no-console */\n              console.log(\n                `ReactGlobalState - useAsyncData garbage collected at path ${\n                  path ?? ''\n                }`,\n              );\n              /* eslint-enable no-console */\n            }\n            globalState.dropDependencies(path ?? '');\n            globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {\n              ...state2,\n              data: null,\n              numRefs: 0,\n              timestamp: 0,\n            });\n          } else {\n            globalState.set<ForceT, number>(numRefsPath, state2.numRefs - 1);\n          }\n        }\n      };\n    }, [disabled, garbageCollectAge, globalState, path]);\n\n    // Note: a bunch of Rules of Hooks ignored belows because in our very\n    // special case the otherwise wrong behavior is actually what we need.\n\n    // Data loading and refreshing.\n    useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks\n      if (!disabled) {\n        const state2: AsyncDataEnvelopeT<DataT> = globalState.get<\n          ForceT, AsyncDataEnvelopeT<DataT>>(path);\n\n        const { deps } = options;\n        if (\n          // The hook is called with a list of dependencies, that mismatch\n          // dependencies last used to retrieve the data at given path.\n          (deps && globalState.hasChangedDependencies(path ?? '', deps))\n\n          // Data at the path are stale, and are not being loaded.\n          || (\n            refreshAge < Date.now() - state2.timestamp\n            && (!state2.operationId || state2.operationId.startsWith('S'))\n          )\n        ) {\n          if (!deps) globalState.dropDependencies(path ?? '');\n          void load(path, loader, globalState, {\n            data: state2.data,\n            timestamp: state2.timestamp,\n          });\n        }\n      }\n    });\n  }\n\n  const [localState] = useGlobalState<ForceT, AsyncDataEnvelopeT<DataT>>(\n    path,\n    newAsyncDataEnvelope<DataT>(),\n  );\n\n  return {\n    data: maxage < Date.now() - localState.timestamp ? null : localState.data,\n    loading: Boolean(localState.operationId),\n    reload: heap.reload,\n    timestamp: localState.timestamp,\n  };\n}\n\nexport { useAsyncData };\n\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport interface UseAsyncDataI<StateT> {\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;\n\n  <Forced extends ForceT | LockT = LockT, DataT = unknown>(\n    path: null | string | undefined,\n    loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,\n    options?: UseAsyncDataOptionsT,\n  ): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/{module → code}/useGlobalState.js

@@ -63,10 +63,20 @@ import { cloneDeepForLog, isDebugMode } from "./utils";
 
 // "State evaluation overload"
 
-function useGlobalState(path, initialValue) {
+function useGlobalState(path,
+// TODO: Revise it later!
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+initialValue
+
+// TODO: Revise it later!
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
   const globalState = getGlobalState();
   const ref = useRef(undefined);
-  let rc;
+
+  // TODO: Revise how this `rc` variable is used, perhaps we can simplify stuff
+  // here.
+  let rc = ref.current;
   if (!ref.current) {
     const emitter = new Emitter();
     ref.current = {
@@ -76,10 +86,10 @@ function useGlobalState(path, initialValue) {
       setter: value => {
         const newState = isFunction(value) ? value(rc.globalState.get(rc.path)) : value;
         if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
-          var _rc$path;
+          var _path, _path2;
           /* eslint-disable no-console */
-          console.groupCollapsed(`ReactGlobalState - useGlobalState setter triggered for path ${rc.path || ''}`);
-          console.log('New value:', cloneDeepForLog(newState, (_rc$path = rc.path) !== null && _rc$path !== void 0 ? _rc$path : ''));
+          console.groupCollapsed(`ReactGlobalState - useGlobalState setter triggered for path ${(_path = rc.path) !== null && _path !== void 0 ? _path : ''}`);
+          console.log('New value:', cloneDeepForLog(newState, (_path2 = rc.path) !== null && _path2 !== void 0 ? _path2 : ''));
           console.groupEnd();
           /* eslint-enable no-console */
         }
@@ -99,6 +109,8 @@ function useGlobalState(path, initialValue) {
       state: isFunction(initialValue) ? initialValue() : initialValue,
       subscribe: emitter.addListener.bind(emitter),
       watcher: () => {
+        // TODO: Revise it later.
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
         const state = rc.globalState.get(rc.path);
         if (state !== rc.state) rc.emitter.emit();
       }
@@ -110,8 +122,8 @@ function useGlobalState(path, initialValue) {
   rc.state = useSyncExternalStore(rc.subscribe, () => rc.globalState.get(rc.path, {
     initialValue
   }), () => rc.globalState.get(rc.path, {
-    initialValue,
-    initialState: true
+    initialState: true,
+    initialValue
   }));
   useEffect(() => {
     const {
@@ -119,7 +131,9 @@ function useGlobalState(path, initialValue) {
     } = ref.current;
     globalState.watch(watcher);
     watcher();
-    return () => globalState.unWatch(watcher);
+    return () => {
+      globalState.unWatch(watcher);
+    };
   }, [globalState]);
   useEffect(() => {
     ref.current.watcher();
@@ -127,4 +141,7 @@ function useGlobalState(path, initialValue) {
   return [rc.state, rc.setter];
 }
 export default useGlobalState;
+
+// TODO: Revise.
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 //# sourceMappingURL=useGlobalState.js.map

package/build/code/useGlobalState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlobalState.js","names":["isFunction","useEffect","useRef","useSyncExternalStore","Emitter","getGlobalState","cloneDeepForLog","isDebugMode","useGlobalState","path","initialValue","globalState","ref","undefined","rc","current","emitter","setter","value","newState","get","process","env","NODE_ENV","_path","_path2","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 { isFunction } from 'lodash';\n\nimport {\n  type Dispatch,\n  type SetStateAction,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\n\nimport { Emitter } from '@dr.pogodin/js-utils';\n\nimport type GlobalState from './GlobalState';\nimport { getGlobalState } from './GlobalStateProvider';\n\nimport {\n  type CallbackT,\n  type ForceT,\n  type LockT,\n  type TypeLock,\n  type ValueAtPathT,\n  type ValueOrInitializerT,\n  cloneDeepForLog,\n  isDebugMode,\n} from './utils';\n\nexport type SetterT<T> = Dispatch<SetStateAction<T>>;\n\ntype ListenerT = () => void;\n\ntype 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<\n    Exclude<ValueAtPathT<StateT, PathT, never>, undefined>>\n): UseGlobalStateResT<Exclude<ValueAtPathT<StateT, PathT, void>, undefined>>;\n\nfunction useGlobalState<\n  StateT,\n  PathT extends null | string | undefined,\n>(\n  path: PathT,\n  initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>\n): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;\n\nfunction useGlobalState(\n  path?: null | string,\n  // TODO: Revise it later!\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  initialValue?: ValueOrInitializerT<any>,\n\n  // TODO: Revise it later!\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): UseGlobalStateResT<any> {\n  const globalState = getGlobalState();\n\n  const ref = useRef<GlobalStateRef>(undefined);\n\n  // TODO: Revise how this `rc` variable is used, perhaps we can simplify stuff\n  // here.\n  let rc: GlobalStateRef | undefined = ref.current;\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)) as unknown\n          : value;\n\n        if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n          /* eslint-disable no-console */\n          console.groupCollapsed(\n            `ReactGlobalState - useGlobalState setter triggered for path ${\n              rc!.path ?? ''\n            }`,\n          );\n          console.log('New value:', cloneDeepForLog(newState, rc!.path ?? ''));\n          console.groupEnd();\n          /* eslint-enable no-console */\n        }\n        rc!.globalState.set<ForceT, unknown>(rc!.path, newState);\n\n        // NOTE: The regular global state's update notifications, automatically\n        // triggered by the rc.globalState.set() call above, are batched, and\n        // scheduled to fire asynchronosuly at a later time, which is problematic\n        // for managed text inputs - if they have their value update delayed to\n        // future render cycles, it will result in reset of their cursor position\n        // to the value end. Calling the rc.emitter.emit() below causes a sooner\n        // state update for the current component, thus working around the issue.\n        // For additional details see the original issue:\n        // https://github.com/birdofpreyru/react-global-state/issues/22\n        if (newState !== rc!.state) rc!.emitter.emit();\n      },\n      state: isFunction(initialValue) ? initialValue() : initialValue,\n      subscribe: emitter.addListener.bind(emitter),\n      watcher: () => {\n        // TODO: Revise it later.\n        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n        const state = rc!.globalState.get(rc!.path) as unknown;\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      { initialState: true, initialValue },\n    ),\n  );\n\n  useEffect(() => {\n    const { watcher } = ref.current!;\n    globalState.watch(watcher);\n    watcher();\n    return () => {\n      globalState.unWatch(watcher);\n    };\n  }, [globalState]);\n\n  useEffect(() => {\n    ref.current!.watcher();\n  }, [path]);\n\n  return [rc.state, rc.setter];\n}\n\nexport default useGlobalState;\n\n// TODO: Revise.\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport interface UseGlobalStateI<StateT> {\n  (): UseGlobalStateResT<StateT>;\n\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    initialValue: ValueOrInitializerT<\n      Exclude<ValueAtPathT<StateT, PathT, never>, undefined>>\n  ): UseGlobalStateResT<Exclude<ValueAtPathT<StateT, PathT, void>, undefined>>;\n\n  <PathT extends null | string | undefined>(\n    path: PathT,\n    initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>\n  ): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;\n\n  <Forced extends ForceT | LockT = LockT, ValueT = unknown>(\n    path: null | string | undefined,\n    initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,\n  ): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/{module → code}/utils.js

@@ -32,7 +32,7 @@ import { cloneDeep } from 'lodash';
 export function isDebugMode() {
   try {
     return process.env.NODE_ENV !== 'production' && !!process.env.REACT_GLOBAL_STATE_DEBUG;
-  } catch (error) {
+  } catch {
     return false;
   }
 }

package/build/code/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["cloneDeep","isDebugMode","process","env","NODE_ENV","REACT_GLOBAL_STATE_DEBUG","cloneDeepBailKeys","Set","cloneDeepForLog","value","key","arguments","length","undefined","has","console","warn","start","Date","now","res","time","add","escape","x","replace","toString","hash","items","map","join"],"sources":["../../src/utils.ts"],"sourcesContent":["import { type GetFieldType, cloneDeep } from 'lodash';\n\nexport type CallbackT = () => void;\n\n// TODO: This (ForceT, LockT, and TypeLock) probably should be moved to JS Utils\n// lib.\n\nexport declare const force: unique symbol;\nexport declare const lock: unique symbol;\n\nexport type ForceT = typeof force;\nexport type LockT = typeof lock;\n\nexport type TypeLock<\n  Unlocked extends ForceT | LockT,\n\n  // TODO: Revise later.\n  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\n  LockedT extends never | void,\n  UnlockedT,\n> = Unlocked extends ForceT ? UnlockedT : LockedT;\n\n/**\n * Given the type of state, `StateT`, and the type of state path, `PathT`,\n * it evaluates the type of value at that path of the state, if it can be\n * evaluated from the path type (it is possible when `PathT` is a string\n * literal type, and `StateT` elements along this path have appropriate\n * types); otherwise it falls back to the specified `UnknownT` type,\n * which should be set either `never` (for input arguments), or `void`\n * (for return types) - `never` and `void` in those places forbid assignments,\n * and are not auto-inferred to more permissible types.\n *\n * BEWARE: When StateT is any the construct resolves to any for any string\n * paths.\n */\nexport type ValueAtPathT<\n  StateT,\n  PathT extends null | string | undefined,\n\n  // TODO: Revise later.\n  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-invalid-void-type\n  UnknownT extends never | undefined | void,\n> = unknown extends StateT\n  ? UnknownT\n  : string extends PathT\n    ? UnknownT\n    : PathT extends null | undefined\n      ? StateT\n      : GetFieldType<StateT, PathT> extends undefined\n        ? UnknownT : GetFieldType<StateT, PathT>;\n\nexport type ValueOrInitializerT<ValueT> = ValueT | (() => ValueT);\n\n/**\n * Returns 'true' if debug logging should be performed; 'false' otherwise.\n *\n * BEWARE: The actual safeguards for the debug logging still should read\n *  if (process.env.NODE_ENV !== 'production' && isDebugMode()) {\n *    // Some debug logging\n *  }\n * to ensure that debug code is stripped out by Webpack in production mode.\n *\n * @returns\n * @ignore\n */\nexport function isDebugMode(): boolean {\n  try {\n    return process.env.NODE_ENV !== 'production'\n      && !!process.env.REACT_GLOBAL_STATE_DEBUG;\n  } catch {\n    return false;\n  }\n}\n\nconst cloneDeepBailKeys = new Set<string>();\n\n/**\n * Deep-clones given value for logging purposes, or returns the value itself\n * if the previous clone attempt, with the same key, took more than 300ms\n * (to avoid situations when large payload in the global state slows down\n * development versions of the app due to the logging overhead).\n */\nexport function cloneDeepForLog<T>(value: T, key: string = ''): T {\n  if (cloneDeepBailKeys.has(key)) {\n    // eslint-disable-next-line no-console\n    console.warn(`The logged value won't be clonned (key \"${key}\").`);\n    return value;\n  }\n\n  const start = Date.now();\n  const res = cloneDeep(value);\n  const time = Date.now() - start;\n  if (time > 300) {\n    // eslint-disable-next-line no-console\n    console.warn(`${time}ms spent to clone the logged value (key \"${key}\").`);\n    cloneDeepBailKeys.add(key);\n  }\n\n  return res;\n}\n\n/**\n * Converts given value to an escaped string. For now, we are good with the most\n * trivial escape logic:\n *  - '%' characters are replaced by '%0' code pair;\n *  - '/' characters are replaced by '%1' code pair.\n */\nexport function escape(x: number | string): string {\n  return typeof x === 'string'\n    ? x.replace(/%/g, '%0').replace(/\\//g, '%1')\n    : x.toString();\n}\n\n/**\n * Hashes given string array. For our current needs we are fine to go with\n * the most trivial implementation, which probably should not be called \"hash\"\n * in the strict sense: we just escape each given string to not include '/'\n * characters, and then we join all those strings using '/' as the separator.\n */\nexport function hash(items: Array<number | string>): string {\n  return items.map(escape).join('/');\n}\n"],"mappings":"AAAA,SAA4BA,SAAS,QAAQ,QAAQ;;AAIrD;AACA;;AAiBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAmBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,WAAWA,CAAA,EAAY;EACrC,IAAI;IACF,OAAOC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,IACvC,CAAC,CAACF,OAAO,CAACC,GAAG,CAACE,wBAAwB;EAC7C,CAAC,CAAC,MAAM;IACN,OAAO,KAAK;EACd;AACF;AAEA,MAAMC,iBAAiB,GAAG,IAAIC,GAAG,CAAS,CAAC;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,eAAeA,CAAIC,KAAQ,EAAuB;EAAA,IAArBC,GAAW,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,EAAE;EAC3D,IAAIL,iBAAiB,CAACQ,GAAG,CAACJ,GAAG,CAAC,EAAE;IAC9B;IACAK,OAAO,CAACC,IAAI,CAAC,2CAA2CN,GAAG,KAAK,CAAC;IACjE,OAAOD,KAAK;EACd;EAEA,MAAMQ,KAAK,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;EACxB,MAAMC,GAAG,GAAGpB,SAAS,CAACS,KAAK,CAAC;EAC5B,MAAMY,IAAI,GAAGH,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGF,KAAK;EAC/B,IAAII,IAAI,GAAG,GAAG,EAAE;IACd;IACAN,OAAO,CAACC,IAAI,CAAC,GAAGK,IAAI,4CAA4CX,GAAG,KAAK,CAAC;IACzEJ,iBAAiB,CAACgB,GAAG,CAACZ,GAAG,CAAC;EAC5B;EAEA,OAAOU,GAAG;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,MAAMA,CAACC,CAAkB,EAAU;EACjD,OAAO,OAAOA,CAAC,KAAK,QAAQ,GACxBA,CAAC,CAACC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAACA,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,GAC1CD,CAAC,CAACE,QAAQ,CAAC,CAAC;AAClB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,IAAIA,CAACC,KAA6B,EAAU;EAC1D,OAAOA,KAAK,CAACC,GAAG,CAACN,MAAM,CAAC,CAACO,IAAI,CAAC,GAAG,CAAC;AACpC","ignoreList":[]}

package/build/types/GlobalState.d.ts

@@ -1,4 +1,4 @@
-import SsrContext from './SsrContext';
+import type SsrContext from './SsrContext';
 import { type CallbackT, type ForceT, type LockT, type TypeLock, type ValueAtPathT, type ValueOrInitializerT } from './utils';
 type GetOptsT<T> = {
     initialState?: boolean;
@@ -39,7 +39,7 @@ export default class GlobalState<StateT, SsrContextT extends SsrContext<StateT>
      * are used. We should normalize given path here, I guess, or on a higher
      * level in the logic?
      */
-    hasChangedDependencies(path: string, deps: any[]): boolean;
+    hasChangedDependencies(path: string, deps: unknown[]): boolean;
     /**
      * Gets entire state, the same way as .get(null, opts) would do.
      * @param opts.initialState

package/build/types/GlobalStateProvider.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import GlobalState from './GlobalState';
-import SsrContext from './SsrContext';
-import { type ValueOrInitializerT } from './utils';
+import type SsrContext from './SsrContext';
+import type { ValueOrInitializerT } from './utils';
 /**
  * Gets {@link GlobalState} instance from the context. In most cases
  * you should use {@link useGlobalState}, and other hooks to interact with
@@ -46,5 +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 const GlobalStateProvider: <StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>>({ children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>) => import("react/jsx-runtime").JSX.Element;
+declare const GlobalStateProvider: <StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>>({ children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>) => ReactNode;
 export default GlobalStateProvider;

package/build/types/SsrContext.d.ts

@@ -1,6 +1,6 @@
 export default class SsrContext<StateT> {
+    state?: StateT | undefined;
     dirty: boolean;
-    pending: Promise<void>[];
-    state?: StateT;
-    constructor(state?: StateT);
+    pending: Array<Promise<void>>;
+    constructor(state?: StateT | undefined);
 }

package/build/types/useAsyncCollection.d.ts

@@ -3,9 +3,7 @@
  */
 import { type AsyncDataEnvelopeT, type DataInEnvelopeAtPathT, type UseAsyncDataOptionsT, type UseAsyncDataResT } from './useAsyncData';
 import { type ForceT, type LockT, type TypeLock } from './utils';
-export type AsyncCollectionT<DataT = unknown, IdT extends number | string = number | string> = {
-    [id in IdT]?: AsyncDataEnvelopeT<DataT>;
-};
+export type AsyncCollectionT<DataT = unknown, IdT extends number | string = number | string> = Record<IdT, AsyncDataEnvelopeT<DataT>>;
 export type AsyncCollectionLoaderT<DataT, IdT extends number | string = number | string> = (id: IdT, oldData: null | DataT, meta: {
     isAborted: () => boolean;
     oldDataTimestamp: number;
@@ -18,9 +16,7 @@ type CollectionItemT<DataT> = {
     timestamp: number;
 };
 export type UseAsyncCollectionResT<DataT, IdT extends number | string = number | string> = {
-    items: {
-        [id in IdT]: CollectionItemT<DataT>;
-    };
+    items: Record<IdT, CollectionItemT<DataT>>;
     loading: boolean;
     reload: AsyncCollectionReloaderT<DataT, IdT>;
     timestamp: number;
@@ -33,10 +29,12 @@ declare function useAsyncCollection<StateT, PathT extends null | string | undefi
 declare function useAsyncCollection<Forced extends ForceT | LockT = LockT, DataT = unknown, IdT extends number | string = number | string>(id: IdT, path: null | string | undefined, loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;
 declare function useAsyncCollection<StateT, PathT extends null | string | undefined, IdT extends number | string, DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> = DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>(id: IdT[], path: PathT, loader: AsyncCollectionLoaderT<DataT, IdT>, options?: UseAsyncDataOptionsT): UseAsyncCollectionResT<DataT, IdT>;
 declare function useAsyncCollection<Forced extends ForceT | LockT = LockT, DataT = unknown, IdT extends number | string = number | string>(id: IdT[], path: null | string | undefined, loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncCollectionResT<DataT, IdT>;
+declare function useAsyncCollection<StateT, PathT extends null | string | undefined, IdT extends number | string, DataT extends DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`> = DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>(id: IdT | IdT[], path: PathT, loader: AsyncCollectionLoaderT<DataT, IdT>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataT> | UseAsyncCollectionResT<DataT, IdT>;
 export default useAsyncCollection;
 export interface UseAsyncCollectionI<StateT> {
     <PathT extends null | string | undefined, IdT extends number | string>(id: IdT, path: PathT, loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;
     <Forced extends ForceT | LockT = LockT, DataT = unknown, IdT extends number | string = number | string>(id: IdT, path: null | string | undefined, loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;
     <PathT extends null | string | undefined, IdT extends number | string>(id: IdT[], path: PathT, loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncCollectionResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>;
     <Forced extends ForceT | LockT = LockT, DataT = unknown, IdT extends number | string = number | string>(id: IdT[], path: null | string | undefined, loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncCollectionResT<DataT, IdT>;
+    <PathT extends null | string | undefined, IdT extends number | string>(id: IdT | IdT[], path: PathT, loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>> | UseAsyncCollectionResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>, IdT>;
 }

package/build/types/useAsyncData.d.ts

@@ -2,8 +2,8 @@
  * Loads and uses async data into the GlobalState path.
  */
 import { type ForceT, type LockT, type TypeLock, type ValueAtPathT } from './utils';
-import GlobalState from './GlobalState';
-import SsrContext from './SsrContext';
+import type GlobalState from './GlobalState';
+import type SsrContext from './SsrContext';
 export declare const DEFAULT_MAXAGE: number;
 export type AsyncDataLoaderT<DataT> = (oldData: null | DataT, meta: {
     isAborted: () => boolean;

package/build/types/utils.d.ts

@@ -1,7 +1,7 @@
 import { type GetFieldType } from 'lodash';
 export type CallbackT = () => void;
-declare const force: unique symbol;
-declare const lock: unique symbol;
+export declare const force: unique symbol;
+export declare const lock: unique symbol;
 export type ForceT = typeof force;
 export type LockT = typeof lock;
 export type TypeLock<Unlocked extends ForceT | LockT, LockedT extends never | void, UnlockedT> = Unlocked extends ForceT ? UnlockedT : LockedT;
@@ -54,4 +54,3 @@ export declare function escape(x: number | string): string;
  * characters, and then we join all those strings using '/' as the separator.
  */
 export declare function hash(items: Array<number | string>): string;
-export {};

package/eslint.config.mjs

@@ -0,0 +1,19 @@
+/* eslint-disable import/no-extraneous-dependencies */
+
+import { defineConfig } from 'eslint/config';
+import eslintConfigs from '@dr.pogodin/eslint-configs';
+
+export default defineConfig([
+  { ignores: [
+    'build/',
+    'docs/build/',
+    'docs/.docusaurus/',
+  ] },
+  eslintConfigs.configs.javascript,
+  eslintConfigs.configs.typescript,
+  eslintConfigs.configs.react,
+  {
+    extends: [eslintConfigs.configs.jest],
+    files: ['__tests__/**'],
+  },
+]);

package/package.json

@@ -1,25 +1,20 @@
 {
   "name": "@dr.pogodin/react-global-state",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Hook-based global state for React",
-  "main": "./build/common/index.js",
-  "react-native": "src/index.ts",
-  "source": "src/index.ts",
+  "main": "./build/code/index.js",
   "types": "./build/types/index.d.ts",
   "exports": {
-    "module": "./build/module/index.js",
-    "node": "./build/common/index.js",
-    "default": "./build/common/index.js"
+    "default": "./build/code/index.js"
   },
   "scripts": {
-    "build": "rimraf build && npm run build:types && npm run build:common && npm run build:module",
-    "build:common": "rimraf build/common && babel src -x .ts,.tsx --out-dir build/common --source-maps",
-    "build:module": "rimraf build/module && babel src -x .ts,.tsx --out-dir build/module --source-maps --config-file ./babel.module.config.js",
+    "build": "rimraf build && npm run build:types && npm run build:code",
+    "build:code": "rimraf build/code && babel src -x .ts,.tsx --out-dir build/code --source-maps --config-file ./babel.module.config.js",
     "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": "tstyche",
-    "lint": "eslint --ext .js,.jsx,.ts,.tsx .",
+    "lint": "eslint",
     "test": "npm run lint && npm run typecheck && npm run jest",
     "typecheck": "tsc --project __tests__/tsconfig.json"
   },
@@ -43,50 +38,39 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@babel/runtime": "^7.26.0",
-    "@dr.pogodin/js-utils": "^0.0.13",
-    "@types/lodash": "^4.17.13",
+    "@babel/runtime": "^7.27.1",
+    "@dr.pogodin/js-utils": "^0.0.18",
+    "@types/lodash": "^4.17.16",
     "lodash": "^4.17.21",
-    "uuid": "^11.0.3"
+    "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.26.4",
-    "@babel/core": "^7.26.0",
-    "@babel/eslint-parser": "^7.25.9",
-    "@babel/eslint-plugin": "^7.25.9",
-    "@babel/node": "^7.26.0",
-    "@babel/plugin-transform-runtime": "^7.25.9",
-    "@babel/preset-env": "^7.26.0",
-    "@babel/preset-react": "^7.26.3",
-    "@babel/preset-typescript": "^7.26.0",
+    "@babel/cli": "^7.27.2",
+    "@babel/core": "^7.27.1",
+    "@babel/node": "^7.27.1",
+    "@babel/plugin-transform-runtime": "^7.27.1",
+    "@babel/preset-env": "^7.27.2",
+    "@babel/preset-react": "^7.27.1",
+    "@babel/preset-typescript": "^7.27.1",
+    "@dr.pogodin/eslint-configs": "^0.0.6",
     "@testing-library/dom": "^10.4.0",
-    "@testing-library/react": "^16.1.0",
+    "@testing-library/react": "^16.3.0",
     "@tsconfig/recommended": "^1.0.8",
     "@types/jest": "^29.5.14",
     "@types/pretty": "^2.0.3",
-    "@types/react": "^19.0.2",
-    "@types/react-dom": "^19.0.2",
+    "@types/react": "^19.1.3",
+    "@types/react-dom": "^19.1.3",
     "babel-jest": "^29.7.0",
     "babel-plugin-module-resolver": "^5.0.2",
-    "eslint": "^8.57.1",
-    "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.31.0",
-    "eslint-plugin-jest": "^28.10.0",
-    "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-react": "^7.37.3",
-    "eslint-plugin-react-hooks": "^4.6.2",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "mockdate": "^3.0.5",
     "rimraf": "^6.0.1",
-    "tstyche": "^3.2.0",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.2"
+    "tstyche": "^3.5.0",
+    "typescript": "^5.8.3"
   },
   "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
   }
 }