@yiin/reactive-proxy-state 1.0.12 → 1.0.13

package/dist/wrap-array.js

@@ -1,237 +0,0 @@
-import { deepEqual, getPathConcat, setPathConcat, wrapperCache } from './utils';
-import { reactive } from './reactive';
-import { wrapMap } from './wrap-map';
-import { wrapSet } from './wrap-set';
-import { track, trigger } from './watch-effect';
-// avoid repeated typeof checks
-function isObject(v) {
-    return v && typeof v === 'object';
-}
-export function wrapArray(arr, emit, path) {
-    // reuse existing proxy if available for performance
-    const cachedProxy = wrapperCache.get(arr);
-    if (cachedProxy)
-        return cachedProxy;
-    // cache for wrapped methods to avoid re-creating them on each call
-    const methodCache = {};
-    const proxy = new Proxy(arr, {
-        get(target, prop, receiver) {
-            track(target, prop);
-            if (methodCache[prop]) {
-                return methodCache[prop];
-            }
-            // handle specific array mutation methods that require custom logic and event emission
-            switch (prop) {
-                case 'push':
-                    track(target, 'length');
-                    methodCache[prop] = 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;
-                    };
-                    return methodCache[prop];
-                case 'pop':
-                    track(target, 'length');
-                    methodCache[prop] = 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;
-                    };
-                    return methodCache[prop];
-                case 'shift':
-                    track(target, 'length');
-                    methodCache[prop] = 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;
-                    };
-                    return methodCache[prop];
-                case 'unshift':
-                    track(target, 'length');
-                    methodCache[prop] = 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;
-                    };
-                    return methodCache[prop];
-                case 'splice':
-                    track(target, 'length');
-                    methodCache[prop] = 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;
-                    };
-                    return methodCache[prop];
-                // handle methods that rely on iteration state
-                case Symbol.iterator:
-                case 'values':
-                case 'keys':
-                case 'entries':
-                case 'forEach':
-                case 'map':
-                case 'filter':
-                case 'reduce':
-                case 'reduceRight':
-                case 'find':
-                case 'findIndex':
-                case 'every':
-                case 'some':
-                case 'join':
-                    track(target, Symbol.iterator);
-                    // fall through to default behavior (usually binding)
-                    break;
-                case 'length':
-                    track(target, 'length');
-                    return Reflect.get(target, prop, receiver);
-            }
-            const value = Reflect.get(target, prop, receiver);
-            // determine if the property access is numeric array index access
-            const isNumericIndex = typeof prop === 'number' || (typeof prop === 'string' && !isNaN(parseInt(prop, 10)));
-            if (isNumericIndex) {
-                track(target, String(prop));
-                if (!isObject(value))
-                    return value;
-                // reuse existing proxy for nested object/array if available
-                const cachedValueProxy = wrapperCache.get(value);
-                if (cachedValueProxy)
-                    return cachedValueProxy;
-                // calculate the nested path for the element, optimizing with caching
-                const propKey = String(prop);
-                const pathKey = path.length > 0 ? `${path.join('.')}.${propKey}` : propKey;
-                let newPath = getPathConcat(pathKey);
-                if (newPath === undefined) {
-                    newPath = path.concat(propKey);
-                    setPathConcat(pathKey, newPath);
-                }
-                // recursively wrap nested structures
-                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, return a copy
-                return reactive(value, emit, newPath);
-            }
-            // ensure functions accessed directly are bound to the original target
-            if (typeof value === 'function') {
-                return value.bind(target);
-            }
-            return value;
-        },
-        set(target, prop, value, receiver) {
-            const oldValue = target[prop];
-            // avoid unnecessary triggers if value hasn't changed
-            if (oldValue === value)
-                return true;
-            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))));
-            // emit event and trigger effects only if the set was successful and wasn't intercepted by a setter
-            // (unless it's a direct numeric index set, which doesn't have a descriptor.set)
-            if (result && (!descriptor || !descriptor.set || isNumericIndex)) {
-                const propKey = String(prop);
-                const pathKey = path.length > 0 ? `${path.join('.')}.${propKey}` : propKey;
-                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/wrap-map.js

@@ -1,252 +0,0 @@
-import { deepEqual, getPathConcat, setPathConcat, wrapperCache } from './utils';
-import { reactive } from './reactive';
-import { wrapArray } from './wrap-array';
-import { wrapSet } from './wrap-set';
-import { track, trigger } from './watch-effect';
-export function wrapMap(map, emit, path) {
-    // reuse existing proxy if available for performance
-    const cachedProxy = wrapperCache.get(map);
-    if (cachedProxy)
-        return cachedProxy;
-    // cache for wrapped methods to avoid re-creating them on each call
-    const methodCache = {};
-    const proxy = new Proxy(map, {
-        get(target, prop, receiver) {
-            track(target, prop);
-            // iteration methods need to track the iterator symbol on every access
-            // to re-establish dependency after effect cleanup, even when cached
-            if (prop === Symbol.iterator || prop === 'entries' || prop === 'values' || prop === 'keys' || prop === 'forEach') {
-                track(target, Symbol.iterator);
-            }
-            if (methodCache[prop]) {
-                return methodCache[prop];
-            }
-            if (prop === 'set') {
-                methodCache[prop] = function (key, value) {
-                    const existed = target.has(key);
-                    const oldValue = target.get(key);
-                    const oldSize = target.size;
-                    // avoid unnecessary work if value hasn't changed
-                    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;
-                    // optimize path calculation by caching concatenated paths
-                    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);
-                    // trigger effects based on whether it was an add or update
-                    if (!existed) {
-                        trigger(target, Symbol.iterator);
-                        if (oldSize !== newSize) {
-                            trigger(target, 'size');
-                        }
-                    }
-                    else {
-                        trigger(target, String(key));
-                    }
-                    return receiver;
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'delete') {
-                methodCache[prop] = 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) { // only emit and trigger if delete was successful
-                        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');
-                        }
-                        trigger(target, String(key));
-                    }
-                    return result;
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'clear') {
-                methodCache[prop] = 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);
-                    trigger(target, Symbol.iterator);
-                    if (oldSize !== newSize) {
-                        trigger(target, 'size');
-                    }
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'get') {
-                // return a function that tracks the specific key only when called
-                methodCache[prop] = function (key) {
-                    track(target, String(key));
-                    const value = target.get(key);
-                    if (!value || typeof value !== 'object')
-                        return value;
-                    const cachedValueProxy = wrapperCache.get(value);
-                    if (cachedValueProxy)
-                        return cachedValueProxy;
-                    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);
-                    }
-                    // recursively wrap nested structures
-                    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, return a copy
-                    return reactive(value, emit, newPath);
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'has') {
-                track(target, Symbol.iterator);
-                methodCache[prop] = function (key) {
-                    // track the specific key only when 'has' is called
-                    track(target, String(key));
-                    return target.has(key);
-                }.bind(target); // bind is still okay here, doesn't interfere with caching
-                return methodCache[prop];
-            }
-            // handle iteration methods
-            if (prop === Symbol.iterator || prop === 'entries' || prop === 'values' || prop === 'keys' || prop === 'forEach') {
-                track(target, Symbol.iterator);
-                const originalMethod = Reflect.get(target, prop, receiver);
-                // return custom iterators/foreach that wrap values during iteration
-                if (prop === 'forEach') {
-                    methodCache[prop] = (callbackfn, thisArg) => {
-                        // use the proxied .entries() to ensure values passed to callback are wrapped and tracked
-                        const entriesIterator = proxy.entries();
-                        for (const [key, value] of entriesIterator) {
-                            callbackfn.call(thisArg, value, key, proxy);
-                        }
-                    };
-                    return methodCache[prop];
-                }
-                // handle symbol.iterator, entries, values, keys by creating generator functions
-                methodCache[prop] = function* (...args) {
-                    const iterator = originalMethod.apply(target, args);
-                    for (const entry of iterator) {
-                        let keyToWrap = entry;
-                        let valueToWrap = entry;
-                        let isEntry = false;
-                        if (prop === 'entries' || prop === Symbol.iterator) {
-                            keyToWrap = entry[0];
-                            valueToWrap = entry[1];
-                            isEntry = true;
-                        }
-                        // wrap key if it's an object
-                        // note: reactivity on map keys can be complex/unexpected
-                        let wrappedKey = keyToWrap;
-                        if (isEntry && keyToWrap && typeof keyToWrap === 'object') {
-                            const pathKey = path.length > 0 ? `${path.join('.')}.${String(keyToWrap)}` : String(keyToWrap);
-                            let keyPath = getPathConcat(pathKey);
-                            if (keyPath === undefined) {
-                                keyPath = path.concat(String(keyToWrap));
-                                setPathConcat(pathKey, keyPath);
-                            }
-                            // todo: decide if map keys should be deeply reactive
-                            wrappedKey = reactive(keyToWrap, emit, keyPath);
-                        }
-                        // wrap value if it's an object
-                        let wrappedValue = valueToWrap;
-                        if (valueToWrap && typeof valueToWrap === 'object') {
-                            const cachedValueProxy = wrapperCache.get(valueToWrap);
-                            if (cachedValueProxy) {
-                                wrappedValue = cachedValueProxy;
-                            }
-                            else {
-                                const keyString = String(keyToWrap); // use original key for path
-                                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);
-                            }
-                        }
-                        if (prop === 'entries' || prop === Symbol.iterator) {
-                            yield [wrappedKey, wrappedValue];
-                        }
-                        else if (prop === 'values') {
-                            yield wrappedValue;
-                        }
-                        else { // keys
-                            yield wrappedKey;
-                        }
-                    }
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'size') {
-                track(target, 'size');
-                return target.size;
-            }
-            const value = Reflect.get(target, prop, receiver);
-            // Bind plain functions accessed directly (e.g., toString)
-            if (typeof value === 'function') {
-                return value.bind(target);
-            }
-            return value;
-        }
-    });
-    // cache the newly created proxy before returning
-    wrapperCache.set(map, proxy);
-    return proxy;
-}

package/dist/wrap-set.js

@@ -1,182 +0,0 @@
-import { getPathConcat, setPathConcat, wrapperCache } from './utils';
-import { reactive } from './reactive';
-import { wrapArray } from './wrap-array';
-import { wrapMap } from './wrap-map';
-import { track, trigger } from './watch-effect';
-export function wrapSet(set, emit, path) {
-    // reuse existing proxy if available for performance
-    const cachedProxy = wrapperCache.get(set);
-    if (cachedProxy)
-        return cachedProxy;
-    // cache for wrapped methods to avoid re-creating them on each call
-    const methodCache = {};
-    const proxy = new Proxy(set, {
-        get(target, prop, receiver) {
-            track(target, prop);
-            if (methodCache[prop]) {
-                return methodCache[prop];
-            }
-            if (prop === 'add') {
-                methodCache[prop] = function (value) {
-                    const existed = target.has(value);
-                    const oldSize = target.size;
-                    // only add and trigger if the value doesn't already exist
-                    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; // return the proxy itself for chaining
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'delete') {
-                methodCache[prop] = function (value) {
-                    const existed = target.has(value);
-                    const oldSize = target.size;
-                    if (existed) {
-                        const oldValue = value;
-                        const result = target.delete(value);
-                        const newSize = target.size;
-                        if (result) { // only emit and trigger if delete was successful
-                            const event = {
-                                action: 'set-delete',
-                                path: path,
-                                value: value,
-                                oldValue: oldValue
-                            };
-                            emit(event);
-                            trigger(target, Symbol.iterator);
-                            if (oldSize !== newSize) {
-                                trigger(target, 'size');
-                            }
-                        }
-                        return result;
-                    }
-                    return false;
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'clear') {
-                methodCache[prop] = function () {
-                    const oldSize = target.size;
-                    if (oldSize === 0)
-                        return;
-                    target.clear();
-                    const newSize = target.size;
-                    const event = {
-                        action: 'set-clear',
-                        path: path,
-                        value: null
-                    };
-                    emit(event);
-                    trigger(target, Symbol.iterator);
-                    if (oldSize !== newSize) {
-                        trigger(target, 'size');
-                    }
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'has') {
-                track(target, Symbol.iterator);
-                methodCache[prop] = function (value) {
-                    // track specific primitive value when 'has' is called
-                    // tracking object values for existence is complex and less common, handled by iteration track
-                    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'symbol') {
-                        track(target, String(value));
-                    }
-                    return target.has(value);
-                }.bind(target); // bind is still okay here, doesn't interfere with caching
-                return methodCache[prop];
-            }
-            // handle iteration methods
-            if (prop === 'values' || prop === Symbol.iterator || prop === 'entries' || prop === 'keys' || prop === 'forEach') {
-                track(target, Symbol.iterator);
-                const originalMethod = Reflect.get(target, prop, receiver);
-                // return custom iterators/foreach that wrap values during iteration
-                if (prop === 'forEach') {
-                    methodCache[prop] = (callbackfn, thisArg) => {
-                        // use the proxied values() to ensure values passed to callback are wrapped and tracked
-                        const valuesIterator = proxy.values();
-                        for (const value of valuesIterator) {
-                            callbackfn.call(thisArg, value, value, proxy);
-                        }
-                    };
-                    return methodCache[prop];
-                }
-                // handle symbol.iterator, values, keys, entries by creating generator functions
-                methodCache[prop] = function* (...args) {
-                    let index = 0; // use index for path generation if value is not primitive
-                    const iterator = originalMethod.apply(target, args);
-                    for (const entry of iterator) {
-                        let valueToWrap = entry;
-                        let mapKey = undefined; // key for entries() which yields [value, value]
-                        if (prop === 'entries') {
-                            mapKey = entry[0]; // for Set.entries(), key and value are the same
-                            valueToWrap = entry[1];
-                        }
-                        track(target, String(index));
-                        let wrappedValue = valueToWrap;
-                        if (valueToWrap && typeof valueToWrap === 'object') {
-                            const cachedValueProxy = wrapperCache.get(valueToWrap);
-                            if (cachedValueProxy) {
-                                wrappedValue = cachedValueProxy;
-                            }
-                            else {
-                                // calculate path using index as key, as set values don't have inherent keys
-                                const keyForPath = 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);
-                                }
-                                // recursively wrap nested structures
-                                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()); // dates are not proxied, return copy
-                                else
-                                    wrappedValue = reactive(valueToWrap, emit, newPath);
-                            }
-                        }
-                        if (prop === 'entries') {
-                            yield [wrappedValue, wrappedValue]; // set entries yield [value, value]
-                        }
-                        else {
-                            yield wrappedValue;
-                        }
-                        index++;
-                    }
-                };
-                return methodCache[prop];
-            }
-            if (prop === 'size') {
-                track(target, 'size');
-                return target.size;
-            }
-            const value = Reflect.get(target, prop, receiver);
-            // Bind plain functions accessed directly (e.g., toString)
-            if (typeof value === 'function') {
-                return value.bind(target);
-            }
-            return value;
-        }
-    });
-    // cache the newly created proxy before returning
-    wrapperCache.set(set, proxy);
-    return proxy;
-}

package/dist/wrapArray.d.ts

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