@bbn/bbn 1.0.185 → 1.0.187

package/dist/fn/object/mutateArray.js

@@ -1,54 +1,44 @@
 import { isArray } from '../type/isArray.js';
 import { hash } from '../string/hash.js';
-import { isSame } from '../type/isSame.js';
 var mutateArray = function (a1, a2) {
     if (!isArray(a1, a2)) {
         throw new TypeError('mutateArray can only be called with arrays');
     }
     var mapA2 = new Map(a2.map(function (item) { return [hash(item), item]; }));
-    var a1Pointer = 0;
-    var a2Pointer = 0;
-    var _loop_1 = function () {
-        var a1Item = a1[a1Pointer];
-        var a2Item = a2[a2Pointer];
-        var a1Key = a1Item ? hash(a1Item) : undefined;
-        var a2Key = hash(a2Item);
-        if (a1Key === a2Key) {
-            // The items match, move both pointers.
-            a1Pointer++;
-            a2Pointer++;
+    var a1Ordered = [];
+    // Build a1Ordered to have the same order and contents as a2
+    a2.forEach(function (item) {
+        a1Ordered.push(item);
+    });
+    // Remove items from a1 that are not in a2
+    var i = a1.length;
+    while (i--) {
+        if (!mapA2.has(hash(a1[i]))) {
+            a1.splice(i, 1);
         }
-        else if (mapA2.has(a1Key)) {
-            // The item in a1 exists in a2 but is out of order, so it should be moved.
-            // First, find the correct position to move it to.
-            var correctIndex = a1.findIndex(function (item) { return hash(item) === a2Key; });
-            var itemToMove = a1.splice(correctIndex, 1)[0];
-            a1.splice(a1Pointer, 0, itemToMove);
-            // Now that the item has been moved to the correct position, move pointers.
-            a1Pointer++;
-            a2Pointer++;
-        }
-        else {
-            // The item in a1 does not exist in a2, so it should be removed.
-            a1.splice(a1Pointer, 1);
-        }
-        // If there's no corresponding item in a1 for the current a2 item, insert it.
-        if (a1[a1Pointer] === undefined && a2Pointer < a2.length) {
-            a1.splice(a1Pointer, 0, a2Item);
-            a1Pointer++;
-            a2Pointer++;
+    }
+    var _loop_1 = function (j) {
+        if (j >= a1.length || hash(a1[j]) !== hash(a1Ordered[j])) {
+            // Find the index of the item in a1, if it exists
+            var indexInA1 = a1.findIndex(function (item) { return hash(item) === hash(a1Ordered[j]); });
+            if (indexInA1 !== -1) {
+                // Move the item to the correct position if it already exists in a1
+                var itemToMove = a1.splice(indexInA1, 1)[0];
+                a1.splice(j, 0, itemToMove);
+            }
+            else {
+                // Insert the new item from a2 into a1
+                a1.splice(j, 0, a1Ordered[j]);
+            }
         }
     };
-    while (a2Pointer < a2.length) {
-        _loop_1();
-    }
-    // If there are any remaining items in a1 that are not in a2, remove them.
-    while (a1.length > a2.length) {
-        a1.pop();
+    // Insert or move items to match the order of a2
+    for (var j = 0; j < a1Ordered.length; j++) {
+        _loop_1(j);
     }
-    if (!isSame(a1, a2)) {
-        bbn.fn.log(a1, a2);
-        throw new Error('mutateArray failed');
+    // If a1 has extra items at the end (not present in a2), remove them
+    if (a1.length > a1Ordered.length) {
+        a1.splice(a1Ordered.length, a1.length - a1Ordered.length);
     }
     return a1;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "1.0.185",
+  "version": "1.0.187",
   "description": "Javascript toolkit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",