@mmstack/primitives 21.0.5 → 21.0.7

package/fesm2022/mmstack-primitives.mjs

@@ -228,7 +228,7 @@ function derived(source, optOrKey, opt) {
             return baseEqual(a, b);
         }
         : baseEqual;
-    const sig = toWritable(computed(() => from(source()), { ...rest, equal }), (newVal) => onChange(newVal));
+    const sig = toWritable(computed(() => from(source()), { ...rest, equal }), (newVal) => onChange(newVal), undefined, { pure: false });
     sig.from = from;
     if (isMutable(source)) {
         sig.mutate = (updater) => {
@@ -292,7 +292,6 @@ function isDerivation(sig) {
 function isWritableSignal(value) {
     return isWritableSignal$1(value);
 }
-
 /**
  * @internal
  * Creates a setter function for a source signal of type `Signal<T[]>` or a function returning `T[]`.
@@ -353,8 +352,11 @@ function indexArray(source, map, opt = {}) {
             if (len === prev.value.length)
                 return prev.value;
             if (len < prev.value.length) {
-                if (opt.onDestroy)
-                    prev.value.forEach((v) => opt.onDestroy?.(v));
+                if (opt.onDestroy) {
+                    for (let i = len; i < prev.value.length; i++) {
+                        opt.onDestroy(prev.value[i]);
+                    }
+                }
                 return prev.value.slice(0, len);
             }
             const next = prev.value.slice();
@@ -370,70 +372,183 @@ function indexArray(source, map, opt = {}) {
  */
 const mapArray = indexArray;
 
-function keyArray(source, keyFn, map, opt = {}) {
-    const data = isSignal(source) ? source : computed(source);
-    const setter = createSetter(data);
-    const writableData = isWritableSignal(data)
-        ? data
-        : toWritable(data, () => {
-            // noop
-        });
-    if (isWritableSignal(data) && isMutable(data) && !opt.equal) {
-        opt.equal = (a, b) => {
-            if (a !== b)
-                return false;
-            return false; // opt out for same refs
-        };
-    }
-    let freeMap = new Map();
-    const createRecord = (i) => {
-        const idx = signal(i, ...(ngDevMode ? [{ debugName: "idx" }] : []));
-        const value = derived(writableData, {
-            from: (v) => v[idx()],
-            onChange: (next) => setter(next, untracked(idx)),
-        }, opt);
-        return {
-            source: {
-                idx,
-                value,
-            },
-            computation: map(value, idx),
-        };
-    };
-    const internal = linkedSignal({ ...(ngDevMode ? { debugName: "internal" } : {}), source: () => writableData(),
-        computation: (src, prev) => {
-            const prevCache = prev?.value.cache ?? new Map();
-            const nextCache = freeMap;
-            const nextValues = [];
-            let changed = false;
-            for (let i = 0; i < src.length; i++) {
-                const k = untracked(() => keyFn(src[i]));
-                let record = prevCache.get(k);
-                if (!record) {
-                    changed = true;
-                    record = createRecord(i);
+/**
+ * Reactively maps items from a source array to a new array by value (identity).
+ *
+ * similar to `Array.prototype.map`, but:
+ * 1. The `mapFn` receives the `index` as a Signal.
+ * 2. If an item in the `source` array moves to a new position, the *result* of the map function is reused and moved.
+ *    The `index` signal is updated to the new index.
+ * 3. The `mapFn` is only run for *new* items.
+ *
+ * This is useful for building efficient lists where DOM nodes or heavy instances should be reused
+ * when the list is reordered.
+ *
+ * @param source A `Signal<T[]>` or a function returning `T[]`.
+ * @param mapFn The mapping function. Receives the item and its index as a Signal.
+ * @param options Optional configuration:
+ *  - `onDestroy`: A callback invoked when a mapped item is removed from the array.
+ * @returns A `Signal<U[]>` containing the mapped array.
+ */
+function keyArray(source, mapFn, options = {}) {
+    const sourceSignal = isSignal(source) ? source : computed(source);
+    const items = [];
+    let mapped = [];
+    const indexes = [];
+    const getKey = options.key || ((v) => v);
+    const newIndices = new Map();
+    const temp = [];
+    const tempIndexes = [];
+    const newIndicesNext = [];
+    const newIndexesCache = new Array();
+    return computed(() => {
+        const newItems = sourceSignal() || [];
+        return untracked(() => {
+            let i;
+            let j;
+            const newLen = newItems.length;
+            let len = items.length;
+            const newMapped = new Array(newLen);
+            const newIndexes = newIndexesCache;
+            newIndexes.length = 0;
+            newIndexes.length = newLen;
+            let start;
+            let end;
+            let newEnd;
+            let item;
+            let key;
+            if (newLen === 0) {
+                if (len !== 0) {
+                    if (options.onDestroy) {
+                        for (let k = 0; k < len; k++)
+                            options.onDestroy(mapped[k]);
+                    }
+                    items.length = 0;
+                    mapped = [];
+                    indexes.length = 0;
                 }
-                prevCache.delete(k);
-                nextCache.set(k, record);
-                nextValues.push(record.computation);
-                if (untracked(record.source.idx) !== i) {
-                    untracked(() => record.source.idx.set(i));
-                    changed = true;
+                return mapped;
+            }
+            // Fast path for new create (init)
+            if (len === 0) {
+                for (j = 0; j < newLen; j++) {
+                    item = newItems[j];
+                    items[j] = item;
+                    const indexSignal = signal(j, ...(ngDevMode ? [{ debugName: "indexSignal" }] : []));
+                    newIndexes[j] = indexSignal;
+                    newMapped[j] = mapFn(item, indexSignal);
                 }
             }
-            if (prevCache.size > 0)
-                changed = true;
-            if (opt.onDestroy)
-                prevCache.values().forEach((v) => opt.onDestroy?.(v.computation));
-            // clear for next run
-            prevCache.clear();
-            freeMap = prevCache;
-            return {
-                cache: nextCache,
-                values: changed ? nextValues : (prev?.value.values ?? []),
-            };
-        } });
-    return computed(() => internal().values);
+            else {
+                newIndices.clear();
+                temp.length = 0;
+                tempIndexes.length = 0;
+                newIndicesNext.length = 0;
+                // Skip common prefix
+                for (start = 0, end = Math.min(len, newLen); start < end && getKey(items[start]) === getKey(newItems[start]); start++) {
+                    newMapped[start] = mapped[start];
+                    newIndexes[start] = indexes[start];
+                }
+                // Common suffix
+                for (end = len - 1, newEnd = newLen - 1; end >= start &&
+                    newEnd >= start &&
+                    getKey(items[end]) === getKey(newItems[newEnd]); end--, newEnd--) {
+                    temp[newEnd] = mapped[end];
+                    tempIndexes[newEnd] = indexes[end];
+                }
+                // 0) Prepare a map of all indices in newItems, scanning backwards
+                for (j = newEnd; j >= start; j--) {
+                    item = newItems[j];
+                    key = getKey(item);
+                    i = newIndices.get(key);
+                    newIndicesNext[j] = i === undefined ? -1 : i;
+                    newIndices.set(key, j);
+                }
+                // 1) Step through old items: check if they are in new set
+                for (i = start; i <= end; i++) {
+                    item = items[i];
+                    key = getKey(item);
+                    j = newIndices.get(key);
+                    if (j !== undefined && j !== -1) {
+                        temp[j] = mapped[i];
+                        tempIndexes[j] = indexes[i];
+                        j = newIndicesNext[j];
+                        newIndices.set(key, j);
+                    }
+                    else {
+                        if (options.onDestroy)
+                            options.onDestroy(mapped[i]);
+                    }
+                }
+                // 2) Set all new values
+                for (j = start; j < newLen; j++) {
+                    if (j in temp) {
+                        newMapped[j] = temp[j];
+                        newIndexes[j] = tempIndexes[j];
+                        untracked(() => newIndexes[j].set(j)); // Update index signal
+                    }
+                    else {
+                        const indexSignal = signal(j, ...(ngDevMode ? [{ debugName: "indexSignal" }] : []));
+                        newIndexes[j] = indexSignal;
+                        newMapped[j] = mapFn(newItems[j], indexSignal);
+                    }
+                }
+                // 4) Save items for next update
+                items.length = newLen;
+                for (let k = 0; k < newLen; k++)
+                    items[k] = newItems[k];
+            }
+            mapped = newMapped;
+            indexes.length = newLen;
+            for (let k = 0; k < newLen; k++)
+                indexes[k] = newIndexes[k];
+            return mapped;
+        });
+    });
+}
+
+function pooledKeys(src) {
+    const aBuf = new Set();
+    const bBuf = new Set();
+    let active = aBuf;
+    let spare = bBuf;
+    return computed(() => {
+        const val = src();
+        spare.clear();
+        for (const k in val)
+            if (Object.prototype.hasOwnProperty.call(val, k))
+                spare.add(k);
+        if (active.size === spare.size && active.isSubsetOf(spare))
+            return active;
+        const temp = active;
+        active = spare;
+        spare = temp;
+        return active;
+    });
+}
+function mapObject(source, mapFn, options = {}) {
+    const src = isSignal(source) ? source : computed(source);
+    const writable = (isWritableSignal(src)
+        ? src
+        : toWritable(src, () => {
+            // noop
+        })); // maximal overload internally
+    return linkedSignal({
+        source: pooledKeys(src),
+        computation: (next, prev) => {
+            const nextObj = {};
+            for (const k of next)
+                nextObj[k] =
+                    prev && prev.source.has(k)
+                        ? prev.value[k]
+                        : mapFn(k, derived(writable, k));
+            if (options.onDestroy && prev && prev.source.size)
+                for (const k of prev.source)
+                    if (!next.has(k))
+                        options.onDestroy(prev.value[k]);
+            return nextObj;
+        },
+    }).asReadonly();
 }
 
 const frameStack = [];
@@ -501,38 +616,38 @@ function clearFrame(frame, userCleanups) {
  * @example
  * ```ts
  * const users = signal([
-  { id: 1, name: 'Alice' },
-  { id: 2, name: 'Bob' }
-]);
-
-// The fine-grained mapped list
-const mappedUsers = mapArray(
-  users,
-  (userSignal, index) => {
-    // 1. Create a fine-grained SIDE EFFECT for *this item*
-    // This effect's lifetime is now tied to this specific item. created once on init of this index.
-    const effectRef = nestedEffect(() => {
-      // This only runs if *this* userSignal changes,
-      // not if the whole list changes.
-      console.log(`User ${index} updated:`, userSignal().name);
-    });
-
-    // 2. Return the data AND the cleanup logic
-    return {
-      // The mapped data
-      label: computed(() => `User: ${userSignal().name}`),
-      
-      // The cleanup function
-      destroyEffect: () => effectRef.destroy()
-    };
-  },
-  {
-    // 3. Tell mapArray HOW to clean up when an item is removed, this needs to be manual as it's not a nestedEffect itself
-    onDestroy: (mappedItem) => {
-      mappedItem.destroyEffect();
-    }
-  }
-);
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' }
+ * ]);
+ *
+ * // The fine-grained mapped list
+ * const mappedUsers = mapArray(
+ *   users,
+ *   (userSignal, index) => {
+ *     // 1. Create a fine-grained SIDE EFFECT for *this item*
+ *     // This effect's lifetime is now tied to this specific item. created once on init of this index.
+ *     const effectRef = nestedEffect(() => {
+ *       // This only runs if *this* userSignal changes,
+ *       // not if the whole list changes.
+ *       console.log(`User ${index} updated:`, userSignal().name);
+ *     });
+ *
+ *     // 2. Return the data AND the cleanup logic
+ *     return {
+ *       // The mapped data
+ *       label: computed(() => `User: ${userSignal().name}`),
+ *
+ *       // The cleanup function
+ *       destroyEffect: () => effectRef.destroy()
+ *     };
+ *   },
+ *   {
+ *     // 3. Tell mapArray HOW to clean up when an item is removed, this needs to be manual as it's not a nestedEffect itself
+ *     onDestroy: (mappedItem) => {
+ *       mappedItem.destroyEffect();
+ *     }
+ *   }
+ * );
  * ```
  */
 function nestedEffect(effectFn, options) {
@@ -1441,76 +1556,98 @@ function sensors(track, opt) {
     }, {});
 }
 
-// Credit to NGRX signal store, adaptation for purposes of supporting Writable/Mutable signals
-// Link to source: https://github.com/ngrx/platform/blob/main/modules/signals/src/deep-signal.ts
-const TREAT_AS_VALUE = new Set([
-    Date,
-    Error,
-    RegExp,
-    ArrayBuffer,
-    DataView,
-    Function,
-    WeakSet,
-    WeakMap,
-    WeakRef,
-    Promise,
-    typeof Iterator !== 'undefined' ? Iterator : class {
-    },
-    Array,
-]);
-function isIterable(value) {
-    return typeof value?.[Symbol.iterator] === 'function';
-}
 function isRecord(value) {
-    if (value === null || typeof value !== 'object' || isIterable(value)) {
+    if (value === null || typeof value !== 'object')
         return false;
-    }
-    let proto = Object.getPrototypeOf(value);
-    if (proto === Object.prototype) {
-        return true;
-    }
-    while (proto && proto !== Object.prototype) {
-        if (TREAT_AS_VALUE.has(proto.constructor))
-            return false;
-        proto = Object.getPrototypeOf(proto);
-    }
-    return proto === Object.prototype;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
 }
-const STORE = Symbol(isDevMode() ? 'SIGNAL_STORE' : '');
-const STORE_PROXY = Symbol(isDevMode() ? 'SIGNAL_STORE_PROXY' : '');
-function toStore(source, injector = inject(Injector)) {
-    return new Proxy(source, {
+const IS_STORE = Symbol('MMSTACK::IS_STORE');
+const PROXY_CACHE = new WeakMap();
+const SIGNAL_FN_PROP = new Set([
+    'set',
+    'update',
+    'mutate',
+    'inline',
+    'asReadonly',
+]);
+/**
+ * @experimental This API is experimental and may change or be removed in future releases.
+ * Converts a Signal into a deep-observable Store.
+ * Accessing nested properties returns a derived Signal of that path.
+ * @example
+ * const state = store({ user: { name: 'John' } });
+ * const nameSignal = state.user.name; // WritableSignal<string>
+ */
+function toStore(source, injector) {
+    if (source[IS_STORE])
+        return source;
+    if (!injector)
+        injector = inject(Injector);
+    const writableSource = isWritableSignal(source)
+        ? source
+        : toWritable(source, () => {
+            // noop
+        });
+    const isMutableSource = isMutable(writableSource);
+    return new Proxy(writableSource, {
         has(_, prop) {
             return Reflect.has(untracked(source), prop);
         },
+        ownKeys() {
+            const v = untracked(source);
+            return isRecord(v) ? Reflect.ownKeys(v) : [];
+        },
+        getOwnPropertyDescriptor(_, prop) {
+            const value = untracked(source);
+            if (!isRecord(value) || !(prop in value))
+                return;
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        },
         get(target, prop) {
-            const value = untracked(target);
-            if (!isRecord(value) || !(prop in value)) {
-                if (isSignal(target[prop]) && target[prop][STORE]) {
-                    delete target[prop];
-                }
+            if (prop === IS_STORE)
+                return true;
+            if (typeof prop === 'symbol' || SIGNAL_FN_PROP.has(prop))
                 return target[prop];
+            let storeCache = PROXY_CACHE.get(target);
+            if (!storeCache) {
+                storeCache = new Map();
+                PROXY_CACHE.set(target, storeCache);
             }
-            if (target[prop][STORE_PROXY]) {
-                return target[prop][STORE_PROXY];
+            const cachedRef = storeCache.get(prop);
+            if (cachedRef) {
+                const cached = cachedRef.deref();
+                if (cached)
+                    return cached;
+                storeCache.delete(prop);
             }
-            let computation;
-            if (!isSignal(target[prop])) {
-                computation = derived(target, prop);
-                Object.defineProperty(target, prop, {
-                    value: computation,
-                    configurable: true,
+            const value = untracked(target);
+            const valueIsRecord = isRecord(value);
+            const equalFn = valueIsRecord && isMutableSource && typeof value[prop] === 'object'
+                ? () => false
+                : undefined;
+            const computation = valueIsRecord
+                ? derived(target, prop, { equal: equalFn })
+                : derived(target, {
+                    from: (v) => v?.[prop],
+                    onChange: (newValue) => target.update((v) => {
+                        if (v === null || v === undefined)
+                            return v;
+                        try {
+                            v[prop] = newValue;
+                        }
+                        catch (e) {
+                            if (isDevMode())
+                                console.error(`[store] Failed to set property "${String(prop)}"`, e);
+                        }
+                        return v;
+                    }),
                 });
-                target[prop][STORE] = true;
-            }
-            const proxy = toStore(target[prop], injector);
-            const cleanupRef = nestedEffect(() => {
-                if (Reflect.has(source(), prop))
-                    return;
-                delete target[prop];
-                cleanupRef.destroy();
-            }, { injector });
-            target[prop][STORE_PROXY] = proxy;
+            const proxy = toStore(computation, injector);
+            storeCache.set(prop, new WeakRef(proxy));
             return proxy;
         },
     });
@@ -1996,5 +2133,5 @@ function withHistory(source, opt) {
  * Generated bundle index. Do not edit.
  */
 
-export { combineWith, debounce, debounced, derived, distinct, elementSize, elementVisibility, filter, indexArray, isDerivation, isMutable, keyArray, map, mapArray, mediaQuery, mousePosition, mutable, mutableStore, nestedEffect, networkStatus, pageVisibility, pipeable, piped, prefersDarkMode, prefersReducedMotion, scrollPosition, select, sensor, sensors, store, stored, tabSync, tap, throttle, throttled, toFakeDerivation, toFakeSignalDerivation, toStore, toWritable, until, windowSize, withHistory };
+export { combineWith, debounce, debounced, derived, distinct, elementSize, elementVisibility, filter, indexArray, isDerivation, isMutable, keyArray, map, mapArray, mapObject, mediaQuery, mousePosition, mutable, mutableStore, nestedEffect, networkStatus, pageVisibility, pipeable, piped, prefersDarkMode, prefersReducedMotion, scrollPosition, select, sensor, sensors, store, stored, tabSync, tap, throttle, throttled, toFakeDerivation, toFakeSignalDerivation, toStore, toWritable, until, windowSize, withHistory };
 //# sourceMappingURL=mmstack-primitives.mjs.map