@yiin/reactive-proxy-state 1.0.1 → 1.0.3

package/dist/wrapArray.js

@@ -0,0 +1,237 @@
+import { deepEqual, getPathConcat, setPathConcat, wrapperCache } from './utils';
+import { reactive } from './reactive';
+import { wrapMap } from './wrapMap';
+import { wrapSet } from './wrapSet';
+import { track, trigger } from './watchEffect';
+// Pre-allocate type check function
+function isObject(v) {
+    return v && typeof v === 'object';
+}
+export function wrapArray(arr, emit, path) {
+    // Check wrapper cache first
+    const cachedProxy = wrapperCache.get(arr);
+    if (cachedProxy)
+        return cachedProxy;
+    const proxy = new Proxy(arr, {
+        get(target, prop, receiver) {
+            // Original track call - might be redundant if handled below but keep for now
+            track(target, prop);
+            // Handle specific array mutation methods first
+            switch (prop) {
+                case 'push':
+                    track(target, 'length');
+                    return function (...items) {
+                        const oldLength = target.length;
+                        const result = target.push(...items);
+                        const newLength = target.length;
+                        if (items.length > 0) {
+                            const event = {
+                                action: 'array-push',
+                                path: path,
+                                key: oldLength, // Start index was the old length
+                                items: items
+                            };
+                            emit(event);
+                            trigger(target, Symbol.iterator);
+                            if (oldLength !== newLength) {
+                                trigger(target, 'length');
+                            }
+                        }
+                        return result;
+                    };
+                case 'pop':
+                    track(target, 'length');
+                    return function () {
+                        if (target.length === 0)
+                            return undefined;
+                        const oldLength = target.length;
+                        const poppedIndex = oldLength - 1;
+                        const oldValue = target[poppedIndex];
+                        const result = target.pop();
+                        const newLength = target.length;
+                        const event = {
+                            action: 'array-pop',
+                            path: path,
+                            key: poppedIndex,
+                            oldValue: oldValue
+                        };
+                        emit(event);
+                        trigger(target, Symbol.iterator);
+                        if (oldLength !== newLength) {
+                            trigger(target, 'length');
+                        }
+                        return result;
+                    };
+                case 'shift':
+                    track(target, 'length');
+                    return function () {
+                        if (target.length === 0)
+                            return undefined;
+                        const oldLength = target.length;
+                        const oldValue = target[0];
+                        const result = target.shift();
+                        const newLength = target.length;
+                        const event = {
+                            action: 'array-shift',
+                            path: path,
+                            key: 0,
+                            oldValue: oldValue
+                        };
+                        emit(event);
+                        trigger(target, Symbol.iterator);
+                        if (oldLength !== newLength) {
+                            trigger(target, 'length');
+                        }
+                        return result;
+                    };
+                case 'unshift':
+                    track(target, 'length');
+                    return function (...items) {
+                        const oldLength = target.length;
+                        const result = target.unshift(...items);
+                        const newLength = target.length;
+                        if (items.length > 0) {
+                            const event = {
+                                action: 'array-unshift',
+                                path: path,
+                                key: 0,
+                                items: items
+                            };
+                            emit(event);
+                            trigger(target, Symbol.iterator);
+                            if (oldLength !== newLength) {
+                                trigger(target, 'length');
+                            }
+                        }
+                        return result;
+                    };
+                case 'splice':
+                    track(target, 'length');
+                    return function (start, deleteCount, ...items) {
+                        const oldLength = target.length;
+                        const actualStart = start < 0 ? Math.max(target.length + start, 0) : Math.min(start, target.length);
+                        const deleteCountNum = deleteCount === undefined ? target.length - actualStart : Number(deleteCount);
+                        const actualDeleteCount = Math.min(deleteCountNum, target.length - actualStart);
+                        const deletedItems = target.slice(actualStart, actualStart + actualDeleteCount);
+                        const result = target.splice(start, deleteCountNum, ...items);
+                        const newLength = target.length;
+                        if (actualDeleteCount > 0 || items.length > 0) {
+                            const event = {
+                                action: 'array-splice',
+                                path: path,
+                                key: actualStart,
+                                deleteCount: actualDeleteCount,
+                                items: items.length > 0 ? items : undefined,
+                                oldValues: deletedItems.length > 0 ? deletedItems : undefined
+                            };
+                            emit(event);
+                            trigger(target, Symbol.iterator);
+                            if (oldLength !== newLength) {
+                                trigger(target, 'length');
+                            }
+                        }
+                        return result;
+                    };
+                // Handle iteration methods
+                case Symbol.iterator:
+                case 'values': // values() returns an iterator
+                case 'keys': // keys() returns an iterator
+                case 'entries': // entries() returns an iterator
+                    // Track dependency on iteration
+                    track(target, Symbol.iterator);
+                    // Fall through to Reflect.get and bind below
+                    break;
+                case 'forEach':
+                case 'map':
+                case 'filter':
+                case 'reduce':
+                case 'reduceRight':
+                case 'find':
+                case 'findIndex':
+                case 'every':
+                case 'some':
+                case 'join': // join depends on iteration
+                    // These methods depend on iteration
+                    track(target, Symbol.iterator);
+                    // Fall through to Reflect.get and bind below
+                    break;
+                case 'length':
+                    // Explicitly track length access
+                    track(target, 'length');
+                    return Reflect.get(target, prop, receiver);
+            }
+            // Fallback for index access and other properties
+            const value = Reflect.get(target, prop, receiver);
+            // Handle index access: wrap retrieved element if it's an object
+            const isNumericIndex = typeof prop === 'number' || (typeof prop === 'string' && !isNaN(parseInt(prop, 10)));
+            if (isNumericIndex) {
+                // Track access to specific index
+                track(target, String(prop));
+                if (!isObject(value))
+                    return value;
+                // Check wrapper cache for the element
+                const cachedValueProxy = wrapperCache.get(value);
+                if (cachedValueProxy)
+                    return cachedValueProxy;
+                // Calculate path for the element
+                const propKey = String(prop);
+                const pathKey = path.length > 0 ? `${path.join('.')}.${propKey}` : propKey; // Fix pathKey generation for index 0
+                let newPath = getPathConcat(pathKey);
+                if (newPath === undefined) {
+                    newPath = path.concat(propKey);
+                    setPathConcat(pathKey, newPath);
+                }
+                // Wrap based on type (no longer passing seen)
+                if (Array.isArray(value))
+                    return wrapArray(value, emit, newPath);
+                if (value instanceof Map)
+                    return wrapMap(value, emit, newPath);
+                if (value instanceof Set)
+                    return wrapSet(value, emit, newPath);
+                if (value instanceof Date)
+                    return new Date(value.getTime()); // Dates are not proxied
+                // Default to reactive for plain objects
+                return reactive(value, emit, newPath);
+            }
+            // For non-numeric properties or properties that aren't objects, return value directly
+            // Also handle functions bound to the target
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        },
+        set(target, prop, value, receiver) {
+            const oldValue = target[prop];
+            // Fast path for primitive equality
+            if (oldValue === value)
+                return true;
+            // Deep equality check with new WeakMap
+            if (isObject(oldValue) && isObject(value) && deepEqual(oldValue, value, new WeakMap()))
+                return true;
+            const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+            const result = Reflect.set(target, prop, value, receiver);
+            const isNumericIndex = typeof prop === 'number' || (typeof prop === 'string' && !isNaN(parseInt(String(prop))));
+            if (result && (!descriptor || !descriptor.set || isNumericIndex)) {
+                const propKey = String(prop);
+                const pathKey = path.length > 0 ? `${path.join('.')}.${propKey}` : propKey; // Fix pathKey generation for index 0
+                let newPath = getPathConcat(pathKey);
+                if (newPath === undefined) {
+                    newPath = path.concat(propKey);
+                    setPathConcat(pathKey, newPath);
+                }
+                const event = {
+                    action: 'set',
+                    path: newPath,
+                    oldValue,
+                    newValue: value
+                };
+                emit(event);
+                trigger(target, prop);
+            }
+            return result;
+        }
+    });
+    // Cache the newly created proxy before returning
+    wrapperCache.set(arr, proxy);
+    return proxy;
+}

package/dist/wrapMap.d.ts

@@ -0,0 +1,2 @@
+import { EmitFunction, Path } from './types';
+export declare function wrapMap<K, V>(map: Map<K, V>, emit: EmitFunction, path: Path): Map<K, V>;

package/dist/wrapMap.js

@@ -0,0 +1,241 @@
+import { deepEqual, getPathConcat, setPathConcat, wrapperCache } from './utils';
+import { reactive } from './reactive';
+import { wrapArray } from './wrapArray';
+import { wrapSet } from './wrapSet';
+import { track, trigger } from './watchEffect';
+export function wrapMap(map, emit, path) {
+    // Check wrapper cache first
+    const cachedProxy = wrapperCache.get(map);
+    if (cachedProxy)
+        return cachedProxy;
+    const proxy = new Proxy(map, {
+        get(target, prop, receiver) {
+            // Original track call - Keep for properties not explicitly handled
+            track(target, prop);
+            // --- Specific Method Handlers ---
+            if (prop === 'set') {
+                return function (key, value) {
+                    const existed = target.has(key);
+                    const oldValue = target.get(key);
+                    const oldSize = target.size;
+                    if (oldValue === value)
+                        return receiver;
+                    if (oldValue && typeof oldValue === 'object' && value && typeof value === 'object' && deepEqual(oldValue, value, new WeakMap()))
+                        return receiver;
+                    target.set(key, value);
+                    const newSize = target.size;
+                    const pathKey = path.join('.');
+                    let cachedPath = getPathConcat(pathKey);
+                    if (cachedPath === undefined) {
+                        cachedPath = path;
+                        setPathConcat(pathKey, cachedPath);
+                    }
+                    const event = {
+                        action: 'map-set',
+                        path: cachedPath,
+                        key,
+                        oldValue,
+                        newValue: value
+                    };
+                    emit(event);
+                    if (!existed) {
+                        trigger(target, Symbol.iterator);
+                        if (oldSize !== newSize) {
+                            trigger(target, 'size');
+                        }
+                    }
+                    else {
+                        trigger(target, String(key));
+                    }
+                    return receiver;
+                };
+            }
+            if (prop === 'delete') {
+                return function (key) {
+                    const existed = target.has(key);
+                    if (!existed)
+                        return false;
+                    const oldValue = target.get(key);
+                    const oldSize = target.size;
+                    const result = target.delete(key);
+                    const newSize = target.size;
+                    if (result) {
+                        const pathKey = path.join('.');
+                        let cachedPath = getPathConcat(pathKey);
+                        if (cachedPath === undefined) {
+                            cachedPath = path;
+                            setPathConcat(pathKey, cachedPath);
+                        }
+                        const event = {
+                            action: 'map-delete',
+                            path: cachedPath,
+                            key,
+                            oldValue
+                        };
+                        emit(event);
+                        trigger(target, Symbol.iterator);
+                        if (oldSize !== newSize) {
+                            trigger(target, 'size');
+                        }
+                    }
+                    return result;
+                };
+            }
+            if (prop === 'clear') {
+                return function () {
+                    const oldSize = target.size;
+                    if (oldSize === 0)
+                        return;
+                    target.clear();
+                    const newSize = target.size;
+                    const event = {
+                        action: 'map-clear',
+                        path: path,
+                        key: null
+                    };
+                    emit(event);
+                    // Clear triggers both iterator and size
+                    trigger(target, Symbol.iterator);
+                    if (oldSize !== newSize) {
+                        trigger(target, 'size');
+                    }
+                };
+            }
+            if (prop === 'get') {
+                // Return function that tracks the specific key upon execution
+                return function (key) {
+                    // Track access to this specific key when 'get' is called
+                    track(target, String(key));
+                    const value = target.get(key);
+                    if (!value || typeof value !== 'object')
+                        return value; // Fast path for non-objects
+                    // Check wrapper cache for the value
+                    const cachedValueProxy = wrapperCache.get(value);
+                    if (cachedValueProxy)
+                        return cachedValueProxy;
+                    // Calculate path for the value
+                    const keyString = String(key);
+                    const pathKey = path.length > 0 ? `${path.join('.')}.${keyString}` : keyString;
+                    let newPath = getPathConcat(pathKey);
+                    if (newPath === undefined) {
+                        newPath = path.concat(keyString);
+                        setPathConcat(pathKey, newPath);
+                    }
+                    // Wrap based on type (no longer passing seen)
+                    if (value instanceof Map)
+                        return wrapMap(value, emit, newPath);
+                    if (value instanceof Set)
+                        return wrapSet(value, emit, newPath);
+                    if (Array.isArray(value))
+                        return wrapArray(value, emit, newPath);
+                    if (value instanceof Date)
+                        return new Date(value.getTime()); // Dates are not proxied
+                    // Default to reactive for plain objects
+                    return reactive(value, emit, newPath);
+                };
+            }
+            if (prop === 'has') {
+                // Track dependency on iteration/structure when 'has' is accessed
+                track(target, Symbol.iterator);
+                return function (key) {
+                    // Track specific key when 'has' is called
+                    track(target, String(key));
+                    return target.has(key);
+                }.bind(target); // Bind to original target for correct 'this'
+            }
+            // --- Iteration Methods ---
+            if (prop === Symbol.iterator || prop === 'entries' || prop === 'values' || prop === 'keys' || prop === 'forEach') {
+                // Track dependency on iteration when these methods are accessed
+                track(target, Symbol.iterator);
+                const originalMethod = Reflect.get(target, prop, receiver);
+                // Return custom iterators/forEach that wrap values
+                if (prop === 'forEach') {
+                    return (callbackfn, thisArg) => {
+                        // Use proxied .entries() to get wrapped values + tracking
+                        const entriesIterator = proxy.entries();
+                        for (const [key, value] of entriesIterator) {
+                            callbackfn.call(thisArg, value, key, proxy);
+                        }
+                    };
+                }
+                // Handle Symbol.iterator, entries, values, keys
+                return function* (...args) {
+                    const iterator = originalMethod.apply(target, args);
+                    for (const entry of iterator) {
+                        let keyToWrap = entry; // Default for keys()
+                        let valueToWrap = entry; // Default for values()
+                        let isEntry = false;
+                        if (prop === 'entries' || prop === Symbol.iterator) {
+                            keyToWrap = entry[0];
+                            valueToWrap = entry[1];
+                            isEntry = true;
+                        }
+                        // Wrap key if object
+                        let wrappedKey = keyToWrap;
+                        if (isEntry && keyToWrap && typeof keyToWrap === 'object') {
+                            const pathKey = path.length > 0 ? `${path.join('.')}.${String(keyToWrap)}` : String(keyToWrap); // Or find better key path?
+                            let keyPath = getPathConcat(pathKey); // Reuse paths where possible
+                            if (keyPath === undefined) {
+                                keyPath = path.concat(String(keyToWrap)); // Simplification for key path
+                                setPathConcat(pathKey, keyPath);
+                            }
+                            // TODO: Decide if Map keys should be deeply reactive
+                            wrappedKey = reactive(keyToWrap, emit, keyPath);
+                        }
+                        // Wrap value if object
+                        let wrappedValue = valueToWrap;
+                        if (valueToWrap && typeof valueToWrap === 'object') {
+                            const cachedValueProxy = wrapperCache.get(valueToWrap);
+                            if (cachedValueProxy) {
+                                wrappedValue = cachedValueProxy;
+                            }
+                            else {
+                                const keyString = String(keyToWrap);
+                                const pathKey = path.length > 0 ? `${path.join('.')}.${keyString}` : keyString;
+                                let newPath = getPathConcat(pathKey);
+                                if (newPath === undefined) {
+                                    newPath = path.concat(keyString);
+                                    setPathConcat(pathKey, newPath);
+                                }
+                                if (valueToWrap instanceof Map)
+                                    wrappedValue = wrapMap(valueToWrap, emit, newPath);
+                                else if (valueToWrap instanceof Set)
+                                    wrappedValue = wrapSet(valueToWrap, emit, newPath);
+                                else if (Array.isArray(valueToWrap))
+                                    wrappedValue = wrapArray(valueToWrap, emit, newPath);
+                                else if (valueToWrap instanceof Date)
+                                    wrappedValue = new Date(valueToWrap.getTime());
+                                else
+                                    wrappedValue = reactive(valueToWrap, emit, newPath);
+                            }
+                        }
+                        // Yield based on iterator type
+                        if (prop === 'entries' || prop === Symbol.iterator) {
+                            yield [wrappedKey, wrappedValue];
+                        }
+                        else if (prop === 'values') {
+                            yield wrappedValue;
+                        }
+                        else { // keys
+                            yield wrappedKey;
+                        }
+                    }
+                };
+            }
+            // --- Size Property ---
+            if (prop === 'size') {
+                // Explicitly track size access
+                track(target, 'size');
+                // Return the size directly from the target to avoid potential 'this' issues with Reflect.get
+                return target.size;
+            }
+            // --- Fallback for other properties/methods ---
+            const value = Reflect.get(target, prop, receiver);
+            // For non-function properties or bound functions, return the value as is.
+            return value;
+        }
+    });
+    // Cache the newly created proxy before returning
+    wrapperCache.set(map, proxy);
+    return proxy;
+}

package/dist/wrapSet.d.ts

@@ -0,0 +1,2 @@
+import { EmitFunction, Path } from './types';
+export declare function wrapSet<T>(set: Set<T>, emit: EmitFunction, path: Path): Set<T>;

package/dist/wrapSet.js

@@ -0,0 +1,184 @@
+import { getPathConcat, setPathConcat, wrapperCache } from './utils';
+import { reactive } from './reactive';
+import { wrapArray } from './wrapArray';
+import { wrapMap } from './wrapMap';
+import { track, trigger } from './watchEffect';
+export function wrapSet(set, emit, path) {
+    // Check wrapper cache first
+    const cachedProxy = wrapperCache.get(set);
+    if (cachedProxy)
+        return cachedProxy;
+    const proxy = new Proxy(set, {
+        get(target, prop, receiver) {
+            // Original track call
+            track(target, prop);
+            if (prop === 'add') {
+                return function (value) {
+                    const existed = target.has(value);
+                    const oldSize = target.size;
+                    if (!existed) {
+                        target.add(value);
+                        const newSize = target.size;
+                        const event = {
+                            action: 'set-add',
+                            path: path,
+                            value: value
+                        };
+                        emit(event);
+                        trigger(target, Symbol.iterator);
+                        if (oldSize !== newSize) {
+                            trigger(target, 'size');
+                        }
+                    }
+                    return receiver;
+                };
+            }
+            if (prop === 'delete') {
+                return function (value) {
+                    const existed = target.has(value);
+                    const oldSize = target.size;
+                    if (existed) {
+                        const oldValue = value; // The value being deleted is the oldValue
+                        const result = target.delete(value);
+                        const newSize = target.size;
+                        if (result) {
+                            const event = {
+                                action: 'set-delete',
+                                path: path,
+                                value: value, // value being deleted
+                                oldValue: oldValue // Add oldValue to the event
+                            };
+                            emit(event);
+                            trigger(target, Symbol.iterator);
+                            if (oldSize !== newSize) {
+                                trigger(target, 'size');
+                            }
+                        }
+                        return result;
+                    }
+                    return false;
+                };
+            }
+            if (prop === 'clear') {
+                return function () {
+                    const oldSize = target.size;
+                    if (oldSize === 0)
+                        return;
+                    target.clear();
+                    const newSize = target.size;
+                    const event = {
+                        action: 'set-clear', // Create 'set-clear' action
+                        path: path,
+                        value: null
+                    };
+                    emit(event);
+                    // Clear triggers both iterator and size
+                    trigger(target, Symbol.iterator);
+                    if (oldSize !== newSize) {
+                        trigger(target, 'size');
+                    }
+                };
+            }
+            if (prop === 'has') {
+                // 'has' depends on the specific value and iteration/size
+                track(target, Symbol.iterator); // Track iteration implicitly
+                return function (value) {
+                    // Also track the specific value when 'has' is called
+                    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'symbol') {
+                        track(target, String(value));
+                    }
+                    // How to track non-primitive values?
+                    // We might need a different strategy for object keys in Sets/Maps if deep reactivity on keys is needed
+                    return target.has(value);
+                }.bind(target); // Bind to original target
+            }
+            // Handle iteration methods - custom implementation already tracks
+            if (prop === 'values' || prop === Symbol.iterator || prop === 'entries' || prop === 'keys' || prop === 'forEach') {
+                // Track dependency on iteration
+                track(target, Symbol.iterator);
+                const originalMethod = Reflect.get(target, prop, receiver);
+                // Return a function that yields wrapped values (or calls forEach)
+                if (prop === 'forEach') {
+                    return (callbackfn, thisArg) => {
+                        // Simplified forEach based on values iterator
+                        const valuesIterator = proxy.values(); // Use the proxied values() to get wrapped values + tracking
+                        for (const value of valuesIterator) {
+                            callbackfn.call(thisArg, value, value, proxy);
+                        }
+                    };
+                }
+                // Handle Symbol.iterator, values, keys, entries
+                return function* (...args) {
+                    let index = 0; // Index for path generation
+                    const iterator = originalMethod.apply(target, args);
+                    for (const entry of iterator) {
+                        let valueToWrap = entry; // Default for values(), keys()
+                        let mapKey = undefined; // For entries()
+                        // For entries(), the entry is [key, value]
+                        if (prop === 'entries') {
+                            mapKey = entry[0];
+                            valueToWrap = entry[1];
+                        }
+                        // Track access to each element during iteration
+                        track(target, String(index));
+                        let wrappedValue = valueToWrap;
+                        if (valueToWrap && typeof valueToWrap === 'object') {
+                            // Check wrapper cache first
+                            const cachedValueProxy = wrapperCache.get(valueToWrap);
+                            if (cachedValueProxy) {
+                                wrappedValue = cachedValueProxy;
+                            }
+                            else {
+                                // Calculate path using index (or mapKey if available and primitive)
+                                const keyForPath = (mapKey !== undefined && (typeof mapKey !== 'object') ? String(mapKey) : String(index));
+                                const pathKey = path.length > 0 ? `${path.join('.')}.${keyForPath}` : keyForPath;
+                                let newPath = getPathConcat(pathKey);
+                                if (newPath === undefined) {
+                                    newPath = path.concat(keyForPath);
+                                    setPathConcat(pathKey, newPath);
+                                }
+                                // Wrap based on type
+                                if (valueToWrap instanceof Map)
+                                    wrappedValue = wrapMap(valueToWrap, emit, newPath);
+                                else if (valueToWrap instanceof Set)
+                                    wrappedValue = wrapSet(valueToWrap, emit, newPath);
+                                else if (Array.isArray(valueToWrap))
+                                    wrappedValue = wrapArray(valueToWrap, emit, newPath);
+                                else if (valueToWrap instanceof Date)
+                                    wrappedValue = new Date(valueToWrap.getTime());
+                                else
+                                    wrappedValue = reactive(valueToWrap, emit, newPath);
+                                // Note: We don't cache the *wrapped* value here, wrap functions handle caching
+                            }
+                        }
+                        // Yield the original or wrapped value/entry
+                        if (prop === 'entries') {
+                            yield [mapKey, wrappedValue];
+                        }
+                        else {
+                            yield wrappedValue;
+                        }
+                        index++;
+                    }
+                };
+            }
+            if (prop === 'size') {
+                // Explicitly track size access
+                track(target, 'size');
+                // Return the size directly from the target to avoid potential 'this' issues with Reflect.get
+                return target.size;
+            }
+            // Fallback for other properties (should be minimal for Set)
+            const value = Reflect.get(target, prop, receiver);
+            // REMOVED - Tracking handled above
+            // if (prop === 'size') { ... }
+            // If the property is a function (and not handled above), return it directly.
+            // Reflect.get preserves the correct 'this' binding (receiver).
+            // REMOVED: return value.bind(target);
+            return value;
+        }
+    });
+    // Cache the newly created proxy before returning
+    wrapperCache.set(set, proxy);
+    return proxy;
+}