mvc-kit 2.12.5 → 2.13.0

package/dist/react/use-instance.js

@@ -1,41 +1,48 @@
 import { useRef, useSyncExternalStore } from "react";
+//#region src/react/use-instance.ts
 function hasAsyncSubscription(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj.subscribeAsync === "function";
+	return obj !== null && typeof obj === "object" && typeof obj.subscribeAsync === "function";
 }
-const SERVER_SNAPSHOT = () => 0;
+var SERVER_SNAPSHOT = () => 0;
+/**
+* Subscribe to an existing Subscribable instance.
+* No ownership - caller manages the instance lifecycle.
+*
+* If the instance has a `subscribeAsync` method (duck-typed),
+* a combined subscription ensures async state changes also
+* trigger React re-renders.
+*/
 function useInstance(subscribable) {
-  const ref = useRef(null);
-  if (!ref.current || ref.current.subscribable !== subscribable) {
-    const version = { current: ref.current?.version ?? 0 };
-    ref.current = {
-      version: version.current,
-      subscribable,
-      subscribe: (onStoreChange) => {
-        const unsub1 = subscribable.subscribe(() => {
-          version.current++;
-          ref.current.version = version.current;
-          onStoreChange();
-        });
-        let unsub2;
-        if (hasAsyncSubscription(subscribable)) {
-          unsub2 = subscribable.subscribeAsync(() => {
-            version.current++;
-            ref.current.version = version.current;
-            onStoreChange();
-          });
-        }
-        return () => {
-          unsub1();
-          unsub2?.();
-        };
-      },
-      getSnapshot: () => version.current
-    };
-  }
-  useSyncExternalStore(ref.current.subscribe, ref.current.getSnapshot, SERVER_SNAPSHOT);
-  return subscribable.state;
+	const ref = useRef(null);
+	if (!ref.current || ref.current.subscribable !== subscribable) {
+		const version = { current: ref.current?.version ?? 0 };
+		ref.current = {
+			version: version.current,
+			subscribable,
+			subscribe: (onStoreChange) => {
+				const unsub1 = subscribable.subscribe(() => {
+					version.current++;
+					ref.current.version = version.current;
+					onStoreChange();
+				});
+				let unsub2;
+				if (hasAsyncSubscription(subscribable)) unsub2 = subscribable.subscribeAsync(() => {
+					version.current++;
+					ref.current.version = version.current;
+					onStoreChange();
+				});
+				return () => {
+					unsub1();
+					unsub2?.();
+				};
+			},
+			getSnapshot: () => version.current
+		};
+	}
+	useSyncExternalStore(ref.current.subscribe, ref.current.getSnapshot, SERVER_SNAPSHOT);
+	return subscribable.state;
 }
-export {
-  useInstance
-};
-//# sourceMappingURL=use-instance.js.map
+//#endregion
+export { useInstance };
+
+//# sourceMappingURL=use-instance.js.map

package/dist/react/use-instance.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-instance.js","sources":["../../src/react/use-instance.ts"],"sourcesContent":["import { useSyncExternalStore, useRef } from 'react';\nimport type { Subscribable } from '../types';\n\nfunction hasAsyncSubscription(obj: unknown): obj is { subscribeAsync(cb: () => void): () => void } {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    typeof (obj as any).subscribeAsync === 'function'\n  );\n}\n\nconst SERVER_SNAPSHOT = () => 0;\n\ninterface InstanceRef<S> {\n  version: number;\n  subscribable: Subscribable<S>;\n  subscribe: (onStoreChange: () => void) => () => void;\n  getSnapshot: () => number;\n}\n\n/**\n * Subscribe to an existing Subscribable instance.\n * No ownership - caller manages the instance lifecycle.\n *\n * If the instance has a `subscribeAsync` method (duck-typed),\n * a combined subscription ensures async state changes also\n * trigger React re-renders.\n */\nexport function useInstance<S>(subscribable: Subscribable<S>): S {\n  const ref = useRef<InstanceRef<S> | null>(null);\n\n  if (!ref.current || ref.current.subscribable !== subscribable) {\n    const version = { current: ref.current?.version ?? 0 };\n    ref.current = {\n      version: version.current,\n      subscribable,\n      subscribe: (onStoreChange: () => void) => {\n        const unsub1 = subscribable.subscribe(() => {\n          version.current++;\n          ref.current!.version = version.current;\n          onStoreChange();\n        });\n        let unsub2: (() => void) | undefined;\n        if (hasAsyncSubscription(subscribable)) {\n          unsub2 = subscribable.subscribeAsync(() => {\n            version.current++;\n            ref.current!.version = version.current;\n            onStoreChange();\n          });\n        }\n        return () => { unsub1(); unsub2?.(); };\n      },\n      getSnapshot: () => version.current,\n    };\n  }\n\n  useSyncExternalStore(ref.current.subscribe, ref.current.getSnapshot, SERVER_SNAPSHOT);\n\n  return subscribable.state;\n}\n"],"names":[],"mappings":";AAGA,SAAS,qBAAqB,KAAqE;AACjG,SACE,QAAQ,QACR,OAAO,QAAQ,YACf,OAAQ,IAAY,mBAAmB;AAE3C;AAEA,MAAM,kBAAkB,MAAM;AAiBvB,SAAS,YAAe,cAAkC;AAC/D,QAAM,MAAM,OAA8B,IAAI;AAE9C,MAAI,CAAC,IAAI,WAAW,IAAI,QAAQ,iBAAiB,cAAc;AAC7D,UAAM,UAAU,EAAE,SAAS,IAAI,SAAS,WAAW,EAAA;AACnD,QAAI,UAAU;AAAA,MACZ,SAAS,QAAQ;AAAA,MACjB;AAAA,MACA,WAAW,CAAC,kBAA8B;AACxC,cAAM,SAAS,aAAa,UAAU,MAAM;AAC1C,kBAAQ;AACR,cAAI,QAAS,UAAU,QAAQ;AAC/B,wBAAA;AAAA,QACF,CAAC;AACD,YAAI;AACJ,YAAI,qBAAqB,YAAY,GAAG;AACtC,mBAAS,aAAa,eAAe,MAAM;AACzC,oBAAQ;AACR,gBAAI,QAAS,UAAU,QAAQ;AAC/B,0BAAA;AAAA,UACF,CAAC;AAAA,QACH;AACA,eAAO,MAAM;AAAE,iBAAA;AAAU,mBAAA;AAAA,QAAY;AAAA,MACvC;AAAA,MACA,aAAa,MAAM,QAAQ;AAAA,IAAA;AAAA,EAE/B;AAEA,uBAAqB,IAAI,QAAQ,WAAW,IAAI,QAAQ,aAAa,eAAe;AAEpF,SAAO,aAAa;AACtB;"}
+{"version":3,"file":"use-instance.js","names":[],"sources":["../../src/react/use-instance.ts"],"sourcesContent":["import { useSyncExternalStore, useRef } from 'react';\nimport type { Subscribable } from '../types';\n\nfunction hasAsyncSubscription(obj: unknown): obj is { subscribeAsync(cb: () => void): () => void } {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    typeof (obj as any).subscribeAsync === 'function'\n  );\n}\n\nconst SERVER_SNAPSHOT = () => 0;\n\ninterface InstanceRef<S> {\n  version: number;\n  subscribable: Subscribable<S>;\n  subscribe: (onStoreChange: () => void) => () => void;\n  getSnapshot: () => number;\n}\n\n/**\n * Subscribe to an existing Subscribable instance.\n * No ownership - caller manages the instance lifecycle.\n *\n * If the instance has a `subscribeAsync` method (duck-typed),\n * a combined subscription ensures async state changes also\n * trigger React re-renders.\n */\nexport function useInstance<S>(subscribable: Subscribable<S>): S {\n  const ref = useRef<InstanceRef<S> | null>(null);\n\n  if (!ref.current || ref.current.subscribable !== subscribable) {\n    const version = { current: ref.current?.version ?? 0 };\n    ref.current = {\n      version: version.current,\n      subscribable,\n      subscribe: (onStoreChange: () => void) => {\n        const unsub1 = subscribable.subscribe(() => {\n          version.current++;\n          ref.current!.version = version.current;\n          onStoreChange();\n        });\n        let unsub2: (() => void) | undefined;\n        if (hasAsyncSubscription(subscribable)) {\n          unsub2 = subscribable.subscribeAsync(() => {\n            version.current++;\n            ref.current!.version = version.current;\n            onStoreChange();\n          });\n        }\n        return () => { unsub1(); unsub2?.(); };\n      },\n      getSnapshot: () => version.current,\n    };\n  }\n\n  useSyncExternalStore(ref.current.subscribe, ref.current.getSnapshot, SERVER_SNAPSHOT);\n\n  return subscribable.state;\n}\n"],"mappings":";;AAGA,SAAS,qBAAqB,KAAqE;AACjG,QACE,QAAQ,QACR,OAAO,QAAQ,YACf,OAAQ,IAAY,mBAAmB;;AAI3C,IAAM,wBAAwB;;;;;;;;;AAiB9B,SAAgB,YAAe,cAAkC;CAC/D,MAAM,MAAM,OAA8B,KAAK;AAE/C,KAAI,CAAC,IAAI,WAAW,IAAI,QAAQ,iBAAiB,cAAc;EAC7D,MAAM,UAAU,EAAE,SAAS,IAAI,SAAS,WAAW,GAAG;AACtD,MAAI,UAAU;GACZ,SAAS,QAAQ;GACjB;GACA,YAAY,kBAA8B;IACxC,MAAM,SAAS,aAAa,gBAAgB;AAC1C,aAAQ;AACR,SAAI,QAAS,UAAU,QAAQ;AAC/B,oBAAe;MACf;IACF,IAAI;AACJ,QAAI,qBAAqB,aAAa,CACpC,UAAS,aAAa,qBAAqB;AACzC,aAAQ;AACR,SAAI,QAAS,UAAU,QAAQ;AAC/B,oBAAe;MACf;AAEJ,iBAAa;AAAE,aAAQ;AAAE,eAAU;;;GAErC,mBAAmB,QAAQ;GAC5B;;AAGH,sBAAqB,IAAI,QAAQ,WAAW,IAAI,QAAQ,aAAa,gBAAgB;AAErF,QAAO,aAAa"}

package/dist/react/use-local.cjs

@@ -1,69 +1,53 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const react = require("react");
-const guards = require("./guards.cjs");
-const useInstance = require("./use-instance.cjs");
-const useSubscribeOnly = require("./use-subscribe-only.cjs");
+const require_use_instance = require("./use-instance.cjs");
+const require_guards = require("./guards.cjs");
+const require_use_subscribe_only = require("./use-subscribe-only.cjs");
+let react = require("react");
+//#region src/react/use-local.ts
 function depsChanged(prev, next) {
-  if (prev === void 0) return false;
-  if (prev.length !== next.length) return true;
-  for (let i = 0; i < prev.length; i++) {
-    if (!Object.is(prev[i], next[i])) return true;
-  }
-  return false;
+	if (prev === void 0) return false;
+	if (prev.length !== next.length) return true;
+	for (let i = 0; i < prev.length; i++) if (!Object.is(prev[i], next[i])) return true;
+	return false;
 }
 function useLocal(classOrFactory, ...rest) {
-  let args;
-  let deps;
-  if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {
-    deps = rest[rest.length - 1];
-    args = rest.slice(0, -1);
-  } else {
-    args = rest;
-    deps = void 0;
-  }
-  const instanceRef = react.useRef(null);
-  const mountedRef = react.useRef(false);
-  const prevDepsRef = react.useRef(void 0);
-  if (deps !== void 0 && depsChanged(prevDepsRef.current, deps)) {
-    instanceRef.current?.dispose();
-    instanceRef.current = null;
-  }
-  if (deps !== void 0) {
-    prevDepsRef.current = deps;
-  }
-  if (!instanceRef.current || instanceRef.current.disposed) {
-    const isClass = typeof classOrFactory === "function" && classOrFactory.prototype && classOrFactory.prototype.constructor === classOrFactory;
-    if (isClass) {
-      instanceRef.current = new classOrFactory(...args);
-    } else {
-      instanceRef.current = classOrFactory();
-    }
-  }
-  react.useEffect(() => {
-    const instance = instanceRef.current;
-    mountedRef.current = true;
-    if (guards.isInitializable(instance)) {
-      instance.init();
-    }
-    return () => {
-      mountedRef.current = false;
-      setTimeout(() => {
-        if (!mountedRef.current) {
-          instance.dispose();
-        }
-      }, 0);
-    };
-  }, deps ?? []);
-  if (guards.isSubscribable(instanceRef.current)) {
-    const state = useInstance.useInstance(instanceRef.current);
-    return [state, instanceRef.current];
-  }
-  if (guards.isSubscribeOnly(instanceRef.current)) {
-    useSubscribeOnly.useSubscribeOnly(instanceRef.current);
-    return instanceRef.current;
-  }
-  return instanceRef.current;
+	let args;
+	let deps;
+	if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {
+		deps = rest[rest.length - 1];
+		args = rest.slice(0, -1);
+	} else {
+		args = rest;
+		deps = void 0;
+	}
+	const instanceRef = (0, react.useRef)(null);
+	const mountedRef = (0, react.useRef)(false);
+	const prevDepsRef = (0, react.useRef)(void 0);
+	if (deps !== void 0 && depsChanged(prevDepsRef.current, deps)) {
+		instanceRef.current?.dispose();
+		instanceRef.current = null;
+	}
+	if (deps !== void 0) prevDepsRef.current = deps;
+	if (!instanceRef.current || instanceRef.current.disposed) if (typeof classOrFactory === "function" && classOrFactory.prototype && classOrFactory.prototype.constructor === classOrFactory) instanceRef.current = new classOrFactory(...args);
+	else instanceRef.current = classOrFactory();
+	(0, react.useEffect)(() => {
+		const instance = instanceRef.current;
+		mountedRef.current = true;
+		if (require_guards.isInitializable(instance)) instance.init();
+		return () => {
+			mountedRef.current = false;
+			setTimeout(() => {
+				if (!mountedRef.current) instance.dispose();
+			}, 0);
+		};
+	}, deps ?? []);
+	if (require_guards.isSubscribable(instanceRef.current)) return [require_use_instance.useInstance(instanceRef.current), instanceRef.current];
+	if (require_guards.isSubscribeOnly(instanceRef.current)) {
+		require_use_subscribe_only.useSubscribeOnly(instanceRef.current);
+		return instanceRef.current;
+	}
+	return instanceRef.current;
 }
+//#endregion
 exports.useLocal = useLocal;
-//# sourceMappingURL=use-local.cjs.map
+
+//# sourceMappingURL=use-local.cjs.map

package/dist/react/use-local.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-local.cjs","sources":["../../src/react/use-local.ts"],"sourcesContent":["import { useRef, useEffect } from 'react';\nimport type { DependencyList } from 'react';\nimport type { Subscribable, Disposable } from '../types';\nimport { isSubscribable, isSubscribeOnly, isInitializable } from './guards';\nimport { useInstance } from './use-instance';\nimport { useSubscribeOnly } from './use-subscribe-only';\nimport type { StateOf } from './types';\n\nfunction depsChanged(prev: DependencyList | undefined, next: DependencyList): boolean {\n  if (prev === undefined) return false;\n  if (prev.length !== next.length) return true;\n  for (let i = 0; i < prev.length; i++) {\n    if (!Object.is(prev[i], next[i])) return true;\n  }\n  return false;\n}\n\n// ── With deps (class + initialState + deps) ────────────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<any> & Disposable>(\n  Class: new (initialState: StateOf<T>) => T,\n  initialState: StateOf<T>,\n  deps: DependencyList,\n): [StateOf<T>, T];\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T,\n  deps: DependencyList,\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(\n  factory: () => T,\n  deps: DependencyList,\n): T;\n\n// ── Without deps (existing overloads, unchanged) ───────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<\n  T extends Subscribable<S> & Disposable,\n  S = StateOf<T>,\n  Args extends unknown[] = unknown[]\n>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable, Args extends unknown[] = unknown[]>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): T;\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(factory: () => T): T;\n\n// ── Implementation ─────────────────────────────────────────────────\n\nexport function useLocal<T extends Disposable, S = StateOf<T>>(\n  classOrFactory: (new (...args: unknown[]) => T) | (() => T),\n  ...rest: unknown[]\n): [S, T] | T {\n  // ── Detect deps: last arg is an array → treat as deps ──\n  let args: unknown[];\n  let deps: DependencyList | undefined;\n\n  if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {\n    deps = rest[rest.length - 1] as DependencyList;\n    args = rest.slice(0, -1);\n  } else {\n    args = rest;\n    deps = undefined;\n  }\n\n  const instanceRef = useRef<T | null>(null);\n  const mountedRef = useRef(false);\n  const prevDepsRef = useRef<DependencyList | undefined>(undefined);\n\n  // ── Render phase: dep-change detection ──\n  if (deps !== undefined && depsChanged(prevDepsRef.current, deps)) {\n    instanceRef.current?.dispose();\n    instanceRef.current = null;\n  }\n  if (deps !== undefined) {\n    prevDepsRef.current = deps;\n  }\n\n  // ── Create instance if needed ──\n  if (!instanceRef.current || instanceRef.current.disposed) {\n    const isClass =\n      typeof classOrFactory === 'function' &&\n      classOrFactory.prototype &&\n      classOrFactory.prototype.constructor === classOrFactory;\n\n    if (isClass) {\n      instanceRef.current = new (classOrFactory as new (...a: unknown[]) => T)(...args);\n    } else {\n      instanceRef.current = (classOrFactory as () => T)();\n    }\n  }\n\n  // ── Effect: init + deferred cleanup ──\n  useEffect(() => {\n    const instance = instanceRef.current!; // capture for cleanup closure\n    mountedRef.current = true;\n    if (isInitializable(instance)) {\n      instance.init();\n    }\n    return () => {\n      mountedRef.current = false;\n      setTimeout(() => {\n        if (!mountedRef.current) {\n          instance.dispose();\n        }\n      }, 0);\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps ?? []);\n\n  // ── Subscribe to state if Subscribable ──\n  if (isSubscribable(instanceRef.current)) {\n    const state = useInstance(instanceRef.current as unknown as Subscribable<S>);\n    return [state, instanceRef.current];\n  }\n\n  // ── Subscribe for re-renders if subscribe-only (e.g., Trackable) ──\n  if (isSubscribeOnly(instanceRef.current)) {\n    useSubscribeOnly(instanceRef.current);\n    return instanceRef.current;\n  }\n\n  return instanceRef.current;\n}\n"],"names":["useRef","useEffect","isInitializable","isSubscribable","useInstance","isSubscribeOnly","useSubscribeOnly"],"mappings":";;;;;;AAQA,SAAS,YAAY,MAAkC,MAA+B;AACpF,MAAI,SAAS,OAAW,QAAO;AAC/B,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AACxC,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAI,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,EAAG,QAAO;AAAA,EAC3C;AACA,SAAO;AACT;AA2EO,SAAS,SACd,mBACG,MACS;AAEZ,MAAI;AACJ,MAAI;AAEJ,MAAI,KAAK,SAAS,KAAK,MAAM,QAAQ,KAAK,KAAK,SAAS,CAAC,CAAC,GAAG;AAC3D,WAAO,KAAK,KAAK,SAAS,CAAC;AAC3B,WAAO,KAAK,MAAM,GAAG,EAAE;AAAA,EACzB,OAAO;AACL,WAAO;AACP,WAAO;AAAA,EACT;AAEA,QAAM,cAAcA,MAAAA,OAAiB,IAAI;AACzC,QAAM,aAAaA,MAAAA,OAAO,KAAK;AAC/B,QAAM,cAAcA,MAAAA,OAAmC,MAAS;AAGhE,MAAI,SAAS,UAAa,YAAY,YAAY,SAAS,IAAI,GAAG;AAChE,gBAAY,SAAS,QAAA;AACrB,gBAAY,UAAU;AAAA,EACxB;AACA,MAAI,SAAS,QAAW;AACtB,gBAAY,UAAU;AAAA,EACxB;AAGA,MAAI,CAAC,YAAY,WAAW,YAAY,QAAQ,UAAU;AACxD,UAAM,UACJ,OAAO,mBAAmB,cAC1B,eAAe,aACf,eAAe,UAAU,gBAAgB;AAE3C,QAAI,SAAS;AACX,kBAAY,UAAU,IAAK,eAA8C,GAAG,IAAI;AAAA,IAClF,OAAO;AACL,kBAAY,UAAW,eAAA;AAAA,IACzB;AAAA,EACF;AAGAC,QAAAA,UAAU,MAAM;AACd,UAAM,WAAW,YAAY;AAC7B,eAAW,UAAU;AACrB,QAAIC,OAAAA,gBAAgB,QAAQ,GAAG;AAC7B,eAAS,KAAA;AAAA,IACX;AACA,WAAO,MAAM;AACX,iBAAW,UAAU;AACrB,iBAAW,MAAM;AACf,YAAI,CAAC,WAAW,SAAS;AACvB,mBAAS,QAAA;AAAA,QACX;AAAA,MACF,GAAG,CAAC;AAAA,IACN;AAAA,EAEF,GAAG,QAAQ,EAAE;AAGb,MAAIC,OAAAA,eAAe,YAAY,OAAO,GAAG;AACvC,UAAM,QAAQC,YAAAA,YAAY,YAAY,OAAqC;AAC3E,WAAO,CAAC,OAAO,YAAY,OAAO;AAAA,EACpC;AAGA,MAAIC,OAAAA,gBAAgB,YAAY,OAAO,GAAG;AACxCC,qBAAAA,iBAAiB,YAAY,OAAO;AACpC,WAAO,YAAY;AAAA,EACrB;AAEA,SAAO,YAAY;AACrB;;"}
+{"version":3,"file":"use-local.cjs","names":[],"sources":["../../src/react/use-local.ts"],"sourcesContent":["import { useRef, useEffect } from 'react';\nimport type { DependencyList } from 'react';\nimport type { Subscribable, Disposable } from '../types';\nimport { isSubscribable, isSubscribeOnly, isInitializable } from './guards';\nimport { useInstance } from './use-instance';\nimport { useSubscribeOnly } from './use-subscribe-only';\nimport type { StateOf } from './types';\n\nfunction depsChanged(prev: DependencyList | undefined, next: DependencyList): boolean {\n  if (prev === undefined) return false;\n  if (prev.length !== next.length) return true;\n  for (let i = 0; i < prev.length; i++) {\n    if (!Object.is(prev[i], next[i])) return true;\n  }\n  return false;\n}\n\n// ── With deps (class + initialState + deps) ────────────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<any> & Disposable>(\n  Class: new (initialState: StateOf<T>) => T,\n  initialState: StateOf<T>,\n  deps: DependencyList,\n): [StateOf<T>, T];\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T,\n  deps: DependencyList,\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(\n  factory: () => T,\n  deps: DependencyList,\n): T;\n\n// ── Without deps (existing overloads, unchanged) ───────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<\n  T extends Subscribable<S> & Disposable,\n  S = StateOf<T>,\n  Args extends unknown[] = unknown[]\n>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable, Args extends unknown[] = unknown[]>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): T;\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(factory: () => T): T;\n\n// ── Implementation ─────────────────────────────────────────────────\n\nexport function useLocal<T extends Disposable, S = StateOf<T>>(\n  classOrFactory: (new (...args: unknown[]) => T) | (() => T),\n  ...rest: unknown[]\n): [S, T] | T {\n  // ── Detect deps: last arg is an array → treat as deps ──\n  let args: unknown[];\n  let deps: DependencyList | undefined;\n\n  if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {\n    deps = rest[rest.length - 1] as DependencyList;\n    args = rest.slice(0, -1);\n  } else {\n    args = rest;\n    deps = undefined;\n  }\n\n  const instanceRef = useRef<T | null>(null);\n  const mountedRef = useRef(false);\n  const prevDepsRef = useRef<DependencyList | undefined>(undefined);\n\n  // ── Render phase: dep-change detection ──\n  if (deps !== undefined && depsChanged(prevDepsRef.current, deps)) {\n    instanceRef.current?.dispose();\n    instanceRef.current = null;\n  }\n  if (deps !== undefined) {\n    prevDepsRef.current = deps;\n  }\n\n  // ── Create instance if needed ──\n  if (!instanceRef.current || instanceRef.current.disposed) {\n    const isClass =\n      typeof classOrFactory === 'function' &&\n      classOrFactory.prototype &&\n      classOrFactory.prototype.constructor === classOrFactory;\n\n    if (isClass) {\n      instanceRef.current = new (classOrFactory as new (...a: unknown[]) => T)(...args);\n    } else {\n      instanceRef.current = (classOrFactory as () => T)();\n    }\n  }\n\n  // ── Effect: init + deferred cleanup ──\n  useEffect(() => {\n    const instance = instanceRef.current!; // capture for cleanup closure\n    mountedRef.current = true;\n    if (isInitializable(instance)) {\n      instance.init();\n    }\n    return () => {\n      mountedRef.current = false;\n      setTimeout(() => {\n        if (!mountedRef.current) {\n          instance.dispose();\n        }\n      }, 0);\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps ?? []);\n\n  // ── Subscribe to state if Subscribable ──\n  if (isSubscribable(instanceRef.current)) {\n    const state = useInstance(instanceRef.current as unknown as Subscribable<S>);\n    return [state, instanceRef.current];\n  }\n\n  // ── Subscribe for re-renders if subscribe-only (e.g., Trackable) ──\n  if (isSubscribeOnly(instanceRef.current)) {\n    useSubscribeOnly(instanceRef.current);\n    return instanceRef.current;\n  }\n\n  return instanceRef.current;\n}\n"],"mappings":";;;;;AAQA,SAAS,YAAY,MAAkC,MAA+B;AACpF,KAAI,SAAS,KAAA,EAAW,QAAO;AAC/B,KAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AACxC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC/B,KAAI,CAAC,OAAO,GAAG,KAAK,IAAI,KAAK,GAAG,CAAE,QAAO;AAE3C,QAAO;;AA4ET,SAAgB,SACd,gBACA,GAAG,MACS;CAEZ,IAAI;CACJ,IAAI;AAEJ,KAAI,KAAK,SAAS,KAAK,MAAM,QAAQ,KAAK,KAAK,SAAS,GAAG,EAAE;AAC3D,SAAO,KAAK,KAAK,SAAS;AAC1B,SAAO,KAAK,MAAM,GAAG,GAAG;QACnB;AACL,SAAO;AACP,SAAO,KAAA;;CAGT,MAAM,eAAA,GAAA,MAAA,QAA+B,KAAK;CAC1C,MAAM,cAAA,GAAA,MAAA,QAAoB,MAAM;CAChC,MAAM,eAAA,GAAA,MAAA,QAAiD,KAAA,EAAU;AAGjE,KAAI,SAAS,KAAA,KAAa,YAAY,YAAY,SAAS,KAAK,EAAE;AAChE,cAAY,SAAS,SAAS;AAC9B,cAAY,UAAU;;AAExB,KAAI,SAAS,KAAA,EACX,aAAY,UAAU;AAIxB,KAAI,CAAC,YAAY,WAAW,YAAY,QAAQ,SAM9C,KAJE,OAAO,mBAAmB,cAC1B,eAAe,aACf,eAAe,UAAU,gBAAgB,eAGzC,aAAY,UAAU,IAAK,eAA8C,GAAG,KAAK;KAEjF,aAAY,UAAW,gBAA4B;AAKvD,EAAA,GAAA,MAAA,iBAAgB;EACd,MAAM,WAAW,YAAY;AAC7B,aAAW,UAAU;AACrB,MAAI,eAAA,gBAAgB,SAAS,CAC3B,UAAS,MAAM;AAEjB,eAAa;AACX,cAAW,UAAU;AACrB,oBAAiB;AACf,QAAI,CAAC,WAAW,QACd,UAAS,SAAS;MAEnB,EAAE;;IAGN,QAAQ,EAAE,CAAC;AAGd,KAAI,eAAA,eAAe,YAAY,QAAQ,CAErC,QAAO,CADO,qBAAA,YAAY,YAAY,QAAsC,EAC7D,YAAY,QAAQ;AAIrC,KAAI,eAAA,gBAAgB,YAAY,QAAQ,EAAE;AACxC,6BAAA,iBAAiB,YAAY,QAAQ;AACrC,SAAO,YAAY;;AAGrB,QAAO,YAAY"}

package/dist/react/use-local.js

@@ -1,69 +1,53 @@
-import { useRef, useEffect } from "react";
-import { isInitializable, isSubscribable, isSubscribeOnly } from "./guards.js";
 import { useInstance } from "./use-instance.js";
+import { isInitializable, isSubscribable, isSubscribeOnly } from "./guards.js";
 import { useSubscribeOnly } from "./use-subscribe-only.js";
+import { useEffect, useRef } from "react";
+//#region src/react/use-local.ts
 function depsChanged(prev, next) {
-  if (prev === void 0) return false;
-  if (prev.length !== next.length) return true;
-  for (let i = 0; i < prev.length; i++) {
-    if (!Object.is(prev[i], next[i])) return true;
-  }
-  return false;
+	if (prev === void 0) return false;
+	if (prev.length !== next.length) return true;
+	for (let i = 0; i < prev.length; i++) if (!Object.is(prev[i], next[i])) return true;
+	return false;
 }
 function useLocal(classOrFactory, ...rest) {
-  let args;
-  let deps;
-  if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {
-    deps = rest[rest.length - 1];
-    args = rest.slice(0, -1);
-  } else {
-    args = rest;
-    deps = void 0;
-  }
-  const instanceRef = useRef(null);
-  const mountedRef = useRef(false);
-  const prevDepsRef = useRef(void 0);
-  if (deps !== void 0 && depsChanged(prevDepsRef.current, deps)) {
-    instanceRef.current?.dispose();
-    instanceRef.current = null;
-  }
-  if (deps !== void 0) {
-    prevDepsRef.current = deps;
-  }
-  if (!instanceRef.current || instanceRef.current.disposed) {
-    const isClass = typeof classOrFactory === "function" && classOrFactory.prototype && classOrFactory.prototype.constructor === classOrFactory;
-    if (isClass) {
-      instanceRef.current = new classOrFactory(...args);
-    } else {
-      instanceRef.current = classOrFactory();
-    }
-  }
-  useEffect(() => {
-    const instance = instanceRef.current;
-    mountedRef.current = true;
-    if (isInitializable(instance)) {
-      instance.init();
-    }
-    return () => {
-      mountedRef.current = false;
-      setTimeout(() => {
-        if (!mountedRef.current) {
-          instance.dispose();
-        }
-      }, 0);
-    };
-  }, deps ?? []);
-  if (isSubscribable(instanceRef.current)) {
-    const state = useInstance(instanceRef.current);
-    return [state, instanceRef.current];
-  }
-  if (isSubscribeOnly(instanceRef.current)) {
-    useSubscribeOnly(instanceRef.current);
-    return instanceRef.current;
-  }
-  return instanceRef.current;
+	let args;
+	let deps;
+	if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {
+		deps = rest[rest.length - 1];
+		args = rest.slice(0, -1);
+	} else {
+		args = rest;
+		deps = void 0;
+	}
+	const instanceRef = useRef(null);
+	const mountedRef = useRef(false);
+	const prevDepsRef = useRef(void 0);
+	if (deps !== void 0 && depsChanged(prevDepsRef.current, deps)) {
+		instanceRef.current?.dispose();
+		instanceRef.current = null;
+	}
+	if (deps !== void 0) prevDepsRef.current = deps;
+	if (!instanceRef.current || instanceRef.current.disposed) if (typeof classOrFactory === "function" && classOrFactory.prototype && classOrFactory.prototype.constructor === classOrFactory) instanceRef.current = new classOrFactory(...args);
+	else instanceRef.current = classOrFactory();
+	useEffect(() => {
+		const instance = instanceRef.current;
+		mountedRef.current = true;
+		if (isInitializable(instance)) instance.init();
+		return () => {
+			mountedRef.current = false;
+			setTimeout(() => {
+				if (!mountedRef.current) instance.dispose();
+			}, 0);
+		};
+	}, deps ?? []);
+	if (isSubscribable(instanceRef.current)) return [useInstance(instanceRef.current), instanceRef.current];
+	if (isSubscribeOnly(instanceRef.current)) {
+		useSubscribeOnly(instanceRef.current);
+		return instanceRef.current;
+	}
+	return instanceRef.current;
 }
-export {
-  useLocal
-};
-//# sourceMappingURL=use-local.js.map
+//#endregion
+export { useLocal };
+
+//# sourceMappingURL=use-local.js.map

package/dist/react/use-local.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-local.js","sources":["../../src/react/use-local.ts"],"sourcesContent":["import { useRef, useEffect } from 'react';\nimport type { DependencyList } from 'react';\nimport type { Subscribable, Disposable } from '../types';\nimport { isSubscribable, isSubscribeOnly, isInitializable } from './guards';\nimport { useInstance } from './use-instance';\nimport { useSubscribeOnly } from './use-subscribe-only';\nimport type { StateOf } from './types';\n\nfunction depsChanged(prev: DependencyList | undefined, next: DependencyList): boolean {\n  if (prev === undefined) return false;\n  if (prev.length !== next.length) return true;\n  for (let i = 0; i < prev.length; i++) {\n    if (!Object.is(prev[i], next[i])) return true;\n  }\n  return false;\n}\n\n// ── With deps (class + initialState + deps) ────────────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<any> & Disposable>(\n  Class: new (initialState: StateOf<T>) => T,\n  initialState: StateOf<T>,\n  deps: DependencyList,\n): [StateOf<T>, T];\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T,\n  deps: DependencyList,\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(\n  factory: () => T,\n  deps: DependencyList,\n): T;\n\n// ── Without deps (existing overloads, unchanged) ───────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<\n  T extends Subscribable<S> & Disposable,\n  S = StateOf<T>,\n  Args extends unknown[] = unknown[]\n>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable, Args extends unknown[] = unknown[]>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): T;\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(factory: () => T): T;\n\n// ── Implementation ─────────────────────────────────────────────────\n\nexport function useLocal<T extends Disposable, S = StateOf<T>>(\n  classOrFactory: (new (...args: unknown[]) => T) | (() => T),\n  ...rest: unknown[]\n): [S, T] | T {\n  // ── Detect deps: last arg is an array → treat as deps ──\n  let args: unknown[];\n  let deps: DependencyList | undefined;\n\n  if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {\n    deps = rest[rest.length - 1] as DependencyList;\n    args = rest.slice(0, -1);\n  } else {\n    args = rest;\n    deps = undefined;\n  }\n\n  const instanceRef = useRef<T | null>(null);\n  const mountedRef = useRef(false);\n  const prevDepsRef = useRef<DependencyList | undefined>(undefined);\n\n  // ── Render phase: dep-change detection ──\n  if (deps !== undefined && depsChanged(prevDepsRef.current, deps)) {\n    instanceRef.current?.dispose();\n    instanceRef.current = null;\n  }\n  if (deps !== undefined) {\n    prevDepsRef.current = deps;\n  }\n\n  // ── Create instance if needed ──\n  if (!instanceRef.current || instanceRef.current.disposed) {\n    const isClass =\n      typeof classOrFactory === 'function' &&\n      classOrFactory.prototype &&\n      classOrFactory.prototype.constructor === classOrFactory;\n\n    if (isClass) {\n      instanceRef.current = new (classOrFactory as new (...a: unknown[]) => T)(...args);\n    } else {\n      instanceRef.current = (classOrFactory as () => T)();\n    }\n  }\n\n  // ── Effect: init + deferred cleanup ──\n  useEffect(() => {\n    const instance = instanceRef.current!; // capture for cleanup closure\n    mountedRef.current = true;\n    if (isInitializable(instance)) {\n      instance.init();\n    }\n    return () => {\n      mountedRef.current = false;\n      setTimeout(() => {\n        if (!mountedRef.current) {\n          instance.dispose();\n        }\n      }, 0);\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps ?? []);\n\n  // ── Subscribe to state if Subscribable ──\n  if (isSubscribable(instanceRef.current)) {\n    const state = useInstance(instanceRef.current as unknown as Subscribable<S>);\n    return [state, instanceRef.current];\n  }\n\n  // ── Subscribe for re-renders if subscribe-only (e.g., Trackable) ──\n  if (isSubscribeOnly(instanceRef.current)) {\n    useSubscribeOnly(instanceRef.current);\n    return instanceRef.current;\n  }\n\n  return instanceRef.current;\n}\n"],"names":[],"mappings":";;;;AAQA,SAAS,YAAY,MAAkC,MAA+B;AACpF,MAAI,SAAS,OAAW,QAAO;AAC/B,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AACxC,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAI,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,EAAG,QAAO;AAAA,EAC3C;AACA,SAAO;AACT;AA2EO,SAAS,SACd,mBACG,MACS;AAEZ,MAAI;AACJ,MAAI;AAEJ,MAAI,KAAK,SAAS,KAAK,MAAM,QAAQ,KAAK,KAAK,SAAS,CAAC,CAAC,GAAG;AAC3D,WAAO,KAAK,KAAK,SAAS,CAAC;AAC3B,WAAO,KAAK,MAAM,GAAG,EAAE;AAAA,EACzB,OAAO;AACL,WAAO;AACP,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,OAAiB,IAAI;AACzC,QAAM,aAAa,OAAO,KAAK;AAC/B,QAAM,cAAc,OAAmC,MAAS;AAGhE,MAAI,SAAS,UAAa,YAAY,YAAY,SAAS,IAAI,GAAG;AAChE,gBAAY,SAAS,QAAA;AACrB,gBAAY,UAAU;AAAA,EACxB;AACA,MAAI,SAAS,QAAW;AACtB,gBAAY,UAAU;AAAA,EACxB;AAGA,MAAI,CAAC,YAAY,WAAW,YAAY,QAAQ,UAAU;AACxD,UAAM,UACJ,OAAO,mBAAmB,cAC1B,eAAe,aACf,eAAe,UAAU,gBAAgB;AAE3C,QAAI,SAAS;AACX,kBAAY,UAAU,IAAK,eAA8C,GAAG,IAAI;AAAA,IAClF,OAAO;AACL,kBAAY,UAAW,eAAA;AAAA,IACzB;AAAA,EACF;AAGA,YAAU,MAAM;AACd,UAAM,WAAW,YAAY;AAC7B,eAAW,UAAU;AACrB,QAAI,gBAAgB,QAAQ,GAAG;AAC7B,eAAS,KAAA;AAAA,IACX;AACA,WAAO,MAAM;AACX,iBAAW,UAAU;AACrB,iBAAW,MAAM;AACf,YAAI,CAAC,WAAW,SAAS;AACvB,mBAAS,QAAA;AAAA,QACX;AAAA,MACF,GAAG,CAAC;AAAA,IACN;AAAA,EAEF,GAAG,QAAQ,EAAE;AAGb,MAAI,eAAe,YAAY,OAAO,GAAG;AACvC,UAAM,QAAQ,YAAY,YAAY,OAAqC;AAC3E,WAAO,CAAC,OAAO,YAAY,OAAO;AAAA,EACpC;AAGA,MAAI,gBAAgB,YAAY,OAAO,GAAG;AACxC,qBAAiB,YAAY,OAAO;AACpC,WAAO,YAAY;AAAA,EACrB;AAEA,SAAO,YAAY;AACrB;"}
+{"version":3,"file":"use-local.js","names":[],"sources":["../../src/react/use-local.ts"],"sourcesContent":["import { useRef, useEffect } from 'react';\nimport type { DependencyList } from 'react';\nimport type { Subscribable, Disposable } from '../types';\nimport { isSubscribable, isSubscribeOnly, isInitializable } from './guards';\nimport { useInstance } from './use-instance';\nimport { useSubscribeOnly } from './use-subscribe-only';\nimport type { StateOf } from './types';\n\nfunction depsChanged(prev: DependencyList | undefined, next: DependencyList): boolean {\n  if (prev === undefined) return false;\n  if (prev.length !== next.length) return true;\n  for (let i = 0; i < prev.length; i++) {\n    if (!Object.is(prev[i], next[i])) return true;\n  }\n  return false;\n}\n\n// ── With deps (class + initialState + deps) ────────────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<any> & Disposable>(\n  Class: new (initialState: StateOf<T>) => T,\n  initialState: StateOf<T>,\n  deps: DependencyList,\n): [StateOf<T>, T];\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T,\n  deps: DependencyList,\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Disposes and recreates when deps change.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(\n  factory: () => T,\n  deps: DependencyList,\n): T;\n\n// ── Without deps (existing overloads, unchanged) ───────────────────\n\n/**\n * Create component-scoped Subscribable instance, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<\n  T extends Subscribable<S> & Disposable,\n  S = StateOf<T>,\n  Args extends unknown[] = unknown[]\n>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable, Args extends unknown[] = unknown[]>(\n  Class: new (...args: Args) => T,\n  ...args: Args\n): T;\n\n/**\n * Create component-scoped Subscribable instance via factory, auto-disposed on unmount.\n * Returns [state, instance] tuple.\n */\nexport function useLocal<T extends Subscribable<S> & Disposable, S = StateOf<T>>(\n  factory: () => T\n): [S, T];\n\n/**\n * Create component-scoped Disposable instance via factory (non-Subscribable), auto-disposed on unmount.\n * Returns the instance directly.\n */\nexport function useLocal<T extends Disposable>(factory: () => T): T;\n\n// ── Implementation ─────────────────────────────────────────────────\n\nexport function useLocal<T extends Disposable, S = StateOf<T>>(\n  classOrFactory: (new (...args: unknown[]) => T) | (() => T),\n  ...rest: unknown[]\n): [S, T] | T {\n  // ── Detect deps: last arg is an array → treat as deps ──\n  let args: unknown[];\n  let deps: DependencyList | undefined;\n\n  if (rest.length > 0 && Array.isArray(rest[rest.length - 1])) {\n    deps = rest[rest.length - 1] as DependencyList;\n    args = rest.slice(0, -1);\n  } else {\n    args = rest;\n    deps = undefined;\n  }\n\n  const instanceRef = useRef<T | null>(null);\n  const mountedRef = useRef(false);\n  const prevDepsRef = useRef<DependencyList | undefined>(undefined);\n\n  // ── Render phase: dep-change detection ──\n  if (deps !== undefined && depsChanged(prevDepsRef.current, deps)) {\n    instanceRef.current?.dispose();\n    instanceRef.current = null;\n  }\n  if (deps !== undefined) {\n    prevDepsRef.current = deps;\n  }\n\n  // ── Create instance if needed ──\n  if (!instanceRef.current || instanceRef.current.disposed) {\n    const isClass =\n      typeof classOrFactory === 'function' &&\n      classOrFactory.prototype &&\n      classOrFactory.prototype.constructor === classOrFactory;\n\n    if (isClass) {\n      instanceRef.current = new (classOrFactory as new (...a: unknown[]) => T)(...args);\n    } else {\n      instanceRef.current = (classOrFactory as () => T)();\n    }\n  }\n\n  // ── Effect: init + deferred cleanup ──\n  useEffect(() => {\n    const instance = instanceRef.current!; // capture for cleanup closure\n    mountedRef.current = true;\n    if (isInitializable(instance)) {\n      instance.init();\n    }\n    return () => {\n      mountedRef.current = false;\n      setTimeout(() => {\n        if (!mountedRef.current) {\n          instance.dispose();\n        }\n      }, 0);\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps ?? []);\n\n  // ── Subscribe to state if Subscribable ──\n  if (isSubscribable(instanceRef.current)) {\n    const state = useInstance(instanceRef.current as unknown as Subscribable<S>);\n    return [state, instanceRef.current];\n  }\n\n  // ── Subscribe for re-renders if subscribe-only (e.g., Trackable) ──\n  if (isSubscribeOnly(instanceRef.current)) {\n    useSubscribeOnly(instanceRef.current);\n    return instanceRef.current;\n  }\n\n  return instanceRef.current;\n}\n"],"mappings":";;;;;AAQA,SAAS,YAAY,MAAkC,MAA+B;AACpF,KAAI,SAAS,KAAA,EAAW,QAAO;AAC/B,KAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AACxC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC/B,KAAI,CAAC,OAAO,GAAG,KAAK,IAAI,KAAK,GAAG,CAAE,QAAO;AAE3C,QAAO;;AA4ET,SAAgB,SACd,gBACA,GAAG,MACS;CAEZ,IAAI;CACJ,IAAI;AAEJ,KAAI,KAAK,SAAS,KAAK,MAAM,QAAQ,KAAK,KAAK,SAAS,GAAG,EAAE;AAC3D,SAAO,KAAK,KAAK,SAAS;AAC1B,SAAO,KAAK,MAAM,GAAG,GAAG;QACnB;AACL,SAAO;AACP,SAAO,KAAA;;CAGT,MAAM,cAAc,OAAiB,KAAK;CAC1C,MAAM,aAAa,OAAO,MAAM;CAChC,MAAM,cAAc,OAAmC,KAAA,EAAU;AAGjE,KAAI,SAAS,KAAA,KAAa,YAAY,YAAY,SAAS,KAAK,EAAE;AAChE,cAAY,SAAS,SAAS;AAC9B,cAAY,UAAU;;AAExB,KAAI,SAAS,KAAA,EACX,aAAY,UAAU;AAIxB,KAAI,CAAC,YAAY,WAAW,YAAY,QAAQ,SAM9C,KAJE,OAAO,mBAAmB,cAC1B,eAAe,aACf,eAAe,UAAU,gBAAgB,eAGzC,aAAY,UAAU,IAAK,eAA8C,GAAG,KAAK;KAEjF,aAAY,UAAW,gBAA4B;AAKvD,iBAAgB;EACd,MAAM,WAAW,YAAY;AAC7B,aAAW,UAAU;AACrB,MAAI,gBAAgB,SAAS,CAC3B,UAAS,MAAM;AAEjB,eAAa;AACX,cAAW,UAAU;AACrB,oBAAiB;AACf,QAAI,CAAC,WAAW,QACd,UAAS,SAAS;MAEnB,EAAE;;IAGN,QAAQ,EAAE,CAAC;AAGd,KAAI,eAAe,YAAY,QAAQ,CAErC,QAAO,CADO,YAAY,YAAY,QAAsC,EAC7D,YAAY,QAAQ;AAIrC,KAAI,gBAAgB,YAAY,QAAQ,EAAE;AACxC,mBAAiB,YAAY,QAAQ;AACrC,SAAO,YAAY;;AAGrB,QAAO,YAAY"}

package/dist/react/use-model.cjs

@@ -1,107 +1,93 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const react = require("react");
-const guards = require("./guards.cjs");
+const require_guards = require("./guards.cjs");
+let react = require("react");
+//#region src/react/use-model.ts
+/**
+* Bind to a component-scoped Model with validation and dirty state exposed.
+*/
 function useModel(factory) {
-  const modelRef = react.useRef(null);
-  const mountedRef = react.useRef(false);
-  if (!modelRef.current || modelRef.current.disposed) {
-    modelRef.current = factory();
-  }
-  const modelSubscribe = react.useCallback(
-    (onStoreChange) => modelRef.current.subscribe(onStoreChange),
-    []
-  );
-  const modelSnapshot = react.useCallback(
-    () => modelRef.current.state,
-    []
-  );
-  react.useSyncExternalStore(modelSubscribe, modelSnapshot, modelSnapshot);
-  react.useEffect(() => {
-    mountedRef.current = true;
-    if (guards.isInitializable(modelRef.current)) {
-      modelRef.current.init();
-    }
-    return () => {
-      mountedRef.current = false;
-      setTimeout(() => {
-        if (!mountedRef.current) {
-          modelRef.current?.dispose();
-        }
-      }, 0);
-    };
-  }, []);
-  const model = modelRef.current;
-  return {
-    state: model.state,
-    errors: model.errors,
-    valid: model.valid,
-    dirty: model.dirty,
-    model
-  };
+	const modelRef = (0, react.useRef)(null);
+	const mountedRef = (0, react.useRef)(false);
+	if (!modelRef.current || modelRef.current.disposed) modelRef.current = factory();
+	const modelSubscribe = (0, react.useCallback)((onStoreChange) => modelRef.current.subscribe(onStoreChange), []);
+	const modelSnapshot = (0, react.useCallback)(() => modelRef.current.state, []);
+	(0, react.useSyncExternalStore)(modelSubscribe, modelSnapshot, modelSnapshot);
+	(0, react.useEffect)(() => {
+		mountedRef.current = true;
+		if (require_guards.isInitializable(modelRef.current)) modelRef.current.init();
+		return () => {
+			mountedRef.current = false;
+			setTimeout(() => {
+				if (!mountedRef.current) modelRef.current?.dispose();
+			}, 0);
+		};
+	}, []);
+	const model = modelRef.current;
+	return {
+		state: model.state,
+		errors: model.errors,
+		valid: model.valid,
+		dirty: model.dirty,
+		model
+	};
 }
+/**
+* Create a component-scoped Model with lifecycle management (init + dispose)
+* but NO state subscription. The parent component never re-renders from
+* model state changes.
+*
+* Designed for the per-field isolation pattern: parent creates the model
+* via `useModelRef`, children subscribe to individual fields via `useField`.
+*/
 function useModelRef(factory) {
-  const modelRef = react.useRef(null);
-  const mountedRef = react.useRef(false);
-  if (!modelRef.current || modelRef.current.disposed) {
-    modelRef.current = factory();
-  }
-  react.useEffect(() => {
-    mountedRef.current = true;
-    if (guards.isInitializable(modelRef.current)) {
-      modelRef.current.init();
-    }
-    return () => {
-      mountedRef.current = false;
-      setTimeout(() => {
-        if (!mountedRef.current) {
-          modelRef.current?.dispose();
-        }
-      }, 0);
-    };
-  }, []);
-  return modelRef.current;
+	const modelRef = (0, react.useRef)(null);
+	const mountedRef = (0, react.useRef)(false);
+	if (!modelRef.current || modelRef.current.disposed) modelRef.current = factory();
+	(0, react.useEffect)(() => {
+		mountedRef.current = true;
+		if (require_guards.isInitializable(modelRef.current)) modelRef.current.init();
+		return () => {
+			mountedRef.current = false;
+			setTimeout(() => {
+				if (!mountedRef.current) modelRef.current?.dispose();
+			}, 0);
+		};
+	}, []);
+	return modelRef.current;
 }
+/**
+* Bind to a single Model field with surgical re-renders.
+*/
 function useField(model, field) {
-  const getSnapshot = react.useCallback(() => {
-    return {
-      value: model.state[field],
-      error: model.errors[field]
-    };
-  }, [model, field]);
-  const cachedRef = react.useRef(getSnapshot());
-  const subscribe = react.useCallback(
-    (onStoreChange) => {
-      return model.subscribe(() => {
-        const next = getSnapshot();
-        const current = cachedRef.current;
-        if (next.value !== current.value || next.error !== current.error) {
-          cachedRef.current = next;
-          onStoreChange();
-        }
-      });
-    },
-    [model, getSnapshot]
-  );
-  const snapshot = react.useSyncExternalStore(
-    subscribe,
-    () => cachedRef.current,
-    () => cachedRef.current
-  );
-  const set = react.useCallback(
-    (value) => {
-      const partial = { [field]: value };
-      model.set(partial);
-    },
-    [model, field]
-  );
-  return {
-    value: snapshot.value,
-    error: snapshot.error,
-    set
-  };
+	const getSnapshot = (0, react.useCallback)(() => {
+		return {
+			value: model.state[field],
+			error: model.errors[field]
+		};
+	}, [model, field]);
+	const cachedRef = (0, react.useRef)(getSnapshot());
+	const snapshot = (0, react.useSyncExternalStore)((0, react.useCallback)((onStoreChange) => {
+		return model.subscribe(() => {
+			const next = getSnapshot();
+			const current = cachedRef.current;
+			if (next.value !== current.value || next.error !== current.error) {
+				cachedRef.current = next;
+				onStoreChange();
+			}
+		});
+	}, [model, getSnapshot]), () => cachedRef.current, () => cachedRef.current);
+	const set = (0, react.useCallback)((value) => {
+		const partial = { [field]: value };
+		model.set(partial);
+	}, [model, field]);
+	return {
+		value: snapshot.value,
+		error: snapshot.error,
+		set
+	};
 }
+//#endregion
 exports.useField = useField;
 exports.useModel = useModel;
 exports.useModelRef = useModelRef;
-//# sourceMappingURL=use-model.cjs.map
+
+//# sourceMappingURL=use-model.cjs.map