juststore 0.0.1

package/dist/form.d.ts

@@ -0,0 +1,34 @@
+import type { FieldPath, FieldPathValue, FieldValues } from './path';
+import type { ArrayProxy, State } from './types';
+export { useForm, type CreateFormOptions, type DeepNonNullable, type FormArrayProxy, type FormDeepProxy, type FormState, type FormStore };
+type FormCommon = {
+    /** Subscribe and read the error at path. Re-renders when the error changes. */
+    useError: () => string | undefined;
+    /** Read the error at path without subscribing. */
+    readonly error: string | undefined;
+    /** Set the error at path. */
+    setError: (error: string | undefined) => void;
+};
+type FormArrayProxy<T> = ArrayProxy<T> & FormCommon;
+type FormState<T> = State<T> & FormCommon;
+/** Type for nested objects with proxy methods */
+type FormDeepProxy<T> = NonNullable<T> extends readonly (infer U)[] ? FormArrayProxy<U> & FormState<T> : NonNullable<T> extends FieldValues ? {
+    [K in keyof NonNullable<T>]-?: NonNullable<NonNullable<T>[K]> extends object ? FormDeepProxy<NonNullable<T>[K]> : FormState<NonNullable<T>[K]>;
+} & FormState<T> : FormState<T>;
+/** 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]>;
+} : NonNullable<T>;
+type FormStore<T extends FieldValues> = FormDeepProxy<T> & {
+    clearErrors(): void;
+    handleSubmit(onSubmit: (values: T) => void): (e: React.FormEvent) => void;
+};
+type NoEmptyValidator = 'not-empty';
+type RegexValidator = RegExp;
+type FunctionValidator<T extends FieldValues> = (value: FieldPathValue<T, FieldPath<T>> | undefined, state: FormStore<T>) => string | undefined;
+type Validator<T extends FieldValues> = NoEmptyValidator | RegexValidator | FunctionValidator<T>;
+type FieldConfig<T extends FieldValues> = {
+    validate?: Validator<T>;
+};
+type CreateFormOptions<T extends FieldValues> = Partial<Record<FieldPath<T>, FieldConfig<T>>>;
+declare function useForm<T extends FieldValues>(defaultValue: T, fieldConfigs?: CreateFormOptions<T>): FormStore<T>;

package/dist/form.js

@@ -0,0 +1,111 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+'use client';
+import { pascalCase } from 'change-case';
+import { useId } from 'react';
+import { getSnapshot, produce } from './impl';
+import { createNode } from './node';
+import { createStoreRoot } from './root';
+export { useForm };
+function useForm(defaultValue, fieldConfigs = {}) {
+    const formId = useId();
+    const namespace = `form:${formId}`;
+    const errorNamespace = `errors.${namespace}`;
+    const storeApi = createStoreRoot(namespace, defaultValue, { memoryOnly: true });
+    const errorStore = createStoreRoot(errorNamespace, {}, { memoryOnly: true });
+    const formStore = {
+        clearErrors: () => produce(errorNamespace, undefined, false, true),
+        handleSubmit: (onSubmit) => (e) => {
+            e.preventDefault();
+            // disable submit if there are errors
+            if (Object.keys(getSnapshot(errorNamespace) ?? {}).length === 0) {
+                onSubmit(getSnapshot(namespace));
+            }
+        }
+    };
+    const store = new Proxy(storeApi, {
+        get(_target, prop) {
+            if (prop in formStore) {
+                return formStore[prop];
+            }
+            if (prop in storeApi) {
+                return storeApi[prop];
+            }
+            if (typeof prop === 'string') {
+                return createFormProxy(storeApi, errorStore, prop);
+            }
+            return undefined;
+        }
+    });
+    for (const entry of Object.entries(fieldConfigs)) {
+        const [path, config] = entry;
+        const validator = getValidator(path, config?.validate);
+        if (validator) {
+            storeApi.subscribe(path, (value) => {
+                const error = validator(value, store);
+                if (!error) {
+                    errorStore.reset(path);
+                }
+                else {
+                    errorStore.set(path, error);
+                }
+            });
+        }
+    }
+    return store;
+}
+const createFormProxy = (storeApi, errorStore, path) => {
+    const proxyCache = new Map();
+    const useError = () => errorStore.use(path);
+    const getError = () => errorStore.value(path);
+    const setError = (error) => {
+        errorStore.set(path, error);
+        return true;
+    };
+    return createNode(storeApi, path, proxyCache, {
+        useError: {
+            get: () => useError
+        },
+        error: {
+            get: getError
+        },
+        setError: {
+            get: () => setError
+        }
+    });
+};
+function getValidator(field, validator) {
+    if (!validator) {
+        return undefined;
+    }
+    if (validator === 'not-empty') {
+        return (value) => validateNoEmpty(field, value);
+    }
+    if (validator instanceof RegExp) {
+        return (value) => validateRegex(field, value, validator);
+    }
+    return validator;
+}
+function validateNoEmpty(field, value) {
+    if (!stringValue(value)) {
+        return `${pascalCase(field)} is required`;
+    }
+    return undefined;
+}
+function validateRegex(field, value, regex) {
+    if (!regex.test(stringValue(value))) {
+        return `${pascalCase(field)} is invalid`;
+    }
+    return undefined;
+}
+function stringValue(v) {
+    if (typeof v === 'string') {
+        return v;
+    }
+    if (typeof v === 'number') {
+        return String(v);
+    }
+    if (typeof v === 'boolean') {
+        return String(v);
+    }
+    return '';
+}

package/dist/impl.d.ts

@@ -0,0 +1,19 @@
+import type { FieldPath, FieldPathValue, FieldValues } from './path';
+export { getNestedValue, getSnapshot, joinPath, notifyListeners, produce, setLeaf, useDebounce, useObject, useSubscribe };
+declare function joinPath(namespace: string, path?: string): string;
+/** Get a nested value from an object/array using a dot-separated path. */
+declare function getNestedValue(obj: unknown, path: string): unknown;
+/** Notify exact, root, and affected child listeners for a given key change. */
+declare function notifyListeners(key: string, oldValue: unknown, newValue: unknown, skipRoot?: boolean, skipChildren?: boolean): void;
+/** Snapshot getter used by React's useSyncExternalStore. */
+declare function getSnapshot(key: string): unknown;
+/** Core mutation function that updates store and notifies listeners. */
+declare function produce(key: string, value: unknown, skipUpdate?: boolean, memoryOnly?: boolean): void;
+/** React hook: subscribe to and read a namespaced path value. */
+declare function useObject<T extends FieldValues, P extends FieldPath<T>>(key: string, path?: P): FieldPathValue<T, P> | undefined;
+/** React hook: subscribe to and read a namespaced path debounced value. */
+declare function useDebounce<T extends FieldValues, P extends FieldPath<T>>(key: string, path: P, delay: number): FieldPathValue<T, P> | undefined;
+/** Effectful subscription helper that calls onChange with the latest value. */
+declare function useSubscribe<T>(key: string, onChange: (value: T) => void): void;
+/** Set a leaf value under namespace.path, optionally skipping notifications. */
+declare function setLeaf<T extends FieldValues, P extends FieldPath<T>>(key: string, path: P, value: FieldPathValue<T, P> | undefined, skipUpdate?: boolean, memoryOnly?: boolean): void;

package/dist/impl.js

@@ -0,0 +1,378 @@
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
+import isEqual from 'react-fast-compare';
+import { localStorageDelete, localStorageGet, localStorageSet } from './local_storage';
+export { getNestedValue, getSnapshot, joinPath, notifyListeners, produce, setLeaf, useDebounce, useObject, useSubscribe };
+const memoryStore = new Map();
+function joinPath(namespace, path) {
+    if (!path)
+        return namespace;
+    return namespace + '.' + path;
+}
+// Path traversal utilities
+/** Get a nested value from an object/array using a dot-separated path. */
+function getNestedValue(obj, path) {
+    if (!path)
+        return obj;
+    const segments = path.split('.');
+    let current = obj;
+    for (const segment of segments) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (Number.isNaN(index))
+                return undefined;
+            current = current[index];
+        }
+        else {
+            current = current[segment];
+        }
+    }
+    return current;
+}
+function tryStructuredClone(obj) {
+    if (obj === null || obj === undefined)
+        return null;
+    if (typeof obj !== 'object')
+        return obj;
+    // Fast path for array type
+    if (Array.isArray(obj)) {
+        // Check if array needs deep cloning (contains objects/arrays)
+        const needsDeepClone = obj.some(item => item !== null && typeof item === 'object');
+        if (!needsDeepClone) {
+            // Array of primitives - just return new array reference
+            return [...obj];
+        }
+        return obj.map(item => tryStructuredClone(item));
+    }
+    // Fallback to structuredClone for complex objects
+    try {
+        return structuredClone(obj);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Immutable set/delete of a nested value using a dot-separated path.
+ * - Creates intermediate nodes (array if next segment is a numeric index).
+ * - If value is undefined, deletes object key or removes array index.
+ * - Returns a new root object/array; when path is empty, returns value.
+ */
+function setNestedValue(obj, path, value) {
+    if (!path)
+        return value;
+    const segments = path.split('.');
+    const result = tryStructuredClone(obj);
+    let current = result ?? {};
+    for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        const nextSegment = segments[i + 1];
+        const isNextIndex = !Number.isNaN(Number(nextSegment));
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (Number.isNaN(index))
+                break;
+            if (!current[index]) {
+                current[index] = isNextIndex ? [] : {};
+            }
+            current = current[index];
+        }
+        else if (typeof current === 'object' && current !== null) {
+            const currentObj = current;
+            if (!currentObj[segment]) {
+                currentObj[segment] = isNextIndex ? [] : {};
+            }
+            current = currentObj[segment];
+        }
+    }
+    const lastSegment = segments[segments.length - 1];
+    if (Array.isArray(current)) {
+        const index = Number(lastSegment);
+        if (!Number.isNaN(index)) {
+            if (value === undefined) {
+                current.splice(index, 1);
+            }
+            else {
+                current[index] = value;
+            }
+        }
+    }
+    else if (typeof current === 'object' && current !== null) {
+        const currentObj = current;
+        if (value === undefined) {
+            delete currentObj[lastSegment];
+        }
+        else {
+            currentObj[lastSegment] = value;
+        }
+    }
+    return result;
+}
+/** Extract the root namespace from a full key (e.g. "ns.a.b" => "ns"). */
+function getRootKey(key) {
+    return key.split('.')[0];
+}
+/** Extract the nested path from a full key (e.g. "ns.a.b" => "a.b"). */
+function getPath(key) {
+    const segments = key.split('.');
+    return segments.slice(1).join('.');
+}
+// Helper function to notify listeners hierarchically
+/** Notify exact, root, and affected child listeners for a given key change. */
+function notifyListeners(key, oldValue, newValue, skipRoot = false, skipChildren = false) {
+    const rootKey = skipRoot ? null : key.split('.').slice(0, 2).join('.');
+    const keyPrefix = skipChildren ? null : key + '.';
+    // Single pass: collect listeners to notify
+    const listenersToNotify = new Set();
+    for (const [listenerKey, listenerSet] of listeners.entries()) {
+        if (listenerKey === key) {
+            // Exact key match
+            listenerSet.forEach(listener => listenersToNotify.add(listener));
+        }
+        else if (rootKey && listenerKey === rootKey) {
+            // Root key match
+            listenerSet.forEach(listener => listenersToNotify.add(listener));
+        }
+        else if (keyPrefix && listenerKey.startsWith(keyPrefix)) {
+            // Child key match - check if value actually changed
+            const childPath = listenerKey.substring(key.length + 1);
+            const oldChildValue = getNestedValue(oldValue, childPath);
+            const newChildValue = getNestedValue(newValue, childPath);
+            if (!isEqual(oldChildValue, newChildValue)) {
+                listenerSet.forEach(listener => listenersToNotify.add(listener));
+            }
+        }
+    }
+    // Notify all collected listeners
+    listenersToNotify.forEach(listener => listener());
+}
+// BroadcastChannel for cross-tab synchronization
+const broadcastChannel = typeof window !== 'undefined' ? new BroadcastChannel('godoxy-producer-consumer') : null;
+/**
+ * Backing store providing in-memory data with localStorage persistence
+ * and cross-tab synchronization. All operations are namespaced at the root key
+ * (characters before the first dot).
+ */
+const store = {
+    has(key) {
+        const rootKey = getRootKey(key);
+        return (memoryStore.has(rootKey) ||
+            (typeof window !== 'undefined' && localStorageGet(rootKey) !== undefined));
+    },
+    get(key) {
+        const rootKey = getRootKey(key);
+        const path = getPath(key);
+        // Get root object from memory or localStorage
+        let rootValue;
+        if (memoryStore.has(rootKey)) {
+            rootValue = memoryStore.get(rootKey);
+        }
+        else if (typeof window !== 'undefined') {
+            rootValue = localStorageGet(rootKey);
+            if (rootValue !== undefined) {
+                memoryStore.set(rootKey, rootValue);
+            }
+        }
+        // If no path, return root value
+        if (!path)
+            return rootValue;
+        // Traverse to nested value
+        return getNestedValue(rootValue, path);
+    },
+    set(key, value, memoryOnly = false) {
+        const rootKey = getRootKey(key);
+        const path = getPath(key);
+        let rootValue;
+        if (!path) {
+            // Setting root value directly
+            rootValue = value;
+        }
+        else {
+            // Setting nested value
+            const currentRoot = memoryStore.get(rootKey) ?? localStorageGet(rootKey) ?? {};
+            rootValue = setNestedValue(currentRoot, path, value);
+        }
+        // Update memory
+        if (rootValue === undefined) {
+            memoryStore.delete(rootKey);
+        }
+        else {
+            memoryStore.set(rootKey, rootValue);
+        }
+        // Persist to localStorage (unless memoryOnly)
+        if (!memoryOnly && typeof window !== 'undefined') {
+            localStorageSet(rootKey, rootValue);
+            // Broadcast change to other tabs
+            if (broadcastChannel) {
+                broadcastChannel.postMessage({ type: 'set', key: rootKey, value: rootValue });
+            }
+        }
+    },
+    delete(key, memoryOnly = false) {
+        const rootKey = getRootKey(key);
+        const path = getPath(key);
+        if (!path) {
+            // Deleting root key
+            memoryStore.delete(rootKey);
+            if (!memoryOnly && typeof window !== 'undefined') {
+                localStorageDelete(rootKey);
+                if (broadcastChannel) {
+                    broadcastChannel.postMessage({ type: 'delete', key: rootKey });
+                }
+            }
+        }
+        else {
+            // Deleting nested value
+            const currentRoot = memoryStore.get(rootKey) ?? localStorageGet(rootKey);
+            if (currentRoot !== undefined) {
+                const updatedRoot = setNestedValue(currentRoot, path, undefined);
+                memoryStore.set(rootKey, updatedRoot);
+                if (!memoryOnly && typeof window !== 'undefined') {
+                    localStorageSet(rootKey, updatedRoot);
+                    if (broadcastChannel) {
+                        broadcastChannel.postMessage({ type: 'set', key: rootKey, value: updatedRoot });
+                    }
+                }
+            }
+        }
+    },
+    get size() {
+        return memoryStore.size;
+    }
+};
+/** Snapshot getter used by React's useSyncExternalStore. */
+function getSnapshot(key) {
+    return store.get(key);
+}
+// Cross-tab synchronization: keep memoryStore in sync with BroadcastChannel events
+if (broadcastChannel) {
+    broadcastChannel.addEventListener('message', event => {
+        const { type, key, value } = event.data;
+        if (!key)
+            return;
+        // Store old value before updating
+        const oldRootValue = memoryStore.get(key);
+        if (type === 'delete') {
+            memoryStore.delete(key);
+        }
+        else if (type === 'set') {
+            memoryStore.set(key, value);
+        }
+        // Notify all listeners that might be affected by this root key change
+        const newRootValue = type === 'delete' ? undefined : value;
+        for (const listenerKey of listeners.keys()) {
+            if (listenerKey === key) {
+                // Direct key match - notify with old and new values
+                notifyListeners(listenerKey, oldRootValue, newRootValue);
+            }
+            else if (listenerKey.startsWith(key + '.')) {
+                // Child key - check if its value actually changed
+                const childPath = listenerKey.substring(key.length + 1);
+                const oldChildValue = getNestedValue(oldRootValue, childPath);
+                const newChildValue = getNestedValue(newRootValue, childPath);
+                if (!isEqual(oldChildValue, newChildValue)) {
+                    const childListeners = listeners.get(listenerKey);
+                    childListeners?.forEach(listener => listener());
+                }
+            }
+        }
+    });
+}
+const listeners = new Map();
+/** Subscribe to changes for a key; returns an unsubscribe function. */
+function subscribe(key, listener) {
+    if (!listeners.has(key)) {
+        listeners.set(key, new Set());
+    }
+    listeners.get(key).add(listener);
+    return () => {
+        const keyListeners = listeners.get(key);
+        if (keyListeners) {
+            keyListeners.delete(listener);
+            if (keyListeners.size === 0) {
+                listeners.delete(key);
+            }
+        }
+    };
+}
+/** Core mutation function that updates store and notifies listeners. */
+function produce(key, value, skipUpdate = false, memoryOnly = false) {
+    const current = store.get(key);
+    if (value === undefined) {
+        skipUpdate = current === undefined;
+        store.delete(key, memoryOnly);
+    }
+    else {
+        if (isEqual(current, value))
+            return;
+        store.set(key, value, memoryOnly);
+    }
+    if (skipUpdate)
+        return;
+    // Notify listeners hierarchically with old and new values
+    notifyListeners(key, current, value);
+}
+/** React hook: subscribe to and read a namespaced path value. */
+function useObject(key, path) {
+    const fullKey = joinPath(key, path);
+    const value = useSyncExternalStore(listener => subscribe(fullKey, listener), () => getSnapshot(fullKey), () => getSnapshot(fullKey));
+    return value;
+}
+/** React hook: subscribe to and read a namespaced path debounced value. */
+function useDebounce(key, path, delay) {
+    const fullKey = joinPath(key, path);
+    const currentValue = useSyncExternalStore(listener => subscribe(fullKey, listener), () => getSnapshot(fullKey), () => getSnapshot(fullKey));
+    const [debouncedValue, setDebouncedValue] = useState(currentValue);
+    const timeoutRef = useRef(undefined);
+    useEffect(() => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            if (!isEqual(debouncedValue, currentValue)) {
+                setDebouncedValue(currentValue);
+            }
+        }, delay);
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, [currentValue, delay, debouncedValue]);
+    return debouncedValue;
+}
+/** Effectful subscription helper that calls onChange with the latest value. */
+function useSubscribe(key, onChange) {
+    const onChangeRef = useRef(onChange);
+    useEffect(() => {
+        onChangeRef.current = onChange;
+    }, [onChange]);
+    useEffect(() => {
+        const unsubscribe = subscribe(key, () => {
+            const value = getSnapshot(key);
+            onChangeRef.current(value);
+        });
+        return unsubscribe;
+    }, [key]);
+}
+/** Set a leaf value under namespace.path, optionally skipping notifications. */
+function setLeaf(key, path, value, skipUpdate = false, memoryOnly = false) {
+    const fullKey = joinPath(key, path);
+    produce(fullKey, value, skipUpdate, memoryOnly);
+}
+// Debug helpers (dev only)
+/** Development-only debug helpers exposed on window.__pc_debug in development. */
+const __pc_debug = {
+    getStoreSize: () => store.size,
+    getListenerSize: () => listeners.size,
+    getStore: () => memoryStore,
+    getStoreValue: (key) => memoryStore.get(key)
+};
+// Expose debug in browser for quick inspection during development
+if (typeof window !== 'undefined' && process.env.NODE_ENV === 'development') {
+    ;
+    window.__pc_debug = __pc_debug;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { useForm } from './form';
+export type { FormState, FormStore } from './form';
+export { useMemoryStore, type MemoryStore } from './memory';
+export { createStore, type Store } from './store';
+export type { State, StoreSetStateAction } from './types';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { useForm } from './form';
+export { useMemoryStore } from './memory';
+export { createStore } from './store';

package/dist/local_storage.d.ts

@@ -0,0 +1,7 @@
+export { localStorageDelete, localStorageGet, localStorageSet };
+/** Read from localStorage (JSON.parse) with prefix; undefined on SSR or error. */
+declare function localStorageGet(key: string): unknown;
+/** Write to localStorage (JSON.stringify); remove key when value is undefined. */
+declare function localStorageSet(key: string, value: unknown): void;
+/** Delete from localStorage with prefix. */
+declare function localStorageDelete(key: string): void;

package/dist/local_storage.js

@@ -0,0 +1,43 @@
+// localStorage operations
+const STORAGE_PREFIX = 'juststore:';
+export { localStorageDelete, localStorageGet, localStorageSet };
+/** Read from localStorage (JSON.parse) with prefix; undefined on SSR or error. */
+function localStorageGet(key) {
+    try {
+        if (typeof window === 'undefined')
+            return undefined;
+        const item = localStorage.getItem(`${STORAGE_PREFIX}${key}`);
+        return item ? JSON.parse(item) : undefined;
+    }
+    catch (e) {
+        console.error('Failed to get key from localStorage', key, e);
+        return undefined;
+    }
+}
+/** Write to localStorage (JSON.stringify); remove key when value is undefined. */
+function localStorageSet(key, value) {
+    try {
+        if (typeof window === 'undefined')
+            return;
+        if (value === undefined) {
+            localStorage.removeItem(`${STORAGE_PREFIX}${key}`);
+        }
+        else {
+            localStorage.setItem(`${STORAGE_PREFIX}${key}`, JSON.stringify(value));
+        }
+    }
+    catch (e) {
+        console.error('Failed to set key in localStorage', key, value, e);
+    }
+}
+/** Delete from localStorage with prefix. */
+function localStorageDelete(key) {
+    try {
+        if (typeof window === 'undefined')
+            return;
+        localStorage.removeItem(`${STORAGE_PREFIX}${key}`);
+    }
+    catch (e) {
+        console.error('Failed to delete key from localStorage', key, e);
+    }
+}

package/dist/memory.d.ts

@@ -0,0 +1,21 @@
+import type { FieldValues } from './path';
+import type { DeepProxy, State } from './types';
+export { useMemoryStore, type MemoryStore };
+/**
+ * A component local store with React bindings.
+ *
+ * - Dot-path addressing for nested values (e.g. "state.ui.theme").
+ * - Immutable partial updates with automatic object/array creation.
+ * - Fine-grained subscriptions built on useSyncExternalStore.
+ * - Type-safe paths using FieldPath.
+ * - Dynamic deep access via Proxy for ergonomic usage like `state.a.b.c.use()` and `state.a.b.c.set(v)`.
+ */
+type MemoryStore<T extends FieldValues> = State<T> & {
+    [K in keyof T]: NonNullable<T[K]> extends object ? DeepProxy<T[K]> : State<T[K]>;
+};
+/**
+ * Create a memory store. The returned object is a Proxy that
+ * exposes the base API (use/set/value/reset/...) and also allows deep, dynamic
+ * access: e.g. `store.user.profile.name.use()` or `store.todos.at(0).title.set('x')`.
+ */
+declare function useMemoryStore<T extends FieldValues>(defaultValue: T): MemoryStore<T>;

package/dist/memory.js

@@ -0,0 +1,17 @@
+import { useId } from 'react';
+import { createRootNode } from './node';
+import { createStoreRoot } from './root';
+export { useMemoryStore };
+/**
+ * Create a memory store. The returned object is a Proxy that
+ * exposes the base API (use/set/value/reset/...) and also allows deep, dynamic
+ * access: e.g. `store.user.profile.name.use()` or `store.todos.at(0).title.set('x')`.
+ */
+function useMemoryStore(defaultValue) {
+    const memoryStoreId = useId();
+    const namespace = `memory:${memoryStoreId}`;
+    const storeApi = createStoreRoot(namespace, defaultValue, {
+        memoryOnly: true
+    });
+    return createRootNode(storeApi);
+}

package/dist/mixed_state.d.ts

@@ -0,0 +1,21 @@
+import type { Prettify, State } from './types';
+export { createMixedState, type MixedState };
+type MixedState<T extends readonly unknown[]> = Prettify<Pick<State<Readonly<T>>, 'value' | 'use' | 'Render' | 'Show'>>;
+/**
+ * Creates a mixed state that combines multiple states into a tuple.
+ *
+ * If one of the states is changed, the mixed state will be updated.
+ *
+ * @param states - Array of states to combine
+ * @returns A new state that provides all values as a tuple
+ *
+ * @example
+ * const mixedState = createMixedState(states.addLoading, states.copyLoading, state.agent)
+ *
+ * <mixedState.Render>
+ *   {[addLoading, copyLoading, agent] => <SomeComponent />}
+ * </mixedState.Render>
+ */
+declare function createMixedState<T extends readonly unknown[]>(...states: {
+    [K in keyof T]: State<T[K]>;
+}): MixedState<T>;