juststore 0.4.2 → 0.4.4

package/dist/form.d.ts

@@ -1,5 +1,5 @@
 import type { FieldPath, FieldPathValue, FieldValues, IsEqual } from './path';
-import type { ArrayProxy, DerivedStateProps, IsNullable, MaybeNullable, ObjectMutationMethods, ValueState } from './types';
+import type { ArrayProxy, DerivedStateProps, IsNullable, MaybeNullable, ObjectMutationMethods, Prettify, ValueState } from './types';
 export { createForm, useForm, type CreateFormOptions, type DeepNonNullable, type FormArrayState, type FormObjectState, type FormState, type FormStore, type FormValueState };
 /**
  * Common form field methods available on every form state node.
@@ -13,7 +13,12 @@ type FormCommon = {
     setError: (error: string | undefined) => void;
 };
 type FormState<T> = IsEqual<T, unknown> extends true ? never : [NonNullable<T>] extends [readonly (infer U)[]] ? FormArrayState<U, IsNullable<T>> : [NonNullable<T>] extends [FieldValues] ? FormObjectState<NonNullable<T>, IsNullable<T>> : FormValueState<T>;
-interface FormValueState<T> extends Omit<ValueState<T>, 'withDefault' | 'derived'>, FormCommon {
+type FormReadOnlyState<T> = Prettify<Pick<FormValueState<Readonly<Required<T>>>, 'value' | 'use' | 'useCompute' | 'Render' | 'Show' | 'error' | 'setError'>>;
+interface FormValueState<T> extends Omit<ValueState<T>, 'ensureArray' | 'ensureObject' | 'withDefault' | 'derived'>, FormCommon {
+    /** Ensure the value is an array. */
+    ensureArray(): NonNullable<T> extends (infer U)[] ? FormArrayState<U> : never;
+    /** Ensure the value is an object. */
+    ensureObject(): NonNullable<T> extends FieldValues ? FormObjectState<NonNullable<T>> : never;
     /** Return a new state with a default value, and make the type non-nullable */
     withDefault(defaultValue: T): FormState<NonNullable<T>>;
     /** Virtual state derived from the current value.
@@ -30,10 +35,17 @@ interface FormValueState<T> extends Omit<ValueState<T>, 'withDefault' | 'derived
      */
     derived: <R>({ from, to }: DerivedStateProps<T, R>) => FormState<R>;
 }
-type FormArrayState<T, Nullable extends boolean = false, TT = MaybeNullable<T, Nullable>> = IsEqual<T, unknown> extends true ? never : FormValueState<TT[]> & ArrayProxy<TT, FormState<TT>>;
-type FormObjectState<T extends FieldValues, Nullable extends boolean = false> = {
+type FormObjectProxy<T extends FieldValues> = {
+    /** Virtual state for the object's keys.
+     *
+     * This does NOT read from a real `keys` property on the stored object; it results in a stable array of keys.
+     */
+    readonly keys: FormReadOnlyState<FieldPath<T>[]>;
+} & {
     [K in keyof T]-?: FormState<T[K]>;
-} & FormValueState<MaybeNullable<T, Nullable>> & ObjectMutationMethods;
+};
+type FormArrayState<T, Nullable extends boolean = false> = IsEqual<T, unknown> extends true ? never : FormValueState<MaybeNullable<T[], Nullable>> & ArrayProxy<T, FormState<T>>;
+type FormObjectState<T extends FieldValues, Nullable extends boolean = false> = FormObjectProxy<T> & FormValueState<MaybeNullable<T, Nullable>> & ObjectMutationMethods;
 /** Type for nested objects with proxy methods */
 type DeepNonNullable<T> = [NonNullable<T>] extends [readonly (infer U)[]] ? U[] : [NonNullable<T>] extends [FieldValues] ? {
     [K in keyof NonNullable<T>]-?: DeepNonNullable<NonNullable<T>[K]>;

package/dist/impl.js

@@ -84,7 +84,7 @@ function getNamespace(key) {
 function joinPath(namespace, path) {
     if (!path)
         return namespace;
-    return namespace + '.' + path;
+    return `${namespace}.${path}`;
 }
 function joinChildKey(parent, child) {
     return parent ? `${parent}.${child}` : child;
@@ -93,16 +93,16 @@ function getKeyPrefixes(key) {
     const dot = key.indexOf('.');
     if (dot === -1)
         return [];
-    const parts = key.split('.');
-    if (parts.length <= 1)
+    const [first, ...parts] = key.split('.');
+    if (parts.length === 0)
         return [];
     const prefixes = [];
-    let current = parts[0];
-    for (let i = 1; i < parts.length - 1; i++) {
-        current += '.' + parts[i];
+    let current = first;
+    for (let i = 0; i < parts.length - 1; i++) {
+        current += `.${parts[i]}`;
         prefixes.push(current);
     }
-    prefixes.unshift(parts[0]);
+    prefixes.unshift(first);
     return prefixes;
 }
 /** Snapshot getter used by React's useSyncExternalStore. */
@@ -260,7 +260,7 @@ function setNestedValue(obj, path, value) {
     }
     else if (typeof current === 'object' && current !== null) {
         const currentObj = current;
-        const hadKey = Object.prototype.hasOwnProperty.call(currentObj, lastSegment);
+        const hadKey = Object.hasOwn(currentObj, lastSegment);
         if (value === undefined) {
             delete currentObj[lastSegment];
             if (hadKey) {
@@ -316,21 +316,29 @@ function notifyListeners(key, oldValue, newValue, { skipRoot = false, skipChildr
         // exact match only
         const listenerSet = listeners.get(key);
         if (listenerSet) {
-            listenerSet.forEach(listener => listener());
+            listenerSet.forEach(listener => {
+                listener();
+            });
         }
         return;
     }
     // Exact key match
     const exactSet = listeners.get(key);
     if (exactSet) {
-        exactSet.forEach(listener => listener());
+        exactSet.forEach(listener => {
+            listener();
+        });
     }
     // Ancestor keys match (including namespace root)
     if (!skipRoot) {
         const namespace = getNamespace(key);
-        const rootSet = listeners.get(namespace);
-        if (rootSet) {
-            rootSet.forEach(listener => listener());
+        if (namespace !== key) {
+            const rootSet = listeners.get(namespace);
+            if (rootSet) {
+                rootSet.forEach(listener => {
+                    listener();
+                });
+            }
         }
         // Also notify intermediate ancestors
         const prefixes = getKeyPrefixes(key);
@@ -339,7 +347,9 @@ function notifyListeners(key, oldValue, newValue, { skipRoot = false, skipChildr
                 continue; // Already handled
             const prefixSet = listeners.get(prefix);
             if (prefixSet) {
-                prefixSet.forEach(listener => listener());
+                prefixSet.forEach(listener => {
+                    listener();
+                });
             }
         }
     }
@@ -369,7 +379,9 @@ function notifyListeners(key, oldValue, newValue, { skipRoot = false, skipChildr
                 if (forceNotify || !isEqual(oldChildValue, newChildValue)) {
                     const childSet = listeners.get(childKey);
                     if (childSet) {
-                        childSet.forEach(listener => listener());
+                        childSet.forEach(listener => {
+                            listener();
+                        });
                     }
                 }
             }
@@ -395,13 +407,13 @@ function subscribe(key, listener) {
     if (!listeners.has(key)) {
         listeners.set(key, new Set());
     }
-    listeners.get(key).add(listener);
+    listeners.get(key)?.add(listener);
     const prefixes = getKeyPrefixes(key);
     for (const prefix of prefixes) {
         if (!descendantListenerKeysByPrefix.has(prefix)) {
             descendantListenerKeysByPrefix.set(prefix, new Set());
         }
-        descendantListenerKeysByPrefix.get(prefix).add(key);
+        descendantListenerKeysByPrefix.get(prefix)?.add(key);
     }
     return () => {
         const keyListeners = listeners.get(key);
@@ -471,12 +483,12 @@ function rename(path, oldKey, newKey, memoryOnly) {
     const obj = current;
     if (oldKey === newKey)
         return;
-    if (!Object.prototype.hasOwnProperty.call(obj, oldKey))
+    if (!Object.hasOwn(obj, oldKey))
         return;
     const keyOrder = getStableKeys(obj);
     const entries = [];
     for (const key of keyOrder) {
-        if (!Object.prototype.hasOwnProperty.call(obj, key))
+        if (!Object.hasOwn(obj, key))
             continue;
         if (key === oldKey) {
             entries.push([newKey, obj[oldKey]]);

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { createAtom, type Atom } from './atom';
+export { type Atom, createAtom } from './atom';
 export type * from './form';
 export { useForm } from './form';
-export { createMemoryStore, useMemoryStore, type MemoryStore } from './memory';
+export { isEqual } from './impl';
+export { createMemoryStore, type MemoryStore, useMemoryStore } from './memory';
 export { createMixedState } from './mixed_state';
 export type * from './path';
 export { createStore, type Store } from './store';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createAtom } from './atom';
 export { useForm } from './form';
+export { isEqual } from './impl';
 export { createMemoryStore, useMemoryStore } from './memory';
 export { createMixedState } from './mixed_state';
 export { createStore } from './store';

package/dist/mixed_state.js

@@ -1,3 +1,5 @@
+import { useCallback, useEffect, useState } from 'react';
+import { isEqual } from './impl';
 export { createMixedState };
 /**
  * Creates a mixed state that combines multiple states into a tuple.
@@ -22,7 +24,21 @@ function createMixedState(...states) {
         },
         use,
         useCompute(fn) {
-            return states.map(state => state.useCompute(value => fn(value)));
+            const [value, setValue] = useState(fn(this.value));
+            const recompute = useCallback(() => {
+                const newValue = fn(this.value);
+                // skip update if the new value is the same as the previous value
+                setValue(prev => (isEqual(prev, newValue) ? prev : newValue));
+            }, [fn]);
+            useEffect(() => {
+                const unsubscribeFns = states.map(state => state.subscribe(recompute));
+                return () => {
+                    unsubscribeFns.forEach(unsubscribe => {
+                        unsubscribe();
+                    });
+                };
+            });
+            return value;
         },
         Render({ children }) {
             const value = use();

package/dist/node.js

@@ -1,4 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/** 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 };
 /**
@@ -350,7 +351,6 @@ function createKeysNode(storeApi, path, getObjectValue) {
                 return (_target._Render ??= ({ children }) => children(storeApi.useCompute(signalPath, computeKeys), () => { }));
             }
             if (prop === 'Show') {
-                // eslint-disable-next-line react/display-name
                 return (_target._Show ??= ({ children, on }) => {
                     const show = storeApi.useCompute(signalPath, () => on(computeKeys()), [on]);
                     return show ? children : null;

package/dist/path.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: <Intended> */
 export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 export type BrowserNativeObject = Date | FileList | File;
 /**

package/dist/root.js

@@ -15,6 +15,7 @@ export { createStoreRoot };
  * @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, { ...defaultValue, ...(getSnapshot(namespace, memoryOnly) ?? {}) }, true, true);
@@ -45,16 +46,21 @@ function createStoreRoot(namespace, defaultValue, options = {}) {
             const fnRef = useRef(fn);
             fnRef.current = fn;
             const cacheRef = useRef(null);
+            const depsRef = useRef(deps);
+            // Invalidate cached compute when hook inputs change.
+            if (!isEqual(depsRef.current, deps)) {
+                depsRef.current = deps;
+                cacheRef.current = null;
+            }
+            const pathRef = useRef(fullPath);
+            if (pathRef.current !== fullPath) {
+                pathRef.current = fullPath;
+                cacheRef.current = null;
+            }
             const subscribeToPath = useCallback((onStoreChange) => subscribe(fullPath, onStoreChange), [fullPath]);
             const getComputedSnapshot = useCallback(() => {
-                if (cacheRef.current && cacheRef.current.path !== fullPath) {
-                    cacheRef.current = null;
-                }
-                if (cacheRef.current && !isEqual(cacheRef.current.deps, deps)) {
-                    cacheRef.current = null;
-                }
                 const storeValue = getSnapshot(fullPath, memoryOnly);
-                if (cacheRef.current && isEqual(cacheRef.current.storeValue, storeValue)) {
+                if (cacheRef.current && Object.is(cacheRef.current.storeValue, storeValue)) {
                     // same store value, return the same computed value
                     return cacheRef.current.computed;
                 }
@@ -66,9 +72,9 @@ function createStoreRoot(namespace, defaultValue, options = {}) {
                     cacheRef.current.storeValue = storeValue;
                     return cacheRef.current.computed;
                 }
-                cacheRef.current = { path: fullPath, storeValue, computed: computedNext, deps };
+                cacheRef.current = { storeValue, computed: computedNext };
                 return computedNext;
-            }, [fullPath, deps]);
+            }, [fullPath]);
             return useSyncExternalStore(subscribeToPath, getComputedSnapshot, getComputedSnapshot);
         },
         notify: (path) => {
@@ -80,31 +86,19 @@ function createStoreRoot(namespace, defaultValue, options = {}) {
             });
         },
         useState: (path) => {
-            const fullPath = joinPath(namespace, path);
             const setValue = useCallback((value) => {
-                if (typeof value === 'function') {
-                    const currentValue = getSnapshot(fullPath, memoryOnly);
-                    const newValue = value(currentValue);
-                    return setLeaf(namespace, path, newValue, false, memoryOnly);
-                }
-                return setLeaf(namespace, path, value, false, memoryOnly);
-            }, [fullPath, path]);
+                storeApi.set(path, value, false);
+            }, [path]);
             return [
                 useObject(namespace, path, memoryOnly),
                 setValue
             ];
         },
         Render: ({ path, children }) => {
-            const fullPath = joinPath(namespace, path);
             const value = useObject(namespace, path, memoryOnly);
             const update = useCallback((value) => {
-                if (typeof value === 'function') {
-                    const currentValue = getSnapshot(fullPath, memoryOnly);
-                    const newValue = value(currentValue);
-                    return setLeaf(namespace, path, newValue, false, memoryOnly);
-                }
-                return setLeaf(namespace, path, value, false, memoryOnly);
-            }, [fullPath, path]);
+                storeApi.set(path, value, false);
+            }, [path]);
             return children(value, update);
         },
         Show: ({ path, children, on }) => {

package/dist/stable_keys.js

@@ -13,7 +13,7 @@ function getStableKeys(value) {
     const target = value;
     const existing = externalKeyOrder.get(target);
     if (existing) {
-        const next = existing.filter(k => Object.prototype.hasOwnProperty.call(target, k));
+        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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juststore",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "A small, expressive, and type-safe state management library for React.",
   "type": "module",
   "main": "dist/index.js",
@@ -35,11 +35,11 @@
     "react hooks"
   ],
   "scripts": {
-    "build": "bun run tsc",
-    "typecheck": "bun run tsc --noEmit",
-    "lint": "bun run eslint src/**/*.ts",
-    "format": "bun run prettier --write src/**/*.ts",
-    "format:check": "bun run prettier --check src/**/*.ts",
+    "build": "bun --bun tsc",
+    "typecheck": "bun --bun tsc --noEmit",
+    "lint": "bun --bun biome",
+    "format": "bun --bun biome format --write",
+    "format:check": "bun --bun biome format",
     "prepublishOnly": "bun run build",
     "publish": "npm publish --access public",
     "prepare": "husky"
@@ -52,18 +52,11 @@
     "react-fast-compare": "^3.2.2"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
     "@eslint/js": "^9.39.2",
     "@types/node": "^24.10.4",
     "@types/react": "^19.2.7",
-    "@typescript-eslint/eslint-plugin": "^8.50.1",
-    "@typescript-eslint/parser": "^8.50.1",
-    "eslint": "^9.39.2",
-    "eslint-plugin-prettier": "^5.5.4",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^7.0.1",
-    "eslint-plugin-react-refresh": "^0.4.26",
     "husky": "^9.1.7",
-    "prettier": "^3.7.4",
     "react": "^19.2.3",
     "typescript": "^5.9.3"
   }