@codebelt/classy-store 0.0.1 → 0.1.0

package/dist/index.mjs

@@ -1,10 +1,8 @@
-import { a as subscribe, c as shallowEqual, i as store, n as getInternal, o as PROXYABLE, r as getVersion, t as snapshot } from "./snapshot-fVu34Cr6.mjs";
-import { createProxy, isChanged } from "proxy-compare";
-import { useCallback, useRef, useSyncExternalStore } from "react";
+import { a as subscribe, i as getVersion, n as createClassyStore, o as PROXYABLE, t as snapshot } from "./snapshot-P0QPV1ER.mjs";
 
-//#region src/collections.ts
+//#region src/collections/collections.ts
 /**
-* A Map-like class backed by a plain array so `store()` can proxy mutations.
+* A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.
 *
 * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations
 * like `.set()` would be invisible to the store. `ReactiveMap` solves this by
@@ -12,7 +10,7 @@ import { useCallback, useRef, useSyncExternalStore } from "react";
 *
 * Usage:
 * ```ts
-* const myStore = store({ users: reactiveMap<string, User>() });
+* const myStore = createClassyStore({ users: reactiveMap<string, User>() });
 * myStore.users.set('id1', { name: 'Alice' }); // reactive
 * ```
 */
@@ -81,7 +79,7 @@ var ReactiveMap = class {
 	}
 };
 /**
-* A Set-like class backed by a plain array so `store()` can proxy mutations.
+* A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.
 *
 * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations
 * like `.add()` would be invisible to the store. `ReactiveSet` solves this by
@@ -89,7 +87,7 @@ var ReactiveMap = class {
 *
 * Usage:
 * ```ts
-* const myStore = store({ tags: reactiveSet<string>(['urgent']) });
+* const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });
 * myStore.tags.add('bug'); // reactive
 * ```
 */
@@ -150,7 +148,7 @@ var ReactiveSet = class {
 };
 /**
 * Creates a reactive Map-like collection backed by a plain array.
-* Wrap the parent object with `store()` for full reactivity.
+* Wrap the parent object with `createClassyStore()` for full reactivity.
 *
 * @param initial - Optional iterable of `[key, value]` pairs.
 */
@@ -159,7 +157,7 @@ function reactiveMap(initial) {
 }
 /**
 * Creates a reactive Set-like collection backed by a plain array.
-* Wrap the parent object with `store()` for full reactivity.
+* Wrap the parent object with `createClassyStore()` for full reactivity.
 *
 * @param initial - Optional iterable of values.
 */
@@ -168,59 +166,30 @@ function reactiveSet(initial) {
 }
 
 //#endregion
-//#region src/useStore.ts
-function useStore(proxyStore, selector, isEqual) {
-	getInternal(proxyStore);
-	const subscribe$1 = useCallback((onStoreChange) => subscribe(proxyStore, onStoreChange), [proxyStore]);
-	const snapRef = useRef(void 0);
-	const resultRef = useRef(void 0);
-	const affected = useRef(/* @__PURE__ */ new WeakMap()).current;
-	const proxyCache = useRef(/* @__PURE__ */ new WeakMap()).current;
-	const prevSnapRef = useRef(void 0);
-	const wrappedRef = useRef(void 0);
-	const getSnapshot = () => selector ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) : getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef);
-	return useSyncExternalStore(subscribe$1, getSnapshot, getSnapshot);
-}
+//#region src/utils/equality/equality.ts
 /**
-* `getSnapshot` implementation for selector mode.
-*
-* Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise
-* runs the selector against the new snapshot and compares the result to the
-* previous one via `Object.is` (or a custom `isEqual`). Returns the previous
-* result reference when equal, preventing unnecessary React re-renders.
+* Shallow-equal comparison for objects and arrays.
+* Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
 *
-* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+* - Primitives compared with `Object.is`.
+* - Arrays: length + element-wise `Object.is`.
+* - Objects: key count + value-wise `Object.is`.
 */
-function getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) {
-	const nextSnap = snapshot(proxyStore);
-	if (snapRef.current === nextSnap && resultRef.current !== void 0) return resultRef.current;
-	const nextResult = selector(nextSnap);
-	snapRef.current = nextSnap;
-	if (resultRef.current !== void 0 && (isEqual ? isEqual(resultRef.current, nextResult) : Object.is(resultRef.current, nextResult))) return resultRef.current;
-	resultRef.current = nextResult;
-	return nextResult;
-}
-/**
-* `getSnapshot` implementation for auto-tracked (selectorless) mode.
-*
-* Uses `proxy-compare` to diff only the properties the component actually read.
-* If the snapshot reference is the same, returns the cached tracking proxy.
-* If the snapshot changed but no tracked property differs (`isChanged` returns
-* false), also returns the cached proxy -- avoiding re-render. Only when a
-* relevant property changed does it create a new `createProxy` wrapper.
-*
-* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
-*/
-function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef) {
-	const nextSnap = snapshot(proxyStore);
-	if (prevSnapRef.current === nextSnap) return wrappedRef.current;
-	if (prevSnapRef.current !== void 0 && !isChanged(prevSnapRef.current, nextSnap, affected)) return wrappedRef.current;
-	prevSnapRef.current = nextSnap;
-	const wrapped = createProxy(nextSnap, affected, proxyCache);
-	wrappedRef.current = wrapped;
-	return wrapped;
+function shallowEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+		return true;
+	}
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) if (!Object.hasOwn(b, key) || !Object.is(a[key], b[key])) return false;
+	return true;
 }
 
 //#endregion
-export { getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe, useStore };
+export { createClassyStore, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, subscribe };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["subscribe","coreSubscribe"],"sources":["../src/collections.ts","../src/useStore.ts"],"sourcesContent":["import {PROXYABLE} from './utils';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from './core';\nimport {snapshot} from './snapshot';\nimport type {Snapshot} from './types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = createClassyStore({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `createClassyStore()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `createClassyStore()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/react/react.cjs

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_snapshot = require('../snapshot-BKVFJLuo.cjs');
+let proxy_compare = require("proxy-compare");
+let react = require("react");
+
+//#region src/react/react.ts
+function useStore(proxyStore, selector, isEqual) {
+	require_snapshot.getInternal(proxyStore);
+	const subscribe$1 = (0, react.useCallback)((onStoreChange) => require_snapshot.subscribe(proxyStore, onStoreChange), [proxyStore]);
+	const snapRef = (0, react.useRef)(void 0);
+	const resultRef = (0, react.useRef)(void 0);
+	const affected = (0, react.useRef)(/* @__PURE__ */ new WeakMap()).current;
+	const proxyCache = (0, react.useRef)(/* @__PURE__ */ new WeakMap()).current;
+	const prevSnapRef = (0, react.useRef)(void 0);
+	const wrappedRef = (0, react.useRef)(void 0);
+	const getSnapshot = () => selector ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) : getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef);
+	return (0, react.useSyncExternalStore)(subscribe$1, getSnapshot, getSnapshot);
+}
+/**
+* `getSnapshot` implementation for selector mode.
+*
+* Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise
+* runs the selector against the new snapshot and compares the result to the
+* previous one via `Object.is` (or a custom `isEqual`). Returns the previous
+* result reference when equal, preventing unnecessary React re-renders.
+*
+* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+*/
+function getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) {
+	const nextSnap = require_snapshot.snapshot(proxyStore);
+	if (snapRef.current === nextSnap && resultRef.current !== void 0) return resultRef.current;
+	const nextResult = selector(nextSnap);
+	snapRef.current = nextSnap;
+	if (resultRef.current !== void 0 && (isEqual ? isEqual(resultRef.current, nextResult) : Object.is(resultRef.current, nextResult))) return resultRef.current;
+	resultRef.current = nextResult;
+	return nextResult;
+}
+/**
+* `getSnapshot` implementation for auto-tracked (selectorless) mode.
+*
+* Uses `proxy-compare` to diff only the properties the component actually read.
+* If the snapshot reference is the same, returns the cached tracking proxy.
+* If the snapshot changed but no tracked property differs (`isChanged` returns
+* false), also returns the cached proxy -- avoiding re-render. Only when a
+* relevant property changed does it create a new `createProxy` wrapper.
+*
+* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+*/
+function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef) {
+	const nextSnap = require_snapshot.snapshot(proxyStore);
+	if (prevSnapRef.current === nextSnap) return wrappedRef.current;
+	if (prevSnapRef.current !== void 0 && !(0, proxy_compare.isChanged)(prevSnapRef.current, nextSnap, affected)) return wrappedRef.current;
+	prevSnapRef.current = nextSnap;
+	const wrapped = (0, proxy_compare.createProxy)(nextSnap, affected, proxyCache);
+	wrappedRef.current = wrapped;
+	return wrapped;
+}
+
+//#endregion
+exports.useStore = useStore;
+//# sourceMappingURL=react.cjs.map

package/dist/react/react.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.cjs","names":["subscribe","coreSubscribe","snapshot"],"sources":["../../src/react/react.ts"],"sourcesContent":["import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from '../core/core';\nimport {snapshot} from '../snapshot/snapshot';\nimport type {Snapshot} from '../types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":";;;;;;AAoCA,SAAgB,SACd,YACA,UACA,SACiB;AAEjB,8BAAY,WAAW;CAGvB,MAAMA,sCACH,kBAA8BC,2BAAc,YAAY,cAAc,EACvE,CAAC,WAAW,CACb;CAKD,MAAM,4BAA0C,OAAU;CAC1D,MAAM,8BAAkC,OAAU;CAGlD,MAAM,6CAAkB,IAAI,SAA0B,CAAC,CAAC;CACxD,MAAM,+CAAoB,IAAI,SAA0B,CAAC,CAAC;CAC1D,MAAM,gCAA8C,OAAU;CAC9D,MAAM,+BAA6C,OAAU;CAI7D,MAAM,oBACJ,WACI,oBAAoB,YAAY,SAAS,WAAW,UAAU,QAAQ,GACtE,qBACE,YACA,UACA,YACA,aACA,WACD;AAEP,wCAA4BD,aAAW,aAAa,YAAY;;;;;;;;;;;;AAelE,SAAS,oBACP,YACA,SACA,WACA,UACA,SACG;CACH,MAAM,WAAWE,0BAAS,WAAW;AAGrC,KAAI,QAAQ,YAAY,YAAY,UAAU,YAAY,OACxD,QAAO,UAAU;CAGnB,MAAM,aAAa,SAAS,SAAS;AACrC,SAAQ,UAAU;AAGlB,KACE,UAAU,YAAY,WACrB,UACG,QAAQ,UAAU,SAAS,WAAW,GACtC,OAAO,GAAG,UAAU,SAAS,WAAW,EAE5C,QAAO,UAAU;AAGnB,WAAU,UAAU;AACpB,QAAO;;;;;;;;;;;;;AAgBT,SAAS,qBACP,YACA,UACA,YACA,aACA,YACa;CACb,MAAM,WAAWA,0BAAS,WAAW;AAGrC,KAAI,YAAY,YAAY,SAC1B,QAAO,WAAW;AAIpB,KACE,YAAY,YAAY,UACxB,8BAAW,YAAY,SAAS,UAAU,SAAS,CAGnD,QAAO,WAAW;AAIpB,aAAY,UAAU;CACtB,MAAM,yCAAsB,UAAU,UAAU,WAAW;AAC3D,YAAW,UAAU;AACrB,QAAO"}

package/dist/react/react.d.cts

@@ -0,0 +1,26 @@
+import { t as Snapshot } from "../types-B6RZUB86.cjs";
+
+//#region src/react/react.d.ts
+/**
+ * Subscribe to a store proxy with an explicit selector.
+ *
+ * Re-renders only when the selected value changes (compared via `Object.is`
+ * by default, or a custom `isEqual`).
+ *
+ * @param proxyStore - A reactive proxy created by `store()`.
+ * @param selector  - Picks data from the immutable snapshot.
+ * @param isEqual   - Optional custom equality function (default: `Object.is`).
+ */
+declare function useStore<T extends object, S>(proxyStore: T, selector: (snap: Snapshot<T>) => S, isEqual?: (a: S, b: S) => boolean): S;
+/**
+ * Subscribe to a store proxy **without** a selector (auto-tracked mode).
+ *
+ * Returns a `proxy-compare` tracking proxy over the immutable snapshot.
+ * The component only re-renders when a property it actually read changes.
+ *
+ * @param proxyStore - A reactive proxy created by `store()`.
+ */
+declare function useStore<T extends object>(proxyStore: T): Snapshot<T>;
+//#endregion
+export { useStore };
+//# sourceMappingURL=react.d.cts.map

package/dist/react/react.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.cts","names":[],"sources":["../../src/react/react.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAgB,QAAA,qBAAA,CACd,UAAA,EAAY,CAAA,EACZ,QAAA,GAAW,IAAA,EAAM,QAAA,CAAS,CAAA,MAAO,CAAA,EACjC,OAAA,IAAW,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACnB,CAAA;;;;;;;;;iBAUa,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA"}

package/dist/react/react.d.mts

@@ -0,0 +1,26 @@
+import { t as Snapshot } from "../types-vWYkF3tH.mjs";
+
+//#region src/react/react.d.ts
+/**
+ * Subscribe to a store proxy with an explicit selector.
+ *
+ * Re-renders only when the selected value changes (compared via `Object.is`
+ * by default, or a custom `isEqual`).
+ *
+ * @param proxyStore - A reactive proxy created by `store()`.
+ * @param selector  - Picks data from the immutable snapshot.
+ * @param isEqual   - Optional custom equality function (default: `Object.is`).
+ */
+declare function useStore<T extends object, S>(proxyStore: T, selector: (snap: Snapshot<T>) => S, isEqual?: (a: S, b: S) => boolean): S;
+/**
+ * Subscribe to a store proxy **without** a selector (auto-tracked mode).
+ *
+ * Returns a `proxy-compare` tracking proxy over the immutable snapshot.
+ * The component only re-renders when a property it actually read changes.
+ *
+ * @param proxyStore - A reactive proxy created by `store()`.
+ */
+declare function useStore<T extends object>(proxyStore: T): Snapshot<T>;
+//#endregion
+export { useStore };
+//# sourceMappingURL=react.d.mts.map

package/dist/react/react.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.mts","names":[],"sources":["../../src/react/react.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAgB,QAAA,qBAAA,CACd,UAAA,EAAY,CAAA,EACZ,QAAA,GAAW,IAAA,EAAM,QAAA,CAAS,CAAA,MAAO,CAAA,EACjC,OAAA,IAAW,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACnB,CAAA;;;;;;;;;iBAUa,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA"}

package/dist/react/react.mjs

@@ -0,0 +1,60 @@
+import { a as subscribe, r as getInternal, t as snapshot } from "../snapshot-P0QPV1ER.mjs";
+import { createProxy, isChanged } from "proxy-compare";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+
+//#region src/react/react.ts
+function useStore(proxyStore, selector, isEqual) {
+	getInternal(proxyStore);
+	const subscribe$1 = useCallback((onStoreChange) => subscribe(proxyStore, onStoreChange), [proxyStore]);
+	const snapRef = useRef(void 0);
+	const resultRef = useRef(void 0);
+	const affected = useRef(/* @__PURE__ */ new WeakMap()).current;
+	const proxyCache = useRef(/* @__PURE__ */ new WeakMap()).current;
+	const prevSnapRef = useRef(void 0);
+	const wrappedRef = useRef(void 0);
+	const getSnapshot = () => selector ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) : getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef);
+	return useSyncExternalStore(subscribe$1, getSnapshot, getSnapshot);
+}
+/**
+* `getSnapshot` implementation for selector mode.
+*
+* Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise
+* runs the selector against the new snapshot and compares the result to the
+* previous one via `Object.is` (or a custom `isEqual`). Returns the previous
+* result reference when equal, preventing unnecessary React re-renders.
+*
+* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+*/
+function getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) {
+	const nextSnap = snapshot(proxyStore);
+	if (snapRef.current === nextSnap && resultRef.current !== void 0) return resultRef.current;
+	const nextResult = selector(nextSnap);
+	snapRef.current = nextSnap;
+	if (resultRef.current !== void 0 && (isEqual ? isEqual(resultRef.current, nextResult) : Object.is(resultRef.current, nextResult))) return resultRef.current;
+	resultRef.current = nextResult;
+	return nextResult;
+}
+/**
+* `getSnapshot` implementation for auto-tracked (selectorless) mode.
+*
+* Uses `proxy-compare` to diff only the properties the component actually read.
+* If the snapshot reference is the same, returns the cached tracking proxy.
+* If the snapshot changed but no tracked property differs (`isChanged` returns
+* false), also returns the cached proxy -- avoiding re-render. Only when a
+* relevant property changed does it create a new `createProxy` wrapper.
+*
+* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+*/
+function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef) {
+	const nextSnap = snapshot(proxyStore);
+	if (prevSnapRef.current === nextSnap) return wrappedRef.current;
+	if (prevSnapRef.current !== void 0 && !isChanged(prevSnapRef.current, nextSnap, affected)) return wrappedRef.current;
+	prevSnapRef.current = nextSnap;
+	const wrapped = createProxy(nextSnap, affected, proxyCache);
+	wrappedRef.current = wrapped;
+	return wrapped;
+}
+
+//#endregion
+export { useStore };
+//# sourceMappingURL=react.mjs.map

package/dist/react/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":["subscribe","coreSubscribe"],"sources":["../../src/react/react.ts"],"sourcesContent":["import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from '../core/core';\nimport {snapshot} from '../snapshot/snapshot';\nimport type {Snapshot} from '../types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":";;;;;AAoCA,SAAgB,SACd,YACA,UACA,SACiB;AAEjB,aAAY,WAAW;CAGvB,MAAMA,cAAY,aACf,kBAA8BC,UAAc,YAAY,cAAc,EACvE,CAAC,WAAW,CACb;CAKD,MAAM,UAAU,OAAgC,OAAU;CAC1D,MAAM,YAAY,OAAsB,OAAU;CAGlD,MAAM,WAAW,uBAAO,IAAI,SAA0B,CAAC,CAAC;CACxD,MAAM,aAAa,uBAAO,IAAI,SAA0B,CAAC,CAAC;CAC1D,MAAM,cAAc,OAAgC,OAAU;CAC9D,MAAM,aAAa,OAAgC,OAAU;CAI7D,MAAM,oBACJ,WACI,oBAAoB,YAAY,SAAS,WAAW,UAAU,QAAQ,GACtE,qBACE,YACA,UACA,YACA,aACA,WACD;AAEP,QAAO,qBAAqBD,aAAW,aAAa,YAAY;;;;;;;;;;;;AAelE,SAAS,oBACP,YACA,SACA,WACA,UACA,SACG;CACH,MAAM,WAAW,SAAS,WAAW;AAGrC,KAAI,QAAQ,YAAY,YAAY,UAAU,YAAY,OACxD,QAAO,UAAU;CAGnB,MAAM,aAAa,SAAS,SAAS;AACrC,SAAQ,UAAU;AAGlB,KACE,UAAU,YAAY,WACrB,UACG,QAAQ,UAAU,SAAS,WAAW,GACtC,OAAO,GAAG,UAAU,SAAS,WAAW,EAE5C,QAAO,UAAU;AAGnB,WAAU,UAAU;AACpB,QAAO;;;;;;;;;;;;;AAgBT,SAAS,qBACP,YACA,UACA,YACA,aACA,YACa;CACb,MAAM,WAAW,SAAS,WAAW;AAGrC,KAAI,YAAY,YAAY,SAC1B,QAAO,WAAW;AAIpB,KACE,YAAY,YAAY,UACxB,CAAC,UAAU,YAAY,SAAS,UAAU,SAAS,CAGnD,QAAO,WAAW;AAIpB,aAAY,UAAU;CACtB,MAAM,UAAU,YAAY,UAAU,UAAU,WAAW;AAC3D,YAAW,UAAU;AACrB,QAAO"}

package/dist/{snapshot-TbHIUjvP.cjs → snapshot-BKVFJLuo.cjs}

@@ -1,5 +1,5 @@
 
-//#region src/utils.ts
+//#region src/utils/internal/internal.ts
 const objectProto = Object.getPrototypeOf({});
 /**
 * Symbol that class instances can use to opt-in to deep proxying.
@@ -47,31 +47,9 @@ function findGetterDescriptor(target, prop) {
 		proto = Object.getPrototypeOf(proto);
 	}
 }
-/**
-* Shallow-equal comparison for objects and arrays.
-* Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
-*
-* - Primitives compared with `Object.is`.
-* - Arrays: length + element-wise `Object.is`.
-* - Objects: key count + value-wise `Object.is`.
-*/
-function shallowEqual(a, b) {
-	if (Object.is(a, b)) return true;
-	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
-	if (Array.isArray(a) && Array.isArray(b)) {
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
-		return true;
-	}
-	const keysA = Object.keys(a);
-	const keysB = Object.keys(b);
-	if (keysA.length !== keysB.length) return false;
-	for (const key of keysA) if (!Object.hasOwn(b, key) || !Object.is(a[key], b[key])) return false;
-	return true;
-}
 
 //#endregion
-//#region src/core.ts
+//#region src/core/core.ts
 /** Global version counter shared across all stores. */
 let globalVersion = 0;
 /** Maps every store proxy → its internal bookkeeping. */
@@ -148,7 +126,7 @@ function evaluateComputed(internal, prop, getterFn, receiver) {
 }
 /**
 * Retrieve the internal bookkeeping for a store proxy.
-* Throws if the object was not created with `store()`.
+* Throws if the object was not created with `createClassyStore()`.
 */
 function getInternal(proxy) {
 	const internal = internalsMap.get(proxy);
@@ -270,15 +248,20 @@ function createStoreProxy(target, parent) {
 *
 * @param instance - A class instance (or plain object) to make reactive.
 * @returns The same object wrapped in a reactive Proxy.
+*
+* @example
+* ```ts
+* const myStore = createClassyStore(new MyClass());
+* ```
 */
-function store(instance) {
+function createClassyStore(instance) {
 	return createStoreProxy(instance, null);
 }
 /**
 * Subscribe to store changes. The callback fires once per batched mutation
 * (coalesced via `queueMicrotask`), not once per individual property write.
 *
-* @param proxy - A reactive proxy created by `store()`.
+* @param proxy - A reactive proxy created by `createClassyStore()`.
 * @param callback - Invoked after each batched mutation.
 * @returns An unsubscribe function. Call it to stop receiving notifications.
 */
@@ -301,12 +284,12 @@ function getVersion(proxy) {
 }
 
 //#endregion
-//#region src/snapshot.ts
+//#region src/snapshot/snapshot.ts
 /**
 * Version-stamped snapshot cache for tracked (proxied) sub-trees.
 * Key: raw target object → [version, frozen snapshot].
 */
-const snapCache = /* @__PURE__ */ new WeakMap();
+const snapshotCache = /* @__PURE__ */ new WeakMap();
 /**
 * Cache for untracked nested objects (never accessed through the proxy).
 * Key: the raw mutable object → frozen deep clone.
@@ -325,7 +308,7 @@ const snapshotGetterCache = /* @__PURE__ */ new WeakMap();
 * boundaries: if `this.items` hasn't changed between snapshots (same
 * reference via structural sharing), the getter returns the same result.
 */
-const crossSnapMemo = /* @__PURE__ */ new WeakMap();
+const crossSnapshotMemo = /* @__PURE__ */ new WeakMap();
 /**
 * Run a getter against the snapshot with dependency tracking.
 *
@@ -359,7 +342,7 @@ function computeWithTracking(snap, getterFn) {
 * guarantees stable refs for unchanged sub-trees). For getter properties
 * this invokes the getter (which is itself memoized), then compares.
 */
-function areMemoedDepsValid(currentSnap, deps) {
+function areMemoizedDepsValid(currentSnap, deps) {
 	for (const dep of deps) {
 		const currentValue = Reflect.get(currentSnap, dep.prop, currentSnap);
 		if (!Object.is(currentValue, dep.value)) return false;
@@ -378,16 +361,16 @@ function areMemoedDepsValid(currentSnap, deps) {
 function evaluateSnapshotGetter(currentSnap, target, key, getterFn) {
 	const perSnapCache = snapshotGetterCache.get(currentSnap);
 	if (perSnapCache?.has(key)) return perSnapCache.get(key);
-	let memoMap = crossSnapMemo.get(target);
+	let memoMap = crossSnapshotMemo.get(target);
 	const prev = memoMap?.get(key);
 	let result;
-	if (prev && areMemoedDepsValid(currentSnap, prev.deps)) result = prev.result;
+	if (prev && areMemoizedDepsValid(currentSnap, prev.deps)) result = prev.result;
 	else {
 		const computation = computeWithTracking(currentSnap, getterFn);
 		result = computation.result;
 		if (!memoMap) {
 			memoMap = /* @__PURE__ */ new Map();
-			crossSnapMemo.set(target, memoMap);
+			crossSnapshotMemo.set(target, memoMap);
 		}
 		memoMap.set(key, {
 			deps: computation.deps,
@@ -501,7 +484,7 @@ function installMemoizedGetters(snap, target) {
 * are installed as lazy-memoizing accessors via `installMemoizedGetters`.
 */
 function createSnapshotRecursive(target, internal) {
-	const cached = snapCache.get(target);
+	const cached = snapshotCache.get(target);
 	if (cached && cached[0] === internal.version) return cached[1];
 	let snap;
 	if (Array.isArray(target)) {
@@ -518,7 +501,7 @@ function createSnapshotRecursive(target, internal) {
 		installMemoizedGetters(snap, target);
 	}
 	Object.freeze(snap);
-	snapCache.set(target, [internal.version, snap]);
+	snapshotCache.set(target, [internal.version, snap]);
 	return snap;
 }
 /**
@@ -534,7 +517,7 @@ function createSnapshotRecursive(target, internal) {
 * per snapshot and their results are stable across snapshots when dependencies
 * haven't changed (cross-snapshot memoization).
 *
-* @param proxyStore - A reactive proxy created by `store()`.
+* @param proxyStore - A reactive proxy created by `createClassyStore()`.
 * @returns A deeply frozen plain-JS object (Snapshot<T>).
 */
 function snapshot(proxyStore) {
@@ -549,6 +532,12 @@ Object.defineProperty(exports, 'PROXYABLE', {
     return PROXYABLE;
   }
 });
+Object.defineProperty(exports, 'createClassyStore', {
+  enumerable: true,
+  get: function () {
+    return createClassyStore;
+  }
+});
 Object.defineProperty(exports, 'findGetterDescriptor', {
   enumerable: true,
   get: function () {
@@ -567,28 +556,16 @@ Object.defineProperty(exports, 'getVersion', {
     return getVersion;
   }
 });
-Object.defineProperty(exports, 'shallowEqual', {
-  enumerable: true,
-  get: function () {
-    return shallowEqual;
-  }
-});
 Object.defineProperty(exports, 'snapshot', {
   enumerable: true,
   get: function () {
     return snapshot;
   }
 });
-Object.defineProperty(exports, 'store', {
-  enumerable: true,
-  get: function () {
-    return store;
-  }
-});
 Object.defineProperty(exports, 'subscribe', {
   enumerable: true,
   get: function () {
     return subscribe;
   }
 });
-//# sourceMappingURL=snapshot-TbHIUjvP.cjs.map
+//# sourceMappingURL=snapshot-BKVFJLuo.cjs.map