ks-fwork 2.0.1 → 3.0.1

package/src/utils/arrays.js

@@ -40,81 +40,51 @@ class ArrayWithOriginalIndices {
         return this.#originalIndices[index];
     }
 
-    // REMOVE
-    isRemoval(index, newArray) {
-        // Bail out if index is past the end of the old array.
-        if (index >= this.length) { return false; }
-
-        const item = this.#oldArray[index];
-        const indexInNewArray = newArray.findIndex((newArrayItem) => this.#equalsFn(item, newArrayItem))
-
-        return indexInNewArray === -1;
+    // ADD
+    isAddition(item, startIndex) {
+        return this.findIndexFrom(item, startIndex) === -1;
     }
 
-    removeItem(index) {
+    addItem(item, index) {
         const operation = {
-            op: ARRAY_DIFF_OP.REMOVE,
+            op: ARRAY_DIFF_OP.ADD,
             index,
-            item: this.#oldArray[index],
+            item
         }
 
-        this.#oldArray.splice(index, 1);
-        this.#originalIndices.splice(index, 1);
+        this.#oldArray.splice(index, 0, item);
+        this.#originalIndices.splice(index, 0, -1);
 
         return operation;
     }
 
-    // NOOP
-    isNoop(index, newArray) {
+    // REMOVE
+    isRemoval(index, newArray) {
         // Bail out if index is past the end of the old array.
-        if (index >= this.length) {return false; }
+        if (index >= this.length) { return false; }
 
         const item = this.#oldArray[index];
-        const newArrayItem = newArray[index];
-
-        return this.#equalsFn(item, newArrayItem);
-    }
-
-    noopItem(index) {
-        return {
-            op: ARRAY_DIFF_OP.NOOP,
-            originalIndex: this.originalIndexAt(index),
-            index,
-            item: this.#oldArray[index],
-        }
-    }
-
-    // ADD
-    isAddition(item, fromIndex) {
-        return this.findFromIndex(item, fromIndex) === -1;
-    }
-
-    findFromIndex(item, fromIndex) {
-        for (let i = fromIndex; i < this.length; i++) {
-            if (this.#equalsFn(item, this.#oldArray[i])) {
-                return i;
-            }
-        }
+        const indexInNewArray = newArray.findIndex((newArrayItem) => this.#equalsFn(item, newArrayItem))
 
-        return -1;
+        return indexInNewArray === -1;
     }
 
-    addItem(item, index) {
+    removeItem(index) {
         const operation = {
-            op: ARRAY_DIFF_OP.ADD,
+            op: ARRAY_DIFF_OP.REMOVE,
             index,
-            item
+            item: this.#oldArray[index],
         }
 
-        this.#oldArray.splice(index, 0, item);
-        this.#originalIndices.splice(index, 0, -1);
+        this.#oldArray.splice(index, 1);
+        this.#originalIndices.splice(index, 1);
 
         return operation;
     }
 
     // MOVE
     moveItem(item, toIndex) {
-        const fromIndex = this.findFromIndex(item, toIndex);
+        const fromIndex = this.findIndexFrom(item, toIndex);
 
         const operation = {
             op: ARRAY_DIFF_OP.MOVE,
@@ -133,7 +103,27 @@ class ArrayWithOriginalIndices {
         return operation;
     }
 
-    // REMOVE ITEMS AFTER
+    // NOOP
+    isNoop(index, newArray) {
+        // Bail out if index is past the end of the old array.
+        if (index >= this.length) {return false; }
+
+        const item = this.#oldArray[index];
+        const newArrayItem = newArray[index];
+
+        return this.#equalsFn(item, newArrayItem);
+    }
+
+    noopItem(index) {
+        return {
+            op: ARRAY_DIFF_OP.NOOP,
+            originalIndex: this.originalIndexAt(index),
+            index,
+            item: this.#oldArray[index],
+        }
+    }
+
+    // Remove all items after specified index
     removeItemsAfter(index) {
         const operations = [];
 
@@ -143,6 +133,17 @@ class ArrayWithOriginalIndices {
 
         return operations;
     }
+
+    // Return the first index at or after startIndex where the item matches, or -1 if item is not found.
+    findIndexFrom(item, startIndex) {
+        for (let i = startIndex; i < this.length; i++) {
+            if (this.#equalsFn(item, this.#oldArray[i])) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
 }
 
 export function arraysDiffSequence(oldArray, newArray, equalsFn = (a, b) => a === b) {

package/src/utils/objects.js

@@ -9,4 +9,8 @@ export function objectsDiff(oldObj, newObj) {
             (key) => key in oldObj && oldObj[key] !== newObj[key]
         ),
     }
+}
+
+export function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
 }

package/src/utils/props.js

@@ -0,0 +1,6 @@
+export function extractPropsAndEvents(vNode) {
+    const { on: events = {}, ...props } = vNode.props;
+    delete props.key;
+
+    return { props, events }
+}