@yiin/reactive-proxy-state 1.0.1 → 1.0.3

package/dist/utils.js

@@ -0,0 +1,257 @@
+// Cache for memoized deepEqual results with cleanup
+const deepEqualCache = new WeakMap();
+const MAX_CACHE_SIZE = 1000; // Prevent unbounded growth
+// Path traversal cache with LRU-like behavior
+export const pathCache = new WeakMap();
+const pathCacheSize = new WeakMap();
+// Path concatenation cache with size limit
+export const pathConcatCache = new Map();
+const MAX_PATH_CACHE_SIZE = 1000;
+// Global seen map for circular reference detection
+export const globalSeen = new WeakMap();
+// Global cache for proxy wrappers
+export const wrapperCache = new WeakMap();
+function cleanupPathCache(root) {
+    const cache = pathCache.get(root);
+    if (cache && pathCacheSize.get(root) > MAX_CACHE_SIZE) {
+        // Clear oldest entries (first 20%)
+        const entriesToRemove = Math.floor(MAX_CACHE_SIZE * 0.2);
+        let count = 0;
+        for (const key of cache.keys()) {
+            if (count >= entriesToRemove)
+                break;
+            cache.delete(key);
+            count++;
+        }
+        pathCacheSize.set(root, MAX_CACHE_SIZE - entriesToRemove);
+    }
+}
+function cleanupPathConcatCache() {
+    if (pathConcatCache.size > MAX_PATH_CACHE_SIZE) {
+        // Remove oldest entries (first 20%)
+        const entriesToRemove = Math.floor(MAX_PATH_CACHE_SIZE * 0.2);
+        let count = 0;
+        for (const key of pathConcatCache.keys()) {
+            if (count >= entriesToRemove)
+                break;
+            pathConcatCache.delete(key);
+            count++;
+        }
+    }
+}
+export function deepEqual(a, b, seen = globalSeen) {
+    // Fast path for primitive equality
+    if (a === b)
+        return true;
+    // Fast path for null/undefined
+    if (a == null || b == null)
+        return a === b;
+    // Fast path for different types
+    if (typeof a !== typeof b)
+        return false;
+    // Fast path for Date objects
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    // Fast path for non-objects
+    if (typeof a !== 'object')
+        return false;
+    // Fast path for different array types
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    // Check for circular references
+    if (seen.has(a))
+        return seen.get(a) === b;
+    seen.set(a, b);
+    // Check cache for memoized results
+    if (deepEqualCache.has(a) && deepEqualCache.get(a)?.has(b)) {
+        return deepEqualCache.get(a).get(b);
+    }
+    // Initialize cache for this object if needed
+    if (!deepEqualCache.has(a)) {
+        deepEqualCache.set(a, new WeakMap());
+    }
+    let result;
+    // Compare arrays
+    if (Array.isArray(a)) {
+        if (a.length !== b.length) {
+            result = false;
+        }
+        else {
+            result = a.every((val, idx) => deepEqual(val, b[idx], seen));
+        }
+    }
+    else {
+        // Compare objects
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) {
+            result = false;
+        }
+        else {
+            result = keysA.every(key => deepEqual(a[key], b[key], seen));
+        }
+    }
+    // Cache the result
+    deepEqualCache.get(a).set(b, result);
+    return result;
+}
+// Helper to safely get from path cache with cleanup
+export function getFromPathCache(root, pathKey) {
+    const cache = pathCache.get(root);
+    if (!cache)
+        return undefined;
+    const result = cache.get(pathKey);
+    if (result !== undefined) {
+        // Move to end (most recently used)
+        cache.delete(pathKey);
+        cache.set(pathKey, result);
+    }
+    return result;
+}
+// Helper to safely set in path cache with cleanup
+export function setInPathCache(root, pathKey, value) {
+    if (!pathCache.has(root)) {
+        pathCache.set(root, new Map());
+        pathCacheSize.set(root, 0);
+    }
+    const cache = pathCache.get(root);
+    const size = pathCacheSize.get(root);
+    // If key exists, remove it first (will be added at end)
+    if (cache.has(pathKey)) {
+        cache.delete(pathKey);
+    }
+    cache.set(pathKey, value);
+    pathCacheSize.set(root, size + 1);
+    cleanupPathCache(root);
+}
+// Helper to safely get/set path concatenation with cleanup
+export function getPathConcat(path) {
+    const result = pathConcatCache.get(path);
+    if (result !== undefined) {
+        // Move to end (most recently used)
+        pathConcatCache.delete(path);
+        pathConcatCache.set(path, result);
+    }
+    return result;
+}
+export function setPathConcat(path, value) {
+    pathConcatCache.set(path, value);
+    cleanupPathConcatCache();
+}
+// Helper to check if a value is an object (and not null)
+function isObject(val) {
+    return val !== null && typeof val === 'object';
+}
+/**
+ * Recursively traverses an object to track all nested properties.
+ * Used for deep watching.
+ * @param value - The value to traverse.
+ * @param seen - A Set to handle circular references.
+ */
+export function traverse(value, seen = new Set()) {
+    if (!isObject(value) || seen.has(value)) {
+        return value;
+    }
+    seen.add(value);
+    // Traverse arrays
+    if (Array.isArray(value)) {
+        // Access length for tracking
+        value.length;
+        for (let i = 0; i < value.length; i++) {
+            traverse(value[i], seen);
+        }
+    }
+    // Traverse Sets and Maps
+    else if (value instanceof Set || value instanceof Map) {
+        for (const v of value) {
+            // For Maps, traverse both keys (if objects) and values
+            if (Array.isArray(v)) {
+                traverse(v[0], seen); // Key
+                traverse(v[1], seen); // Value
+            }
+            else {
+                traverse(v, seen); // Value for Set
+            }
+        }
+        // --- Stop after handling Map/Set --- 
+        return value;
+    }
+    // Traverse plain objects (Only if not Array, Map, or Set)
+    else {
+        for (const key in value) {
+            // Access the property to trigger tracking via the proxy's get handler
+            traverse(value[key], seen);
+        }
+    }
+    return value;
+}
+/**
+ * Creates a deep clone of a value.
+ * Handles primitives, Dates, Arrays, Maps, Sets, and plain objects.
+ * Includes cycle detection.
+ * @param value The value to clone.
+ * @param seen A WeakMap to handle circular references during recursion.
+ * @returns A deep clone of the value.
+ */
+export function deepClone(value, seen = new WeakMap()) {
+    // Primitives and null are returned directly
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    // Handle Dates
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    // Handle cycles
+    if (seen.has(value)) {
+        return seen.get(value);
+    }
+    // Handle Arrays
+    if (Array.isArray(value)) {
+        const newArray = [];
+        seen.set(value, newArray);
+        for (let i = 0; i < value.length; i++) {
+            newArray[i] = deepClone(value[i], seen);
+        }
+        return newArray;
+    }
+    // Handle Maps
+    if (value instanceof Map) {
+        const newMap = new Map();
+        seen.set(value, newMap);
+        value.forEach((val, key) => {
+            // Clone both key and value in case they are objects
+            newMap.set(deepClone(key, seen), deepClone(val, seen));
+        });
+        return newMap;
+    }
+    // Handle Sets
+    if (value instanceof Set) {
+        const newSet = new Set();
+        seen.set(value, newSet);
+        value.forEach(val => {
+            newSet.add(deepClone(val, seen));
+        });
+        return newSet;
+    }
+    // Handle plain objects
+    // Create object with same prototype
+    const newObject = Object.create(Object.getPrototypeOf(value));
+    seen.set(value, newObject);
+    // Copy properties
+    for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            newObject[key] = deepClone(value[key], seen);
+        }
+    }
+    // Copy symbol properties (if any)
+    const symbolKeys = Object.getOwnPropertySymbols(value);
+    for (const symbolKey of symbolKeys) {
+        // Check if property descriptor exists and has get/set or is value
+        const descriptor = Object.getOwnPropertyDescriptor(value, symbolKey);
+        if (descriptor && (descriptor.value !== undefined || descriptor.get || descriptor.set)) {
+            newObject[symbolKey] = deepClone(value[symbolKey], seen);
+        }
+    }
+    return newObject;
+}

package/dist/watch.d.ts

@@ -0,0 +1,19 @@
+type WatchCallback<T = any> = (newValue: T, oldValue: T | undefined) => void;
+type WatchSource<T = any> = () => T;
+type WatchSourceInput<T = any> = WatchSource<T> | T;
+type WatchStopHandle = () => void;
+export interface WatchOptions {
+    immediate?: boolean;
+    deep?: boolean;
+}
+/**
+ * Watches a reactive source and runs a callback when it changes
+ *
+ * @param source - A function that returns the value to watch
+ * @param callback - Function to call when the source changes
+ * @param options - Watch options (immediate, deep)
+ * @returns A function to stop watching
+ */
+export declare function watch<T = any>(sourceInput: WatchSourceInput<T>, // Renamed parameter
+callback: WatchCallback<T>, options?: WatchOptions): WatchStopHandle;
+export {};

package/dist/watch.js

@@ -0,0 +1,74 @@
+import { watchEffect } from './watchEffect';
+import { traverse, deepClone } from './utils';
+/**
+ * Watches a reactive source and runs a callback when it changes
+ *
+ * @param source - A function that returns the value to watch
+ * @param callback - Function to call when the source changes
+ * @param options - Watch options (immediate, deep)
+ * @returns A function to stop watching
+ */
+export function watch(sourceInput, // Renamed parameter
+callback, options = {}) {
+    // Default deep to true unless explicitly false
+    const { immediate = false, deep = true } = options;
+    // Normalize sourceInput to always be a function
+    const source = typeof sourceInput === 'function'
+        ? sourceInput
+        : () => sourceInput;
+    let oldValue;
+    let initialized = false;
+    // Use watchEffect to track dependencies and re-run when they change
+    const stopEffect = watchEffect(() => {
+        // 1. Run the source function to get the current value
+        const currentValue = source();
+        // Determine if deep watching is needed for tracking
+        // Use the defaulted 'deep' value
+        let needsDeepTracking = deep === true;
+        // This check becomes redundant if deep defaults to true, but keep for potential explicit {deep: false} on collections?
+        // Maybe simplify: if deep is true, always traverse.
+        /*
+        if (!needsDeepTracking && currentValue && typeof currentValue === 'object') {
+            if (Array.isArray(currentValue) || currentValue instanceof Map || currentValue instanceof Set) {
+                needsDeepTracking = true; // Track collections even if deep:false? Vue does shallow on collections by default.
+            }
+        }
+        */
+        // 2. If deep tracking needed, traverse the value *for tracking purposes only*
+        if (needsDeepTracking) {
+            traverse(currentValue); // Discard result, only needed for effect tracking
+        }
+        // 3. Compare the actual currentValue with the oldValue
+        if (initialized) {
+            let hasChanged = false;
+            // Use the defaulted 'deep' value for comparison logic
+            if (!deep) {
+                hasChanged = currentValue !== oldValue;
+            }
+            else {
+                // For deep watches, the effect running *implies* a relevant change occurred.
+                // The traverse() call ensures dependencies were tracked. If the effect
+                // runs, we assume a change happened without needing deepEqual.
+                hasChanged = true;
+            }
+            if (hasChanged) {
+                // Get the value to pass as the previous oldValue to the callback
+                const prevOldValue = oldValue;
+                // Update the stored oldValue. Clone *only if* deep watching is enabled.
+                oldValue = deep ? deepClone(currentValue) : currentValue;
+                callback(currentValue, prevOldValue);
+            }
+        }
+        else {
+            // First run: establish initial oldValue (cloned if deep) and handle immediate call
+            oldValue = deep ? deepClone(currentValue) : currentValue;
+            initialized = true;
+            if (immediate) {
+                // Pass undefined as oldValue for immediate calls
+                callback(currentValue, undefined);
+            }
+        }
+    });
+    // Return the stop handle from watchEffect
+    return stopEffect;
+}

package/dist/watchEffect.d.ts

@@ -0,0 +1,49 @@
+type EffectCallback<T = any> = () => T;
+type Scheduler = (job: () => void) => void;
+export interface WatchEffectStopHandle<T = any> {
+    (): void;
+    effect: TrackedEffect<T>;
+}
+export interface TrackedEffect<T = any> {
+    run: () => T;
+    dependencies?: Set<Set<TrackedEffect<any>>>;
+    options?: WatchEffectOptions;
+    active?: boolean;
+    _rawCallback: EffectCallback<T>;
+}
+export declare let activeEffect: TrackedEffect<any> | null;
+export declare function setActiveEffect(effect: TrackedEffect<any> | null): void;
+/**
+ * Clean up dependencies for a specific effect
+ */
+export declare function cleanupEffect(effect: TrackedEffect<any>): void;
+/**
+ * Track a property access for the active effect
+ */
+export declare function track(target: object, key: string | symbol): void;
+/**
+ * Trigger effects associated with a property (Synchronous Only)
+ */
+export declare function trigger(target: object, key: string | symbol): void;
+export interface WatchEffectOptions {
+    lazy?: boolean;
+    scheduler?: Scheduler;
+    onTrack?: (event: {
+        effect: EffectCallback<any>;
+        target: object;
+        key: string | symbol;
+        type: 'track';
+    }) => void;
+    onTrigger?: (event: {
+        effect: EffectCallback<any>;
+        target: object;
+        key: string | symbol;
+        type: 'trigger';
+    }) => void;
+}
+/**
+ * Runs a function and re-runs it when its reactive dependencies change.
+ * Returns a stop handle that also exposes the effect instance.
+ */
+export declare function watchEffect<T>(effectCallback: EffectCallback<T>, options?: WatchEffectOptions): WatchEffectStopHandle<T>;
+export {};

package/dist/watchEffect.js

@@ -0,0 +1,139 @@
+// Track currently running effect
+// Note: activeEffect can hold effects with different return types
+export let activeEffect = null;
+// Setter function for activeEffect
+export function setActiveEffect(effect) {
+    activeEffect = effect;
+}
+// Store for tracking dependencies: target -> key -> Set<TrackedEffect>
+// The Sets will hold effects of potentially different types
+const targetMap = new WeakMap();
+/**
+ * Clean up dependencies for a specific effect
+ */
+export function cleanupEffect(effect) {
+    if (effect.dependencies) {
+        effect.dependencies.forEach(dep => {
+            dep.delete(effect);
+        });
+        effect.dependencies.clear(); // Clear the set for the next run
+    }
+}
+/**
+ * Track a property access for the active effect
+ */
+export function track(target, key) {
+    // Only track if there's an active effect that should be running
+    if (!activeEffect || !activeEffect.active)
+        return;
+    // Get the dependency map for this target
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+        depsMap = new Map();
+        targetMap.set(target, depsMap);
+    }
+    // Get the set of effects for this property
+    let dep = depsMap.get(key);
+    if (!dep) {
+        dep = new Set();
+        depsMap.set(key, dep);
+    }
+    // Add the active effect to the set if not already present
+    // Ensure we are adding the correct type to the Set
+    const effectToAdd = activeEffect;
+    if (!dep.has(effectToAdd)) {
+        dep.add(effectToAdd);
+        // Add this dep set to the effect's own dependency list for cleanup
+        if (!effectToAdd.dependencies) {
+            effectToAdd.dependencies = new Set();
+        }
+        effectToAdd.dependencies.add(dep);
+        // Trigger onTrack if available
+        if (effectToAdd.options?.onTrack) {
+            // Pass the raw user callback, not the internal effect object
+            effectToAdd.options.onTrack({ effect: effectToAdd._rawCallback, target, key, type: 'track' });
+        }
+    }
+}
+/**
+ * Trigger effects associated with a property (Synchronous Only)
+ */
+export function trigger(target, key) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap)
+        return;
+    // Use a Set to avoid duplicate runs within the same trigger
+    const effectsToRun = new Set();
+    const addEffects = (depKey) => {
+        const dep = depsMap.get(depKey);
+        if (dep) {
+            dep.forEach(effect => {
+                // Avoid infinite loops by not scheduling the currently running effect
+                // Also check if effect is active
+                if (effect !== activeEffect && effect.active) {
+                    effectsToRun.add(effect);
+                }
+            });
+        }
+    };
+    addEffects(key);
+    // Schedule or run effects
+    effectsToRun.forEach(effect => {
+        // Trigger onTrigger if available
+        if (effect.options?.onTrigger) {
+            effect.options.onTrigger({ effect: effect._rawCallback, target, key, type: 'trigger' });
+        }
+        // Use scheduler if available, otherwise run directly
+        if (effect.options?.scheduler) {
+            effect.options.scheduler(effect.run);
+        }
+        else {
+            effect.run(); // Run the effect's wrapper
+        }
+    });
+}
+/**
+ * Runs a function and re-runs it when its reactive dependencies change.
+ * Returns a stop handle that also exposes the effect instance.
+ */
+export function watchEffect(effectCallback, options = {}) {
+    // The core runner function that handles cleanup, activeEffect setting, and execution
+    const run = () => {
+        if (!effectFn.active)
+            return effectCallback(); // If stopped, just return value (though likely undefined)
+        const previousEffect = activeEffect;
+        try {
+            cleanupEffect(effectFn);
+            setActiveEffect(effectFn);
+            return effectCallback(); // Execute the user's function
+        }
+        finally {
+            setActiveEffect(previousEffect);
+        }
+    };
+    // The effect object itself
+    const effectFn = {
+        run: run,
+        dependencies: new Set(),
+        options: options,
+        active: true,
+        _rawCallback: effectCallback
+    };
+    // Run effect immediately unless lazy
+    if (!options.lazy) {
+        effectFn.run();
+    }
+    // Create the stop handle function
+    const stopHandle = () => {
+        if (effectFn.active) {
+            cleanupEffect(effectFn);
+            effectFn.active = false;
+            // Clear references
+            // effectFn.dependencies = undefined; // Keep dependencies for potential re-activation?
+            // effectFn.options = undefined;
+        }
+    };
+    // Attach the effect instance to the stop handle
+    stopHandle.effect = effectFn;
+    return stopHandle;
+}

package/dist/wrapArray.d.ts

@@ -0,0 +1,2 @@
+import { EmitFunction, Path } from './types';
+export declare function wrapArray<T extends any[]>(arr: T, emit: EmitFunction, path: Path): T;