@slimlib/store 2.0.0 → 2.0.2

package/index.mjs

@@ -0,0 +1,825 @@
+import { DEV } from 'esm-env';
+
+let activeScope;
+
+const setActiveScope = (scope) => {
+    activeScope = scope;
+};
+
+let scheduler = queueMicrotask;
+
+const setScheduler = (newScheduler) => {
+    scheduler = newScheduler;
+};
+
+const [unwrap, propertyDepsSymbol, trackSymbol, childrenSymbol,
+
+] = Array.from([, , , ,], Symbol);
+
+const noopGetter = () => undefined;
+
+class DepsSet extends Set {
+    a = 0;
+    b;
+    constructor(getter) {
+        super();
+        this.b = getter;
+    }
+}
+
+const createSourceEntry = (dependents, node, version, getter, storedValue) => ({
+    c: dependents,
+    d: node,
+    a: version,
+    b: getter,
+    e: storedValue,
+});
+let flushScheduled = false;
+
+let globalVersion = 1;
+const batched = [];
+let lastAddedId = 0;
+let needsSort = false;
+
+let currentComputing;
+let tracked = true;
+
+const setTracked = (value) => {
+    tracked = value;
+};
+
+const batchedAdd = (node) => {
+    const nodeId = node.f;
+
+    if (nodeId < lastAddedId) {
+        needsSort = true;
+    }
+    lastAddedId = nodeId;
+    batched.push(node);
+};
+
+const batchedAddNew = (node, effectId) => {
+    lastAddedId = effectId;
+    batched.push(node);
+};
+
+const unwrapValue = (value) => (value !== null &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    value[unwrap]) ||
+    value;
+
+const makeLive = (node) => {
+    node.g |= 64 ;
+    const nodeSources = node.h;
+    for (let i = 0, len = nodeSources.length; i < len; ++i) {
+        const { c: c, d: sourceNode } = nodeSources[i];
+        c.add(node);
+        if (sourceNode !== undefined && (sourceNode.g & (8  | 64 )) === 0) {
+            makeLive(sourceNode);
+        }
+    }
+};
+
+const makeNonLive = (node) => {
+    node.g &= -65 ;
+    const nodeSources = node.h;
+    for (let i = 0, len = nodeSources.length; i < len; ++i) {
+        const { c: c, d: sourceNode } = nodeSources[i];
+        c.delete(node);
+
+        if (sourceNode !== undefined &&
+            (sourceNode.g & (8  | 64 )) === 64  &&
+            sourceNode.i.size === 0) {
+            makeNonLive(sourceNode);
+        }
+    }
+};
+
+const clearSources = (node, fromIndex = 0) => {
+    const isLive = (node.g & (8  | 64 )) !== 0;
+    const nodeSources = node.h;
+    for (let i = fromIndex, len = nodeSources.length; i < len; ++i) {
+        const { c: c, d: sourceNode } = nodeSources[i];
+
+        let retained = false;
+        for (let j = 0; j < fromIndex && !retained; ++j) {
+            retained = nodeSources[j].c === c;
+        }
+        if (!retained) {
+
+            c.delete(node);
+
+            if (isLive &&
+                sourceNode !== undefined &&
+                (sourceNode.g & (8  | 64 )) === 64  &&
+                sourceNode.i.size === 0) {
+                makeNonLive(sourceNode);
+            }
+        }
+    }
+    nodeSources.length = fromIndex;
+};
+
+const flushEffects = () => {
+    flushScheduled = false;
+
+    const nodes = batched.slice();
+    batched.length = 0;
+    if (needsSort) {
+        nodes.sort((a, b) => a.f - b.f);
+    }
+    lastAddedId = 0;
+    needsSort = false;
+
+    for (let i = 0, len = nodes.length; i < len; ++i) {
+        const node = nodes[i];
+        try {
+            node.j?.();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+};
+
+const scheduleFlush = () => {
+    if (!flushScheduled) {
+        flushScheduled = true;
+        scheduler(flushEffects);
+    }
+};
+
+const trackStateDependency = (deps, valueGetter, cachedValue) => {
+
+    const sourcesArray = currentComputing.h;
+    const skipIndex = currentComputing.k;
+    const existing = sourcesArray[skipIndex];
+    const noSource = existing === undefined;
+    if (noSource || existing.c !== deps) {
+
+        if (!noSource) {
+            clearSources(currentComputing, skipIndex);
+        }
+
+        sourcesArray.push(createSourceEntry(deps, undefined, deps.a, valueGetter, cachedValue));
+
+        currentComputing.g |= 128 ;
+
+        if ((currentComputing.g & (8  | 64 )) !== 0) {
+            deps.add(currentComputing);
+        }
+    }
+    else {
+
+        const entry = sourcesArray[skipIndex];
+        entry.a = deps.a;
+        entry.b = valueGetter;
+        entry.e = cachedValue;
+
+        currentComputing.g |= 128 ;
+    }
+    ++currentComputing.k;
+};
+
+const markNeedsCheck = (node) => {
+    const flags = node.g;
+
+    if ((flags & (4  | 1  | 2 )) !== 0) {
+
+        if ((flags & (4  | 8  | 1 )) === (4  | 8 )) {
+            node.g = flags | 1 ;
+            batchedAdd(node);
+            scheduleFlush();
+        }
+        return;
+    }
+
+    node.g = flags | 2 ;
+    if ((flags & 8 ) !== 0) {
+        batchedAdd(node);
+        scheduleFlush();
+    }
+    for (const dep of node.i) {
+        markNeedsCheck(dep);
+    }
+};
+
+const markDependents = (deps) => {
+    ++globalVersion;
+
+    ++deps.a;
+    for (const dep of deps) {
+        markNeedsCheck(dep);
+    }
+};
+
+const runWithTracking = (node, getter) => {
+
+    node.g = (node.g & -388) | 4 ;
+    node.k = 0;
+    const prev = currentComputing;
+    const prevTracked = tracked;
+    currentComputing = node;
+    tracked = true;
+    try {
+        return getter();
+    }
+    finally {
+        currentComputing = prev;
+        tracked = prevTracked;
+
+        const flags = (node.g &= -5 );
+        const nodeSources = node.h;
+        const skipped = node.k;
+        const nodeSourcesLength = nodeSources.length;
+
+        if ((flags & 256 ) !== 0) {
+            const updateLen = Math.min(skipped, nodeSourcesLength);
+            for (let i = 0; i < updateLen; ++i) {
+                const entry = nodeSources[i];
+                const entryNode = entry.d;
+                if (entryNode !== undefined) {
+                    entry.a = entryNode.a;
+                }
+            }
+        }
+
+        if (nodeSourcesLength > skipped) {
+            clearSources(node, skipped);
+        }
+    }
+};
+
+const untracked = (callback) => {
+    const prevTracked = tracked;
+    tracked = false;
+    try {
+        return callback();
+    }
+    finally {
+        tracked = prevTracked;
+    }
+};
+
+const checkComputedSources = (sourcesArray) => {
+    const prevTracked = tracked;
+    tracked = false;
+    const len = sourcesArray.length;
+    for (let i = 0; i < len; ++i) {
+        const sourceEntry = sourcesArray[i];
+        const sourceNode = sourceEntry.d;
+
+        try {
+            computedRead(sourceNode);
+        }
+        catch {
+
+            tracked = prevTracked;
+            return true;
+        }
+
+        if (sourceEntry.a !== sourceNode.a) {
+            tracked = prevTracked;
+            return true;
+        }
+    }
+    tracked = prevTracked;
+    return false;
+};
+
+const WARN_ON_WRITE_IN_COMPUTED = 1 << 0;
+
+const SUPPRESS_EFFECT_GC_WARNING = 1 << 1;
+
+const WARN_ON_UNTRACKED_EFFECT = 1 << 2;
+
+let debugConfigFlags = 0;
+
+const debugConfig = (flags) => {
+    debugConfigFlags = flags | 0;
+};
+
+const safeForEach = (fns) => {
+    for (let i = 0, len = fns.length; i < len; ++i) {
+        const fn = fns[i];
+        try {
+            fn?.();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+};
+
+const warnIfWriteInComputed = (context) => {
+    if (DEV && (debugConfigFlags & WARN_ON_WRITE_IN_COMPUTED) !== 0 && currentComputing && (currentComputing.g & 8 ) === 0) {
+        console.warn(`[@slimlib/store] Writing to ${context} inside a computed is not recommended. The computed will not automatically re-run when this value changes, which may lead to stale values.`);
+    }
+};
+
+const effectRegistry = DEV
+    ? new FinalizationRegistry((stackTrace) => {
+        if ((debugConfigFlags & SUPPRESS_EFFECT_GC_WARNING) === 0) {
+            console.warn(`[@slimlib/store] Effect was garbage collected without being disposed. This may indicate a memory leak. Effects should be disposed by calling the returned dispose function or by using a scope that is properly disposed.\n\nEffect was created at:\n${stackTrace}`);
+        }
+    })
+    : null;
+
+const registerEffect = DEV
+    ? () => {
+        const token = {};
+
+        const relevantStack = String(new Error().stack).split('\n').slice(3).join('\n');
+        effectRegistry.register(token, relevantStack, token);
+        return token;
+    }
+    : () => undefined;
+
+const unregisterEffect = DEV
+    ? (token) => {
+        effectRegistry?.unregister(token);
+    }
+    : () => { };
+
+const warnIfNoActiveScope = DEV
+    ? (activeScope) => {
+        if ((debugConfigFlags & WARN_ON_UNTRACKED_EFFECT) !== 0 && !activeScope) {
+            console.warn(`[@slimlib/store] Effect created without an active scope. Consider using scope() or setActiveScope() to track effects for proper lifecycle management.`);
+        }
+    }
+    : () => { };
+const cycleMessage = 'Detected cycle in computations.';
+
+function computedRead(self) {
+
+    if (tracked && currentComputing !== undefined) {
+
+        const consumerSources = currentComputing.h;
+        const skipIndex = currentComputing.k;
+        const deps = self.i;
+        const existing = consumerSources[skipIndex];
+        const noSource = existing === undefined;
+        if (noSource || existing.c !== deps) {
+
+            if (!noSource) {
+                clearSources(currentComputing, skipIndex);
+            }
+
+            consumerSources.push(createSourceEntry(deps, self, 0, undefined, undefined));
+
+            if ((currentComputing.g & (8  | 64 )) !== 0) {
+                deps.add(currentComputing);
+
+                if ((self.g & 64 ) === 0) {
+                    makeLive(self);
+                }
+            }
+        }
+
+        currentComputing.g |= 256 ;
+        ++currentComputing.k;
+    }
+    let flags = self.g;
+    const sourcesArray = self.h;
+
+    if ((flags & 4 ) !== 0) {
+        throw new Error(cycleMessage);
+    }
+
+    const hasCached = (flags & (16  | 32 )) !== 0;
+
+    checkCache: if ((flags & (1  | 2 )) === 0 && hasCached) {
+
+        if (self.f === globalVersion) {
+            if ((flags & 32 ) !== 0) {
+                throw self.l;
+            }
+            return self.l;
+        }
+
+        if ((flags & 64 ) === 0) {
+            let sourceChanged = false;
+
+            const prevTracked = tracked;
+
+            setTracked(false);
+            for (let i = 0, len = sourcesArray.length; i < len; ++i) {
+                const source = sourcesArray[i];
+                const sourceNode = source.d;
+                if (sourceNode === undefined) {
+
+                    const currentDepsVersion = source.c.a;
+                    if (source.a !== currentDepsVersion) {
+
+                        const storedValue = source.e;
+                        const storedType = typeof storedValue;
+                        if (storedValue === null || (storedType !== 'object' && storedType !== 'function')) {
+                            const currentValue = source.b();
+                            if (Object.is(currentValue, storedValue)) {
+
+                                source.a = currentDepsVersion;
+                                continue;
+                            }
+                        }
+
+                        sourceChanged = true;
+                        break;
+                    }
+                }
+                else {
+
+                    try {
+                        computedRead(sourceNode);
+                    }
+                    catch {
+
+                        sourceChanged = true;
+                        break;
+                    }
+                    if (source.a !== sourceNode.a) {
+                        sourceChanged = true;
+                        break;
+                    }
+                }
+            }
+            setTracked(prevTracked);
+            if (sourceChanged) {
+
+                self.g = flags |= 1 ;
+                break checkCache;
+            }
+
+            self.f = globalVersion;
+            if ((flags & 32 ) !== 0) {
+                throw self.l;
+            }
+            return self.l;
+        }
+    }
+
+    if ((flags & (1  | 2  | 128 )) === 2  && hasCached) {
+        if (checkComputedSources(sourcesArray)) {
+
+            flags = (flags & -3 ) | 1 ;
+        }
+        else {
+
+            self.g = flags & -3 ;
+
+            self.f = globalVersion;
+            if ((flags & 32 ) !== 0) {
+                throw self.l;
+            }
+            return self.l;
+        }
+    }
+
+    if ((flags & (1  | 2 )) !== 0) {
+        const wasDirty = (flags & 1 ) !== 0;
+        runWithTracking(self, () => {
+            try {
+                const newValue = self.j();
+
+                const changed = (flags & 16 ) === 0 || !self.m(self.l, newValue);
+                if (changed) {
+                    self.l = newValue;
+
+                    ++self.a;
+                    self.g = (self.g | 16 ) & ~32 ;
+
+                    for (const dep of self.i) {
+                        const depFlags = dep.g;
+                        if ((depFlags & (4  | 1  | 2 )) === 2 ) {
+                            dep.g = depFlags | 1 ;
+                        }
+                    }
+                }
+                else if (wasDirty) {
+                    self.g |= 16 ;
+                }
+
+                self.f = globalVersion;
+            }
+            catch (e) {
+
+                ++self.a;
+                self.l = e;
+                self.g = (self.g & ~16 ) | 32 ;
+                self.f = globalVersion;
+            }
+        });
+    }
+
+    if ((self.g & 32 ) !== 0) {
+        throw self.l;
+    }
+    return self.l;
+}
+
+const computed = (getter, equals = Object.is) => {
+    const node = {
+        h: [],
+        i: new DepsSet(noopGetter),
+        g: 1 ,
+        k: 0,
+        a: 0,
+        l: undefined,
+        f: 0,
+        j: getter,
+        m: equals,
+    };
+    return () => computedRead(node);
+};
+
+let effectCreationCounter = 0;
+
+const effect = (callback) => {
+    let disposed = false;
+
+    const gcToken = registerEffect();
+
+    warnIfNoActiveScope(activeScope);
+
+    let node;
+
+    const runner = () => {
+
+        if (disposed) {
+            return;
+        }
+
+        const flags = node.g;
+        if ((flags & 4 ) !== 0) {
+            throw new Error(cycleMessage);
+        }
+
+        if ((flags & (1  | 2  | 128 )) === 2 ) {
+
+            if (!checkComputedSources(node.h)) {
+                node.g = flags & -3 ;
+                return;
+            }
+        }
+
+        runWithTracking(node, () => {
+
+            if (typeof node.l === 'function') {
+                node.l();
+            }
+
+            node.l = callback();
+        });
+    };
+
+    node = {
+        h: [],
+        i: new DepsSet(noopGetter),
+        g: 1  | 8 ,
+        k: 0,
+        a: 0,
+        l: undefined,
+        f: ++effectCreationCounter,
+        j: runner,
+        m: Object.is,
+    };
+    const effectId = node.f;
+    const dispose = () => {
+
+        disposed = true;
+
+        unregisterEffect(gcToken);
+
+        if (typeof node.l === 'function') {
+            node.l();
+        }
+        clearSources(node);
+    };
+
+    if (activeScope) {
+        activeScope[trackSymbol](dispose);
+    }
+
+    batchedAddNew(node, effectId);
+    scheduleFlush();
+    return dispose;
+};
+
+const scope = (callback, parent = activeScope) => {
+    const effects = [];
+    const children = [];
+    const cleanups = [];
+    let disposed = false;
+    let myIndex = -1;
+
+    const onDispose = cleanup => {
+        if (disposed) {
+            return;
+        }
+        cleanups.push(cleanup);
+    };
+    const ctx = ((cb) => {
+        if (!cb) {
+
+            if (disposed) {
+                return;
+            }
+
+            disposed = true;
+
+            safeForEach(children);
+
+            safeForEach(effects);
+            effects.length = 0;
+
+            safeForEach(cleanups);
+
+            if (parent) {
+                parent[childrenSymbol][myIndex] = undefined;
+            }
+            return;
+        }
+
+        if (disposed) {
+            return ctx;
+        }
+
+        const prev = activeScope;
+        setActiveScope(ctx);
+        try {
+            cb(onDispose);
+        }
+        finally {
+            setActiveScope(prev);
+        }
+        return ctx;
+    });
+
+    ctx[trackSymbol] = (dispose) => effects.push(dispose);
+    ctx[childrenSymbol] = children;
+
+    if (parent) {
+        myIndex = parent[childrenSymbol].push(ctx) - 1;
+    }
+
+    if (callback) {
+        ctx(callback);
+    }
+    return ctx;
+};
+
+function signal(initialValue) {
+    let value = initialValue;
+    let deps;
+
+    const read = () => {
+
+        if (tracked && currentComputing !== undefined) {
+
+            trackStateDependency((deps ??= new DepsSet(read)), read, value);
+        }
+        return value;
+
+    };
+
+    read.set = (newValue) => {
+
+        warnIfWriteInComputed('signal');
+        if (!Object.is(value, newValue)) {
+            value = newValue;
+            if (deps !== undefined) {
+                markDependents(deps);
+            }
+        }
+
+    };
+    return read;
+}
+
+function state(object = {}) {
+
+    const proxiesCache = new WeakMap();
+
+    const notifyPropertyDependents = (target, property) => {
+        const propsMap = target[propertyDepsSymbol];
+        if (!propsMap)
+            return;
+        const deps = propsMap.get(property);
+        if (deps !== undefined) {
+            markDependents(deps);
+        }
+    };
+    const createProxy = (object) => {
+        if (proxiesCache.has(object)) {
+            return proxiesCache.get(object);
+        }
+        let methodCache;
+        const proxy = new Proxy(object, {
+
+            set(target, p, newValue) {
+                warnIfWriteInComputed('state');
+                const realValue = unwrapValue(newValue);
+
+                if (!Object.is(target[p], realValue)) {
+                    target[p] = realValue;
+
+                    notifyPropertyDependents(target, p);
+
+                    methodCache?.delete(p);
+                }
+                return true;
+            },
+
+            get(target, p) {
+                if (p === unwrap)
+                    return target;
+
+                const propValue = target[p];
+
+                if (tracked && currentComputing !== undefined) {
+
+                    let propsMap = target[propertyDepsSymbol];
+                    if (propsMap === undefined) {
+                        propsMap = new Map();
+                        Object.defineProperty(target, propertyDepsSymbol, { value: propsMap });
+                    }
+
+                    let deps = propsMap.get(p);
+                    if (deps === undefined) {
+
+                        const propertyGetter = () => target[p];
+
+                        propsMap.set(p, (deps = new DepsSet(propertyGetter)));
+                    }
+
+                    trackStateDependency(deps, deps.b, propValue);
+                }
+
+                const propertyType = typeof propValue;
+                if (propValue === null || (propertyType !== 'object' && propertyType !== 'function')) {
+                    return propValue;
+                }
+
+                if (propertyType === 'function') {
+
+                    if (methodCache === undefined) {
+                        methodCache = new Map();
+                    }
+                    let cached = methodCache.get(p);
+                    if (cached === undefined) {
+
+                        const method = propValue;
+                        cached = (...args) => {
+
+                            for (let i = 0, len = args.length; i < len; ++i) {
+                                args[i] = unwrapValue(args[i]);
+                            }
+                            const result = method.apply(target, args);
+
+                            if (currentComputing === undefined) {
+                                const propsMap = target[propertyDepsSymbol];
+                                if (propsMap === undefined)
+                                    return result;
+                                for (const deps of propsMap.values()) {
+
+                                    markDependents(deps);
+                                }
+                            }
+                            return result;
+                        };
+                        methodCache.set(p, cached);
+                    }
+                    return cached;
+                }
+
+                return createProxy(propValue);
+            },
+
+            defineProperty(target, property, attributes) {
+                warnIfWriteInComputed('state');
+                const result = Reflect.defineProperty(target, property, attributes);
+                if (result) {
+
+                    notifyPropertyDependents(target, property);
+                }
+                return result;
+            },
+
+            deleteProperty(target, p) {
+                warnIfWriteInComputed('state');
+                const result = Reflect.deleteProperty(target, p);
+                if (result) {
+
+                    notifyPropertyDependents(target, p);
+
+                    methodCache?.delete(p);
+                }
+                return result;
+            },
+        });
+        proxiesCache.set(object, proxy);
+        return proxy;
+    };
+    return createProxy(object);
+}
+
+export { SUPPRESS_EFFECT_GC_WARNING, WARN_ON_UNTRACKED_EFFECT, WARN_ON_WRITE_IN_COMPUTED, activeScope, computed, debugConfig, effect, flushEffects, scope, setActiveScope, setScheduler, signal, state, untracked, unwrapValue };