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

package/build/types/withGlobalStateType.d.ts

@@ -0,0 +1,29 @@
+import { type ForceT, type TypeLock, type ValueAtPathT, type ValueOrInitializerT } from './utils';
+import GlobalStateProvider, { getGlobalState, getSsrContext } from './GlobalStateProvider';
+import SsrContext from './SsrContext';
+import { type UseGlobalStateResT } from './useGlobalState';
+import { type AsyncCollectionLoaderT } from './useAsyncCollection';
+import { type AsyncDataLoaderT, type DataInEnvelopeAtPathT, type UseAsyncDataOptionsT, type UseAsyncDataResT } from './useAsyncData';
+interface NarrowedUseGlobalStateI<StateT> {
+    (): UseGlobalStateResT<StateT>;
+    <PathT extends null | string | undefined>(path: PathT, initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;
+    <Forced extends ForceT | false = false, ValueT = unknown>(path: null | string | undefined, initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;
+}
+interface NarrowedUseAsyncDataI<StateT> {
+    <PathT extends null | string | undefined>(path: PathT, loader: AsyncDataLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;
+    <Forced extends ForceT | false = false, DataT = unknown>(path: null | string | undefined, loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<TypeLock<Forced, never, DataT>>;
+}
+interface NarrowedUseAsyncCollectionI<StateT> {
+    <PathT extends null | string | undefined>(id: string, path: PathT, loader: AsyncCollectionLoaderT<DataInEnvelopeAtPathT<StateT, PathT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;
+    <Forced extends ForceT | false = false, DataT = unknown>(id: string, path: null | string | undefined, loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>, options?: UseAsyncDataOptionsT): UseAsyncDataResT<DataT>;
+}
+type WithGlobalStateTypeResT<StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>> = {
+    getGlobalState: typeof getGlobalState<StateT, SsrContextT>;
+    getSsrContext: typeof getSsrContext<SsrContextT>;
+    GlobalStateProvider: typeof GlobalStateProvider<StateT, SsrContextT>;
+    useAsyncCollection: NarrowedUseAsyncCollectionI<StateT>;
+    useAsyncData: NarrowedUseAsyncDataI<StateT>;
+    useGlobalState: NarrowedUseGlobalStateI<StateT>;
+};
+export default function withGlobalStateType<StateT, SsrContextT extends SsrContext<StateT> = SsrContext<StateT>>(): WithGlobalStateTypeResT<StateT, SsrContextT>;
+export {};

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "@dr.pogodin/react-global-state",
-  "version": "0.10.0-alpha.2",
+  "version": "0.10.0-alpha.3",
   "description": "Hook-based global state for React",
-  "main": "./build/index.js",
+  "main": "./build/common/index.js",
   "react-native": "src/index.ts",
   "source": "src/index.ts",
+  "types": "./build/types/index.d.ts",
   "exports": {
-    "types": "./index.d.ts",
-    "default": "./build/index.js"
+    "module": "./build/module/index.js",
+    "node": "./build/common/index.js",
+    "default": "./build/common/index.js"
   },
   "scripts": {
-    "build": "rimraf build && tsc",
+    "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:types": "rimraf build/types && tsc --project tsconfig.types.json",
     "jest": "npm run jest:types && npm run jest:logic",
-    "jest:types": "jest --config jest/config-types.json",
     "jest:logic": "jest --config jest/config.json -w 1",
+    "jest:types": "jest --config jest/config-types.json",
     "lint": "eslint --ext .js,.jsx,.ts,.tsx .",
     "test": "npm run lint && npm run typecheck && npm run jest",
-    "typecheck": "tsc --noEmit && tsc --project __tests__/tsconfig.typecheck.json"
+    "typecheck": "tsc --project __tests__/tsconfig.json"
   },
   "repository": "github:birdofpreyru/react-global-state",
   "keywords": [
@@ -35,53 +40,53 @@
   },
   "homepage": "https://dr.pogodin.studio/docs/react-global-state/index.html",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "dependencies": {
-    "@babel/runtime": "^7.22.6",
+    "@babel/runtime": "^7.23.2",
     "@dr.pogodin/js-utils": "^0.0.6",
     "lodash": "^4.17.21",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@babel/cli": "^7.22.6",
-    "@babel/core": "^7.22.8",
-    "@babel/eslint-parser": "^7.22.7",
-    "@babel/eslint-plugin": "^7.22.5",
-    "@babel/node": "^7.22.6",
-    "@babel/plugin-transform-runtime": "^7.22.7",
-    "@babel/preset-env": "^7.22.7",
-    "@babel/preset-react": "^7.22.5",
-    "@babel/preset-typescript": "^7.22.5",
-    "@tsconfig/recommended": "^1.0.2",
-    "@tsd/typescript": "^5.1.6",
-    "@types/jest": "^29.5.3",
-    "@types/lodash": "^4.14.195",
-    "@types/pretty": "^2.0.1",
-    "@types/react": "^18.2.14",
-    "@types/react-dom": "^18.2.6",
-    "@types/uuid": "^9.0.2",
-    "@typescript-eslint/eslint-plugin": "^5.61.0",
-    "@typescript-eslint/parser": "^5.61.0",
-    "babel-jest": "^29.6.1",
+    "@babel/cli": "^7.23.0",
+    "@babel/core": "^7.23.2",
+    "@babel/eslint-parser": "^7.22.15",
+    "@babel/eslint-plugin": "^7.22.10",
+    "@babel/node": "^7.22.19",
+    "@babel/plugin-transform-runtime": "^7.23.2",
+    "@babel/preset-env": "^7.23.2",
+    "@babel/preset-react": "^7.22.15",
+    "@babel/preset-typescript": "^7.23.2",
+    "@tsconfig/recommended": "^1.0.3",
+    "@tsd/typescript": "^5.2.2",
+    "@types/jest": "^29.5.6",
+    "@types/lodash": "^4.14.200",
+    "@types/pretty": "^2.0.2",
+    "@types/react": "^18.2.31",
+    "@types/react-dom": "^18.2.14",
+    "@types/uuid": "^9.0.6",
+    "@typescript-eslint/eslint-plugin": "^6.8.0",
+    "@typescript-eslint/parser": "^6.8.0",
+    "babel-jest": "^29.7.0",
     "babel-plugin-module-resolver": "^5.0.0",
-    "eslint": "^8.44.0",
+    "eslint": "^8.52.0",
     "eslint-config-airbnb": "^19.0.4",
-    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-import-resolver-babel-module": "^5.3.2",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-jest": "^27.2.2",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-jest": "^27.4.3",
     "eslint-plugin-jsx-a11y": "^6.7.1",
-    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.6.0",
-    "jest": "^29.6.1",
-    "jest-environment-jsdom": "^29.6.1",
+    "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.8.0",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   },
   "peerDependencies": {
     "react": "^18.2.0",

package/src/GlobalState.ts

@@ -12,6 +12,7 @@ import SsrContext from './SsrContext';
 
 import {
   type CallbackT,
+  type ForceT,
   type TypeLock,
   type ValueAtPathT,
   type ValueOrInitializerT,
@@ -25,8 +26,11 @@ type GetOptsT<T> = {
   initialValue?: ValueOrInitializerT<T>;
 };
 
-export default class GlobalState<StateT> {
-  readonly ssrContext?: SsrContext<StateT>;
+export default class GlobalState<
+  StateT,
+  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,
+> {
+  readonly ssrContext?: SsrContextT;
 
   #initialState: StateT;
 
@@ -47,7 +51,7 @@ export default class GlobalState<StateT> {
    */
   constructor(
     initialState: StateT,
-    ssrContext?: SsrContext<StateT>,
+    ssrContext?: SsrContextT,
   ) {
     this.#currentState = initialState;
     this.#initialState = initialState;
@@ -158,10 +162,10 @@ export default class GlobalState<StateT> {
 
   // This variant is not callable by default (without generic arguments),
   // otherwise it allows to set the correct ValueT directly.
-  get<Unlocked extends 0 | 1 = 0, ValueT = void>(
+  get<Forced extends ForceT | false = false, ValueT = void>(
     path?: null | string,
-    opts?: GetOptsT<TypeLock<Unlocked, never, ValueT>>,
-  ): TypeLock<Unlocked, void, ValueT>;
+    opts?: GetOptsT<TypeLock<Forced, never, ValueT>>,
+  ): TypeLock<Forced, void, ValueT>;
 
   get<ValueT>(path?: null | string, opts?: GetOptsT<ValueT>): ValueT {
     if (isNil(path)) {
@@ -178,7 +182,7 @@ export default class GlobalState<StateT> {
     res = isFunction(iv) ? iv() : iv;
 
     if (!opts?.initialState || this.get(path) === undefined) {
-      this.set<1, unknown>(path, res);
+      this.set<ForceT, unknown>(path, res);
     }
 
     return res;
@@ -201,10 +205,10 @@ export default class GlobalState<StateT> {
 
   // This variant is disabled by default, otherwise allows to give
   // expected value type explicitly.
-  set<Unlocked extends 0 | 1 = 0, ValueT = never>(
+  set<Forced extends ForceT | false = false, ValueT = never>(
     path: null | string | undefined,
-    value: TypeLock<Unlocked, never, ValueT>,
-  ): TypeLock<Unlocked, void, ValueT>;
+    value: TypeLock<Forced, never, ValueT>,
+  ): TypeLock<Forced, void, ValueT>;
 
   set(path: null | string | undefined, value: unknown): unknown {
     if (isNil(path)) return this.setEntireState(value as StateT);

package/src/GlobalStateProvider.tsx

@@ -22,7 +22,10 @@ const context = createContext<GlobalState<unknown> | null>(null);
  * the global state, instead of accessing it directly.
  * @return
  */
-export function getGlobalState<StateT>(): GlobalState<StateT> {
+export function getGlobalState<
+  StateT,
+  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,
+>(): GlobalState<StateT, SsrContextT> {
   // Here Rules of Hooks are violated because "getGlobalState()" does not follow
   // convention that hook names should start with use... This is intentional in
   // our case, as getGlobalState() hook is intended for advance scenarious,
@@ -32,7 +35,7 @@ export function getGlobalState<StateT>(): GlobalState<StateT> {
   const globalState = useContext(context);
   /* eslint-enable react-hooks/rules-of-hooks */
   if (!globalState) throw new Error('Missing GlobalStateProvider');
-  return globalState as GlobalState<StateT>;
+  return globalState as GlobalState<StateT, SsrContextT>;
 }
 
 /**
@@ -49,25 +52,30 @@ export function getGlobalState<StateT>(): GlobalState<StateT> {
  * - If `throwWithoutSsrContext` is `true`, and there is no SSR context attached
  *   to the global state provided by {@link &lt;GlobalStateProvider&gt;}.
  */
-export function getSsrContext<StateT>(
+export function getSsrContext<
+  SsrContextT extends SsrContext<unknown>,
+>(
   throwWithoutSsrContext = true,
-): SsrContext<StateT> | undefined {
-  const { ssrContext } = getGlobalState<StateT>();
+): SsrContextT | undefined {
+  const { ssrContext } = getGlobalState<SsrContextT['state'], SsrContextT>();
   if (!ssrContext && throwWithoutSsrContext) {
     throw new Error('No SSR context found');
   }
   return ssrContext;
 }
 
-type NewStateProps<StateT> = {
+type NewStateProps<StateT, SsrContextT extends SsrContext<StateT>> = {
   initialState: ValueOrInitializerT<StateT>,
-  ssrContext?: SsrContext<StateT>;
+  ssrContext?: SsrContextT;
 };
 
-type GlobalStateProviderProps<StateT> = {
+type GlobalStateProviderProps<
+  StateT,
+  SsrContextT extends SsrContext<StateT>,
+> = {
   children?: ReactNode;
-} & (NewStateProps<StateT> | {
-  stateProxy: true | GlobalState<StateT>;
+} & (NewStateProps<StateT, SsrContextT> | {
+  stateProxy: true | GlobalState<StateT, SsrContextT>;
 });
 
 /**
@@ -83,10 +91,13 @@ type GlobalStateProviderProps<StateT> = {
  * - If `GlobalState` instance, it will be used by this provider.
  * - If not given, a new `GlobalState` instance will be created and used.
  */
-export default function GlobalStateProvider<StateT>(
-  { children, ...rest }: GlobalStateProviderProps<StateT>,
+export default function GlobalStateProvider<
+  StateT,
+  SsrContextT extends SsrContext<StateT> = SsrContext<StateT>,
+>(
+  { children, ...rest }: GlobalStateProviderProps<StateT, SsrContextT>,
 ) {
-  const state = useRef<GlobalState<StateT>>();
+  const state = useRef<GlobalState<StateT, SsrContextT>>();
   if (!state.current) {
     // NOTE: The last part of condition, "&& rest.stateProxy", is needed for
     // graceful compatibility with JavaScript - if "undefined" stateProxy value
@@ -96,9 +107,9 @@ export default function GlobalStateProvider<StateT>(
       if (rest.stateProxy === true) state.current = getGlobalState();
       else state.current = rest.stateProxy;
     } else {
-      const { initialState, ssrContext } = rest as NewStateProps<StateT>;
+      const { initialState, ssrContext } = rest as NewStateProps<StateT, SsrContextT>;
 
-      state.current = new GlobalState<StateT>(
+      state.current = new GlobalState<StateT, SsrContextT>(
         isFunction(initialState) ? initialState() : initialState,
         ssrContext,
       );

package/src/index.ts

@@ -28,6 +28,6 @@ export {
   default as useGlobalState,
 } from './useGlobalState';
 
-export { type ValueOrInitializerT } from './utils';
+export { type ForceT, type ValueOrInitializerT } from './utils';
 
 export { default as withGlobalStateType } from './withGlobalStateType';

package/src/useAsyncCollection.ts

@@ -8,7 +8,7 @@ import useAsyncData, {
   type UseAsyncDataResT,
 } from './useAsyncData';
 
-import { TypeLock } from './utils';
+import { type ForceT, type TypeLock } from './utils';
 
 export type AsyncCollectionLoaderT<DataT> =
   (id: string, oldData: null | DataT) => DataT | Promise<DataT>;
@@ -70,14 +70,14 @@ function useAsyncCollection<
 ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, `${PathT}.${IdT}`>>;
 
 function useAsyncCollection<
-  Unlocked extends 0 | 1 = 0,
+  Forced extends ForceT | false = false,
   DataT = unknown,
 >(
   id: string,
   path: null | string | undefined,
-  loader: AsyncCollectionLoaderT<TypeLock<Unlocked, void, DataT>>,
+  loader: AsyncCollectionLoaderT<TypeLock<Forced, void, DataT>>,
   options?: UseAsyncDataOptionsT,
-): UseAsyncDataResT<TypeLock<Unlocked, void, DataT>>;
+): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;
 
 function useAsyncCollection<DataT>(
   id: string,
@@ -86,7 +86,7 @@ function useAsyncCollection<DataT>(
   options: UseAsyncDataOptionsT = {},
 ): UseAsyncDataResT<DataT> {
   const itemPath = path ? `${path}.${id}` : id;
-  return useAsyncData<1, DataT>(
+  return useAsyncData<ForceT, DataT>(
     itemPath,
     (oldData: null | DataT) => loader(id, oldData),
     options,

package/src/useAsyncData.ts

@@ -10,11 +10,16 @@ import { MIN_MS } from '@dr.pogodin/js-utils';
 
 import { getGlobalState } from './GlobalStateProvider';
 import useGlobalState from './useGlobalState';
-import { TypeLock, isDebugMode } from './utils';
 
-import GlobalState from './GlobalState';
+import {
+  type ForceT,
+  type TypeLock,
+  type ValueAtPathT,
+  isDebugMode,
+} from './utils';
 
-import { type ValueAtPathT } from './utils';
+import GlobalState from './GlobalState';
+import SsrContext from './SsrContext';
 
 const DEFAULT_MAXAGE = 5 * MIN_MS; // 5 minutes.
 
@@ -70,7 +75,7 @@ export type UseAsyncDataResT<DataT> = {
 async function load<DataT>(
   path: null | string | undefined,
   loader: AsyncDataLoaderT<DataT>,
-  globalState: GlobalState<unknown>,
+  globalState: GlobalState<unknown, SsrContext<unknown>>,
   oldData: DataT | null,
   opIdPrefix: 'C' | 'S' = 'C',
 ): Promise<void> {
@@ -83,11 +88,11 @@ async function load<DataT>(
   }
   const operationId = opIdPrefix + uuid();
   const operationIdPath = path ? `${path}.operationId` : 'operationId';
-  globalState.set<1, string>(operationIdPath, operationId);
+  globalState.set<ForceT, string>(operationIdPath, operationId);
   const data = await loader(
-    oldData || (globalState.get<1, AsyncDataEnvelopeT<DataT>>(path)).data,
+    oldData || (globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path)).data,
   );
-  const state: AsyncDataEnvelopeT<DataT> = globalState.get<1, AsyncDataEnvelopeT<DataT>>(path);
+  const state: AsyncDataEnvelopeT<DataT> = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path);
   if (operationId === state.operationId) {
     if (process.env.NODE_ENV !== 'production' && isDebugMode()) {
       /* eslint-disable no-console */
@@ -99,7 +104,7 @@ async function load<DataT>(
       console.log('Data:', cloneDeep(data));
       /* eslint-enable no-console */
     }
-    globalState.set<1, AsyncDataEnvelopeT<DataT>>(path, {
+    globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {
       ...state,
       data,
       operationId: '',
@@ -176,13 +181,13 @@ function useAsyncData<
 ): UseAsyncDataResT<DataInEnvelopeAtPathT<StateT, PathT>>;
 
 function useAsyncData<
-  Unlocked extends 0 | 1 = 0,
+  Forced extends ForceT | false = false,
   DataT = unknown,
 >(
   path: null | string | undefined,
-  loader: AsyncDataLoaderT<TypeLock<Unlocked, void, DataT>>,
+  loader: AsyncDataLoaderT<TypeLock<Forced, void, DataT>>,
   options?: UseAsyncDataOptionsT,
-): UseAsyncDataResT<TypeLock<Unlocked, void, DataT>>;
+): UseAsyncDataResT<TypeLock<Forced, void, DataT>>;
 
 function useAsyncData<DataT>(
   path: null | string | undefined,
@@ -201,7 +206,7 @@ function useAsyncData<DataT>(
   // Note: here we can't depend on useGlobalState() to init the initial value,
   // because that way we'll have issues with SSR (see details below).
   const globalState = getGlobalState();
-  const state = globalState.get<1, AsyncDataEnvelopeT<DataT>>(path, {
+  const state = globalState.get<ForceT, AsyncDataEnvelopeT<DataT>>(path, {
     initialValue: newAsyncDataEnvelope<DataT>(),
   });
 
@@ -223,10 +228,11 @@ function useAsyncData<DataT>(
     // The same applies to other useEffect() hooks below.
     useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks
       const numRefsPath = path ? `${path}.numRefs` : 'numRefs';
-      const numRefs = globalState.get<1, number>(numRefsPath);
-      globalState.set<1, number>(numRefsPath, numRefs + 1);
+      const numRefs = globalState.get<ForceT, number>(numRefsPath);
+      globalState.set<ForceT, number>(numRefsPath, numRefs + 1);
       return () => {
-        const state2: AsyncDataEnvelopeT<DataT> = globalState.get<1, AsyncDataEnvelopeT<DataT>>(
+        const state2: AsyncDataEnvelopeT<DataT> = globalState.get<
+        ForceT, AsyncDataEnvelopeT<DataT>>(
           path,
         );
         if (
@@ -242,13 +248,13 @@ function useAsyncData<DataT>(
             );
             /* eslint-enable no-console */
           }
-          globalState.set<1, AsyncDataEnvelopeT<DataT>>(path, {
+          globalState.set<ForceT, AsyncDataEnvelopeT<DataT>>(path, {
             ...state2,
             data: null,
             numRefs: 0,
             timestamp: 0,
           });
-        } else globalState.set<1, number>(numRefsPath, state2.numRefs - 1);
+        } else globalState.set<ForceT, number>(numRefsPath, state2.numRefs - 1);
       };
     }, [garbageCollectAge, globalState, path]);
 
@@ -258,7 +264,9 @@ function useAsyncData<DataT>(
     // Data loading and refreshing.
     let loadTriggered = false;
     useEffect(() => { // eslint-disable-line react-hooks/rules-of-hooks
-      const state2: AsyncDataEnvelopeT<DataT> = globalState.get<1, AsyncDataEnvelopeT<DataT>>(path);
+      const state2: AsyncDataEnvelopeT<DataT> = globalState.get<
+      ForceT, AsyncDataEnvelopeT<DataT>>(path);
+
       if (refreshAge < Date.now() - state2.timestamp
       && (!state2.operationId || state2.operationId.charAt(0) === 'S')) {
         load(path, loader, globalState, state2.data);
@@ -272,7 +280,7 @@ function useAsyncData<DataT>(
     }, deps); // eslint-disable-line react-hooks/exhaustive-deps
   }
 
-  const [localState] = useGlobalState<1, AsyncDataEnvelopeT<DataT>>(
+  const [localState] = useGlobalState<ForceT, AsyncDataEnvelopeT<DataT>>(
     path,
     newAsyncDataEnvelope<DataT>(),
   );

package/src/useGlobalState.ts

@@ -10,6 +10,7 @@ import { getGlobalState } from './GlobalStateProvider';
 
 import {
   type CallbackT,
+  type ForceT,
   type TypeLock,
   type ValueAtPathT,
   type ValueOrInitializerT,
@@ -82,6 +83,11 @@ export type UseGlobalStateResT<T> = [T, SetterT<T>];
 
 function useGlobalState<StateT>(): UseGlobalStateResT<StateT>;
 
+function useGlobalState<Forced extends ForceT | false = false, ValueT = unknown>(
+  path: null | string | undefined,
+  initialValue?: ValueOrInitializerT<TypeLock<Forced, never, ValueT>>,
+): UseGlobalStateResT<TypeLock<Forced, void, ValueT>>;
+
 function useGlobalState<
   StateT,
   PathT extends null | string | undefined,
@@ -90,14 +96,6 @@ function useGlobalState<
   initialValue?: ValueOrInitializerT<ValueAtPathT<StateT, PathT, never>>
 ): UseGlobalStateResT<ValueAtPathT<StateT, PathT, void>>;
 
-function useGlobalState<
-  Unlocked extends 0 | 1 = 0,
-  ValueT = void,
->(
-  path: null | string | undefined,
-  initialValue?: ValueOrInitializerT<TypeLock<Unlocked, never, ValueT>>,
-): UseGlobalStateResT<TypeLock<Unlocked, void, ValueT>>;
-
 function useGlobalState(
   path?: null | string,
   initialValue?: ValueOrInitializerT<unknown>,
@@ -122,7 +120,7 @@ function useGlobalState(
         console.groupEnd();
         /* eslint-enable no-console */
       }
-      rc.globalState.set<1, unknown>(rc.path, newState);
+      rc.globalState.set<ForceT, unknown>(rc.path, newState);
     },
     state: isFunction(initialValue) ? initialValue() : initialValue,
     watcher: () => {
@@ -137,8 +135,8 @@ function useGlobalState(
 
   rc.state = useSyncExternalStore(
     (cb) => rc.emitter.addListener(cb),
-    () => rc.globalState.get<1, unknown>(rc.path, { initialValue }),
-    () => rc.globalState.get<1, unknown>(rc.path, { initialValue, initialState: true }),
+    () => rc.globalState.get<ForceT, unknown>(rc.path, { initialValue }),
+    () => rc.globalState.get<ForceT, unknown>(rc.path, { initialValue, initialState: true }),
   );
 
   useEffect(() => {

package/src/utils.ts

@@ -2,12 +2,17 @@ import { type GetFieldType } from 'lodash';
 
 export type CallbackT = () => void;
 
-// TODO: This probably should be moved to JS Utils lib.
+// TODO: This (ForceT & TypeLock) probably should be moved to JS Utils lib.
+
+// This type is used to "unlocked" special generic overrides around the library.
+declare const force: unique symbol;
+export type ForceT = typeof force;
+
 export type TypeLock<
-  Unlocked extends 0 | 1,
+  Unlocked extends ForceT | false,
   LockedT extends never | void,
   UnlockedT,
-> = Unlocked extends 0 ? LockedT : UnlockedT;
+> = Unlocked extends ForceT ? UnlockedT : LockedT;
 
 /**
  * Given the type of state, `StateT`, and the type of state path, `PathT`,