@mmstack/primitives 22.8.2 → 22.8.3

package/fesm2022/mmstack-primitives.mjs

@@ -2005,6 +2005,29 @@ function indexArray(source, map, opt = {}) {
  */
 const mapArray = indexArray;
 
+function effectiveKeys(arr, getKey, report) {
+    const out = new Array(arr.length);
+    const counts = new Map();
+    const firstOrder = [];
+    let duped = null;
+    for (let i = 0; i < arr.length; i++) {
+        const base = String(getKey(arr[i]));
+        const seen = counts.get(base) ?? 0;
+        if (seen === 0) {
+            firstOrder.push(base);
+        }
+        else {
+            (duped ??= new Set()).add(base);
+        }
+        out[i] = seen === 0 ? base : base + '#' + seen;
+        counts.set(base, seen + 1);
+    }
+    if (report && duped) {
+        const bases = firstOrder.filter((b) => duped.has(b));
+        untracked(() => report(bases));
+    }
+    return out;
+}
 /**
  * Reactively maps items from a source array to a new array by value (identity).
  *
@@ -2023,6 +2046,8 @@ const mapArray = indexArray;
  *  - `onDestroy`: A callback invoked when a mapped item is removed from the array.
  *  - `key`: A custom key extractor for identity matching (e.g. `(item) => item.id`)
  *    when item references change but conceptual identity is preserved.
+ *  - `duplicateKeys`: Opt-in policy for handling duplicate keys. When omitted,
+ *    behavior is unchanged (duplicates collapse). See {@link DuplicateKeyPolicy}.
  * @returns A `Signal<U[]>` containing the mapped array.
  *
  * @example
@@ -2057,9 +2082,11 @@ function keyArray(source, mapFn, options = {}) {
     const tempIndexes = [];
     const newIndicesNext = [];
     const newIndexesCache = new Array();
+    const dup = options.duplicateKeys;
     return computed(() => {
         const newItems = sourceSignal() || [];
         return untracked(() => {
+            const newKeys = dup ? effectiveKeys(newItems, getKey, dup.report) : null;
             let i;
             let j;
             const newLen = newItems.length;
@@ -2100,26 +2127,29 @@ function keyArray(source, mapFn, options = {}) {
                 temp.length = 0;
                 tempIndexes.length = 0;
                 newIndicesNext.length = 0;
-                for (start = 0, end = Math.min(len, newLen); start < end && getKey(items[start]) === getKey(newItems[start]); start++) {
+                const oldKeys = dup ? effectiveKeys(items, getKey) : null;
+                const kNew = newKeys
+                    ? (idx) => newKeys[idx]
+                    : (idx) => getKey(newItems[idx]);
+                const kOld = oldKeys
+                    ? (idx) => oldKeys[idx]
+                    : (idx) => getKey(items[idx]);
+                for (start = 0, end = Math.min(len, newLen); start < end && kOld(start) === kNew(start); start++) {
                     newMapped[start] = mapped[start];
                     newIndexes[start] = indexes[start];
                 }
-                for (end = len - 1, newEnd = newLen - 1; end >= start &&
-                    newEnd >= start &&
-                    getKey(items[end]) === getKey(newItems[newEnd]); end--, newEnd--) {
+                for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && kOld(end) === kNew(newEnd); end--, newEnd--) {
                     temp[newEnd] = mapped[end];
                     tempIndexes[newEnd] = indexes[end];
                 }
                 for (j = newEnd; j >= start; j--) {
-                    item = newItems[j];
-                    key = getKey(item);
+                    key = kNew(j);
                     i = newIndices.get(key) ?? -1;
                     newIndicesNext[j] = i === undefined ? -1 : i;
                     newIndices.set(key, j);
                 }
                 for (i = start; i <= end; i++) {
-                    item = items[i];
-                    key = getKey(item);
+                    key = kOld(i);
                     j = newIndices.get(key) ?? -1;
                     if (j !== undefined && j !== -1) {
                         temp[j] = mapped[i];