juststore 1.2.0 → 1.2.1

package/dist/src/node.js

@@ -1,374 +0,0 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: <T is not known at this point> */
-/** biome-ignore-all lint/suspicious/noAssignInExpressions: <getter methods are cached> */
-import { getStableKeys } from "./impl";
-export { createNode, createRootNode };
-/**
- * Creates the root proxy node for dynamic path access.
- *
- * This is an internal function that wraps a store API in a Proxy, enabling
- * property-chain syntax like `store.user.profile.name.use()`.
- *
- * @param storeApi - The underlying store API with path-based methods
- * @param initialPath - Starting path segment (default: empty string for root)
- * @returns A proxy that intercepts property access and returns nested proxies or state methods
- */
-function createRootNode(storeApi, initialPath = "") {
-    const proxyCache = new Map();
-    return createNode(storeApi, initialPath, proxyCache);
-}
-/**
- * Creates a proxy node for a specific path in the store.
- *
- * The proxy intercepts property access to provide state methods (use, set, value, etc.)
- * and recursively creates child proxies for nested paths. Supports derived state
- * transformations via the `from` and `to` parameters.
- *
- * @param storeApi - The underlying store API
- * @param path - Dot-separated path to this node (e.g., "user.profile.name")
- * @param cache - Shared cache to avoid recreating proxies for the same path
- * @param extensions - Optional custom getters/setters (used by form handling)
- * @param from - Transform function applied when reading values (for derived state)
- * @param to - Transform function applied when writing values (for derived state)
- * @returns A proxy implementing the State interface for the given path
- */
-function createNode(storeApi, path, cache, extensions, from = unchanged, to = unchanged) {
-    const isDerived = from !== unchanged || to !== unchanged;
-    const fieldName = path.split(".").pop();
-    if (!isDerived && cache.has(path)) {
-        return cache.get(path);
-    }
-    const proxy = new Proxy({}, {
-        get(_target, prop) {
-            if (prop === "field") {
-                return fieldName;
-            }
-            if (prop === "use") {
-                return (_target._use ??= () => from(storeApi.use(path)));
-            }
-            if (prop === "useDebounce") {
-                return (_target._useDebounce ??= (delay) => from(storeApi.useDebounce(path, delay)));
-            }
-            if (prop === "useState") {
-                return (_target._useState ??= () => {
-                    const value = storeApi.use(path);
-                    return [from(value), (next) => storeApi.set(path, to(next))];
-                });
-            }
-            if (prop === "value") {
-                return from(storeApi.value(path));
-            }
-            if (prop === "set") {
-                return (_target._set ??= (value, skipUpdate) => storeApi.set(path, to(value), skipUpdate));
-            }
-            if (prop === "reset") {
-                return (_target._reset ??= () => storeApi.reset(path));
-            }
-            if (prop === "subscribe") {
-                return (_target._subscribe ??= (listener) => storeApi.subscribe(path, (value) => listener(to(value))));
-            }
-            if (prop === "useCompute") {
-                return (_target._useCompute ??= (fn) => {
-                    return storeApi.useCompute(path, (value) => fn(from(value)));
-                });
-            }
-            if (prop === "derived") {
-                if (isDerived) {
-                    throw new Error(`Derived method cannot be called on a derived node: ${path}`);
-                }
-                return (_target._derived ??= ({ from, to, }) => createNode(storeApi, path, cache, extensions, from, to));
-            }
-            if (prop === "notify") {
-                return (_target._notify ??= () => storeApi.notify(path));
-            }
-            if (prop === "ensureArray") {
-                return (_target._ensureArray ??= () => {
-                    const cacheKey = `${path}.__juststore_ensureArray`;
-                    if (!isDerived && cache.has(cacheKey)) {
-                        return cache.get(cacheKey);
-                    }
-                    const node = createNode(storeApi, path, cache, extensions, (value) => ensureArray(value, from), unchanged);
-                    if (!isDerived) {
-                        cache.set(cacheKey, node);
-                    }
-                    return node;
-                });
-            }
-            if (prop === "ensureObject") {
-                return (_target._ensureObject ??= () => {
-                    const cacheKey = `${path}.__juststore_ensureObject`;
-                    if (!isDerived && cache.has(cacheKey)) {
-                        return cache.get(cacheKey);
-                    }
-                    const node = createNode(storeApi, path, cache, extensions, (value) => ensureObject(value, from), to);
-                    if (!isDerived) {
-                        cache.set(cacheKey, node);
-                    }
-                    return node;
-                });
-            }
-            if (prop === "withDefault") {
-                return (_target._withDefault ??= (defaultValue) => createNode(storeApi, path, cache, extensions, (value) => withDefault(value, defaultValue, from), to));
-            }
-            if (isObjectMethod(prop)) {
-                const derivedValue = from(storeApi.value(path));
-                if (derivedValue !== undefined && typeof derivedValue !== "object") {
-                    throw new Error(`Expected object at path ${path}, got ${typeof derivedValue}`);
-                }
-                if (prop === "rename") {
-                    return (_target._rename ??= (oldKey, newKey) => storeApi.rename(path, oldKey, newKey));
-                }
-                if (prop === "keys") {
-                    const cacheKey = `${path}.__juststore_keys`;
-                    if (!isDerived && cache.has(cacheKey)) {
-                        return cache.get(cacheKey);
-                    }
-                    const keysNode = createKeysNode(storeApi, path, (value) => ensureObject(value, from));
-                    if (!isDerived) {
-                        cache.set(cacheKey, keysNode);
-                    }
-                    return keysNode;
-                }
-            }
-            if (isArrayMethod(prop)) {
-                if (prop === "useLength") {
-                    return (_target._useLength ??= () => storeApi.useCompute(path, (value) => {
-                        const arr = from(value);
-                        return Array.isArray(arr) ? arr.length : 0;
-                    }));
-                }
-                const derivedValue = from(storeApi.value(path));
-                if (derivedValue !== undefined && !Array.isArray(derivedValue)) {
-                    throw new Error(`Expected array at path ${path}, got ${typeof derivedValue}`);
-                }
-                const currentArray = derivedValue ? [...derivedValue] : [];
-                if (prop === "at") {
-                    return (_target._at ??= (index) => {
-                        const nextPath = path ? `${path}.${index}` : String(index);
-                        return createNode(storeApi, nextPath, cache, extensions);
-                    });
-                }
-                if (prop === "length") {
-                    return currentArray.length;
-                }
-                // Array mutation methods
-                if (prop === "push") {
-                    return (_target._push ??= (...items) => {
-                        // We need to fetch the current array at call time, not bind time
-                        const arr = from(storeApi.value(path)) ?? [];
-                        const newArray = [...arr, ...items];
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray.length;
-                    });
-                }
-                if (prop === "pop") {
-                    return (_target._pop ??= () => {
-                        const arr = from(storeApi.value(path)) ?? [];
-                        if (arr.length === 0)
-                            return undefined;
-                        const newArray = arr.slice(0, -1);
-                        const poppedItem = arr[arr.length - 1];
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return poppedItem;
-                    });
-                }
-                if (prop === "shift") {
-                    return (_target._shift ??= () => {
-                        const arr = from(storeApi.value(path)) ?? [];
-                        if (arr.length === 0)
-                            return undefined;
-                        const newArray = arr.slice(1);
-                        const shiftedItem = arr[0];
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return shiftedItem;
-                    });
-                }
-                if (prop === "unshift") {
-                    return (_target._unshift ??= (...items) => {
-                        const arr = from(storeApi.value(path)) ?? [];
-                        const newArray = [...items, ...arr];
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray.length;
-                    });
-                }
-                if (prop === "splice") {
-                    return (_target._splice ??= (start, deleteCount, ...items) => {
-                        const arr = from(storeApi.value(path)) ?? [];
-                        const newArray = [...arr];
-                        const deletedItems = newArray.splice(start, deleteCount ?? 0, ...items);
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return deletedItems;
-                    });
-                }
-                if (prop === "reverse") {
-                    return (_target._reverse ??= () => {
-                        const arr = from(storeApi.value(path));
-                        if (!Array.isArray(arr))
-                            return [];
-                        const newArray = [...arr];
-                        newArray.reverse();
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray;
-                    });
-                }
-                if (prop === "sort") {
-                    return (_target._sort ??= (compareFn) => {
-                        const arr = from(storeApi.value(path));
-                        if (!Array.isArray(arr))
-                            return [];
-                        const newArray = [...arr];
-                        newArray.sort(compareFn);
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray;
-                    });
-                }
-                if (prop === "fill") {
-                    return (_target._fill ??= (value, start, end) => {
-                        const arr = from(storeApi.value(path));
-                        if (!Array.isArray(arr))
-                            return [];
-                        const newArray = [...arr];
-                        newArray.fill(value, start, end);
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray;
-                    });
-                }
-                if (prop === "copyWithin") {
-                    return (_target._copyWithin ??= (target, start, end) => {
-                        const arr = from(storeApi.value(path));
-                        if (!Array.isArray(arr))
-                            return [];
-                        const newArray = [...arr];
-                        newArray.copyWithin(target, start, end);
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray;
-                    });
-                }
-                if (prop === "sortedInsert") {
-                    return (_target._sortedInsert ??= (cmp, ...items) => {
-                        const arr = from(storeApi.value(path));
-                        if (!Array.isArray(arr))
-                            return [];
-                        if (typeof cmp !== "function")
-                            return arr.length;
-                        const newArray = [...arr];
-                        for (const item of items) {
-                            let left = 0;
-                            let right = newArray.length;
-                            // Binary search to find insertion point
-                            while (left < right) {
-                                const mid = (left + right) >>> 1;
-                                if (cmp(newArray[mid], item) <= 0) {
-                                    left = mid + 1;
-                                }
-                                else {
-                                    right = mid;
-                                }
-                            }
-                            // Insert at the found position
-                            newArray.splice(left, 0, item);
-                        }
-                        storeApi.set(path, isDerived ? newArray.map(to) : newArray);
-                        return newArray.length;
-                    });
-                }
-            }
-            if (extensions?.[prop]?.get) {
-                return extensions[prop]?.get(path);
-            }
-            if (typeof prop === "string" || typeof prop === "number") {
-                const nextPath = path ? `${path}.${prop}` : String(prop);
-                return createNode(storeApi, nextPath, cache, extensions);
-            }
-            return undefined;
-        },
-        set(_target, prop, value) {
-            if (extensions?.[prop]?.set) {
-                return extensions[prop]?.set(path, value);
-            }
-            if (typeof prop === "string" || typeof prop === "number") {
-                const nextPath = path ? `${path}.${prop}` : String(prop);
-                storeApi.set(nextPath, to(value));
-                return true;
-            }
-            return false;
-        },
-    });
-    if (!isDerived) {
-        cache.set(path, proxy);
-    }
-    return proxy;
-}
-function isArrayMethod(prop) {
-    return (prop === "at" ||
-        prop === "length" ||
-        prop === "useLength" ||
-        prop === "push" ||
-        prop === "pop" ||
-        prop === "shift" ||
-        prop === "unshift" ||
-        prop === "splice" ||
-        prop === "reverse" ||
-        prop === "sort" ||
-        prop === "fill" ||
-        prop === "copyWithin" ||
-        prop === "sortedInsert");
-}
-function isObjectMethod(prop) {
-    return prop === "rename" || prop === "keys";
-}
-function unchanged(value) {
-    return value;
-}
-const EMPTY_ARRAY = [];
-const EMPTY_OBJECT = {};
-function createKeysNode(storeApi, path, getObjectValue) {
-    const signalPath = path ? `${path}.__juststore_keys` : "__juststore_keys";
-    const computeKeys = () => {
-        return getStableKeys(getObjectValue(storeApi.value(path)));
-    };
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (prop === "use") {
-                return (_target._use ??= () => storeApi.useCompute(signalPath, computeKeys));
-            }
-            if (prop === "value")
-                return computeKeys();
-            if (prop === "useCompute") {
-                return (_target._useCompute ??= (fn) => {
-                    return storeApi.useCompute(signalPath, () => fn(computeKeys()));
-                });
-            }
-            if (prop === "Render") {
-                return (_target._Render ??= ({ children, }) => children(storeApi.useCompute(signalPath, computeKeys), () => { }));
-            }
-            if (prop === "Show") {
-                return (_target._Show ??= ({ children, on, }) => {
-                    const show = storeApi.useCompute(signalPath, () => on(computeKeys()), [on]);
-                    return show ? children : null;
-                });
-            }
-            return undefined;
-        },
-    });
-}
-function ensureArray(value, from) {
-    if (value === undefined || value === null)
-        return EMPTY_ARRAY;
-    const array = from(value);
-    if (Array.isArray(array))
-        return array;
-    return EMPTY_ARRAY;
-}
-function ensureObject(value, from) {
-    if (value === undefined || value === null)
-        return EMPTY_OBJECT;
-    const obj = from(value);
-    if (obj && typeof obj === "object" && !Array.isArray(obj))
-        return obj;
-    return EMPTY_OBJECT;
-}
-function withDefault(value, defaultValue, from) {
-    if (value === undefined || value === null)
-        return defaultValue; // defaultValue should've already matched the type
-    return from(value);
-}

package/dist/src/path.d.ts

@@ -1,136 +0,0 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: <Intended> */
-export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-export type BrowserNativeObject = Date | FileList | File;
-/**
- * Type which given a tuple type returns its own keys, i.e. only its indices.
- * @typeParam T - tuple type
- * @example
- * ```
- * TupleKeys<[number, string]> = '0' | '1'
- * ```
- */
-export type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
-/**
- * Helper type for recursively constructing paths through a type.
- * This actually constructs the strings and recurses into nested
- * object types.
- *
- * See {@link ArrayPath}
- */
-type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
-/**
- * Checks whether the type is any
- * See {@link https://stackoverflow.com/a/49928360/3406963}
- * @typeParam T - type which may be any
- * ```
- * IsAny<any> = true
- * IsAny<string> = false
- * ```
- */
-export type IsAny<T> = 0 extends 1 & T ? true : false;
-/**
- * Checks whether T1 can be exactly (mutually) assigned to T2
- * @typeParam T1 - type to check
- * @typeParam T2 - type to check against
- * ```
- * IsEqual<string, string> = true
- * IsEqual<'foo', 'foo'> = true
- * IsEqual<string, number> = false
- * IsEqual<string, number> = false
- * IsEqual<string, 'foo'> = false
- * IsEqual<'foo', string> = false
- * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
- * ```
- */
-export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
-/**
- * Helper function to break apart T1 and check if any are equal to T2
- *
- * See {@link IsEqual}
- */
-type AnyIsEqual<T1, T2> = T1 extends T2 ? IsEqual<T1, T2> extends true ? true : never : never;
-/**
- * Type to query whether an array type T is a tuple type.
- * @typeParam T - type which may be an array or tuple
- * @example
- * ```
- * IsTuple<[number]> = true
- * IsTuple<number[]> = false
- * ```
- */
-export type IsTuple<T extends ReadonlyArray<any>> = number extends T["length"] ? false : true;
-/**
- * Type which can be used to index an array or tuple type.
- */
-export type ArrayKey = number;
-/**
- * Helper type for recursively constructing paths through a type.
- * This obscures the internal type param TraversedTypes from exported contract.
- *
- * See {@link ArrayPath}
- */
-type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
-}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
-    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
-}[keyof T];
-/**
- * Type which eagerly collects all paths through a type which point to an array
- * type.
- * @typeParam T - type which should be introspected.
- * @example
- * ```
- * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
- * ```
- */
-export type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
-/**
- * Type which eagerly collects all paths through a type
- * @typeParam T - type which should be introspected
- * @example
- * ```
- * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
- * ```
- */
-export type Path<T> = T extends any ? PathInternal<T> : never;
-/**
- * See {@link Path}
- */
-export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
-/**
- * Helper type for recursively constructing paths through a type.
- * This actually constructs the strings and recurses into nested
- * object types.
- *
- * See {@link Path}
- */
-type PathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${PathInternal<V, TraversedTypes | V>}`;
-/**
- * Helper type for recursively constructing paths through a type.
- * This obscures the internal type param TraversedTypes from exported contract.
- *
- * See {@link Path}
- */
-type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes>;
-}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
-    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
-}[keyof T];
-/**
- * Type to evaluate the type which the given path points to.
- * @typeParam T - deeply nested type which is indexed by the path
- * @typeParam P - path into the deeply nested type
- * @example
- * ```
- * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
- * PathValue<[number, string], '1'> = string
- * ```
- */
-export type PathValue<T, P extends Path<T> | ArrayPath<T>> = PathValueImpl<T, P>;
-type PathValueImpl<T, P extends string> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? undefined extends T[K] ? PathValueImpl<T[K], R> | undefined : PathValueImpl<T[K], R> : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValueImpl<V, R> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : undefined extends T ? undefined : never : never : never;
-/**
- * See {@link PathValue}
- */
-export type FieldPathValue<TFieldValues extends FieldValues, TFieldPath extends FieldPath<TFieldValues>> = Exclude<PathValue<TFieldValues, TFieldPath>, Function>;
-export type FieldValues = Record<string, any>;
-export {};

package/dist/src/path.js

@@ -1,26 +0,0 @@
-/*
-Copied and modified from https://github.com/react-hook-form/react-hook-form
-
-MIT License
-
-Copyright (c) 2019-present Beier(Bill) Luo
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-export {};

package/dist/src/root.d.ts

@@ -1,23 +0,0 @@
-import type { FieldValues } from "./path";
-import type { StoreRoot } from "./types";
-export { createStoreRoot, type StoreOptions };
-/**
- * Configuration options for store creation.
- */
-type StoreOptions = {
-    /** When true, the store only uses memory and does not persist to localStorage */
-    memoryOnly?: boolean;
-};
-/**
- * Creates the core store API with path-based methods.
- *
- * Uses a Proxy pattern for lazy initialization and caching of methods,
- * similar to the atom implementation. Methods are only created when first accessed
- * and then cached for subsequent use.
- *
- * @param namespace - Unique identifier for the store
- * @param defaultValue - Initial state merged with any persisted data
- * @param options - Configuration options
- * @returns A proxy object providing both path-based and dynamic property access to the store
- */
-declare function createStoreRoot<T extends FieldValues>(namespace: string, defaultValue: T, options?: StoreOptions): StoreRoot<T>;

package/dist/src/root.js

@@ -1,81 +0,0 @@
-import { useCallback } from "react";
-import { getNestedValue, getSnapshot, isRecord, joinPath, notifyListeners, produce, rename, setLeaf, subscribe, useCompute, useDebounce, useObject, } from "./impl";
-import { createRootNode } from "./node";
-export { createStoreRoot };
-/**
- * Creates the core store API with path-based methods.
- *
- * Uses a Proxy pattern for lazy initialization and caching of methods,
- * similar to the atom implementation. Methods are only created when first accessed
- * and then cached for subsequent use.
- *
- * @param namespace - Unique identifier for the store
- * @param defaultValue - Initial state merged with any persisted data
- * @param options - Configuration options
- * @returns A proxy object providing both path-based and dynamic property access to the store
- */
-function createStoreRoot(namespace, defaultValue, options = {}) {
-    "use memo";
-    const memoryOnly = options?.memoryOnly ?? false;
-    // merge with default value and save in memory only
-    produce(namespace, mergeWithDefaults(defaultValue, getSnapshot(namespace, memoryOnly)), true, true);
-    const storeApi = {
-        state: (path) => createRootNode(storeApi, path),
-        use: (path) => useObject(namespace, path, memoryOnly),
-        useDebounce: (path, delay) => useDebounce(namespace, path, delay, memoryOnly),
-        set: (path, value, skipUpdate = false) => {
-            if (typeof value !== "function") {
-                return setLeaf(namespace, path, value, skipUpdate, memoryOnly);
-            }
-            const currentValue = storeApi.value(path);
-            const newValue = value(currentValue);
-            return setLeaf(namespace, path, newValue, skipUpdate, memoryOnly);
-        },
-        value: (path) => getSnapshot(joinPath(namespace, path), memoryOnly),
-        reset: (path) => {
-            return produce(joinPath(namespace, path), getNestedValue(defaultValue, path), false, memoryOnly);
-        },
-        rename: (path, oldKey, newKey) => rename(joinPath(namespace, path), oldKey, newKey, memoryOnly),
-        subscribe: (path, listener) => {
-            const fullPath = joinPath(namespace, path);
-            const unsubscribe = subscribe(fullPath, () => listener(getSnapshot(fullPath, memoryOnly)));
-            return unsubscribe;
-        },
-        useCompute: (path, fn, deps) => {
-            return useCompute(namespace, path, fn, deps, memoryOnly);
-        },
-        notify: (path) => {
-            const value = getNestedValue(getSnapshot(namespace, memoryOnly), path);
-            return notifyListeners(joinPath(namespace, path), value, value, {
-                skipRoot: true,
-                skipChildren: true,
-                forceNotify: true,
-            });
-        },
-        useState: (path) => {
-            const setValue = useCallback((value) => {
-                storeApi.set(path, value, false);
-            }, [path]);
-            return [
-                useObject(namespace, path, memoryOnly),
-                setValue,
-            ];
-        },
-    };
-    return storeApi;
-}
-function mergeWithDefaults(defaultValue, existingValue) {
-    if (existingValue === undefined) {
-        return defaultValue;
-    }
-    if (!isRecord(defaultValue) || !isRecord(existingValue)) {
-        return existingValue;
-    }
-    const defaults = defaultValue;
-    const existing = existingValue;
-    const merged = { ...existing };
-    for (const key of Object.keys(defaults)) {
-        merged[key] = mergeWithDefaults(defaults[key], existing[key]);
-    }
-    return merged;
-}

package/dist/src/stable_keys.d.ts

@@ -1,4 +0,0 @@
-export { getExternalKeyOrder, getStableKeys, setExternalKeyOrder };
-declare function getExternalKeyOrder(target: object): string[] | undefined;
-declare function setExternalKeyOrder(target: object, keys: string[]): void;
-declare function getStableKeys(value: unknown): string[];

package/dist/src/stable_keys.js

@@ -1,31 +0,0 @@
-import { isRecord } from "./impl";
-export { getExternalKeyOrder, getStableKeys, setExternalKeyOrder };
-const externalKeyOrder = new WeakMap();
-function getExternalKeyOrder(target) {
-    return externalKeyOrder.get(target);
-}
-function setExternalKeyOrder(target, keys) {
-    externalKeyOrder.set(target, keys);
-}
-function getStableKeys(value) {
-    if (!isRecord(value))
-        return [];
-    const target = value;
-    const existing = externalKeyOrder.get(target);
-    if (existing) {
-        const next = existing.filter((k) => Object.hasOwn(target, k));
-        const nextSet = new Set(next);
-        for (const k of Object.keys(target)) {
-            if (nextSet.has(k))
-                continue;
-            next.push(k);
-        }
-        if (next.length !== existing.length) {
-            setExternalKeyOrder(target, next);
-        }
-        return next;
-    }
-    const keys = Object.keys(target);
-    setExternalKeyOrder(target, keys);
-    return keys;
-}