subay 0.0.13 → 0.1.1

package/src/arr.ts

@@ -0,0 +1,428 @@
+// fully adopt from https://github.com/localvoid/ivi/blob/fe3b159fac6cddb7521dccc47d0a041b60d0947e/packages/ivi/src/lib/core.ts#L1210
+
+const enum MagicValues {
+    /**
+     * One of the children nodes were moved.
+     */
+    RearrangeNodes = 1073741823, // Max SMI Value
+    /**
+     * New node marker.
+     */
+    NewNodeMark = -1,
+    /**
+     * LIS marker.
+     */
+    LISMark = -2,
+}
+
+/**
+ * Update children list with track by key algorithm.
+ *
+ * High-level overview of the algorithm that is implemented in this function:
+ *
+ * This algorithm finds a minimum number of DOM operations. It works in
+ * several steps:
+ *
+ * 1. Common prefix and suffix optimization.
+ *
+ * Look for nodes with identical keys by simultaneously iterating through nodes
+ * in the old children list `A` and new children list `B` from both sides.
+ *
+ *     A: -> [a b c d] <-
+ *     B: -> [a b d] <-
+ *
+ * Skip nodes "a" and "b" at the start, and node "d" at the end.
+ *
+ *     A: -> [c] <-
+ *     B: -> [] <-
+ *
+ * 2. Zero length optimizations.
+ *
+ * Check if the size of one of the list is equal to zero. When length of the
+ * old children list is zero, insert remaining nodes from the new list. When
+ * length of the new children list is zero, remove remaining nodes from the old
+ * list.
+ *
+ *     A: -> [a b c g] <-
+ *     B: -> [a g] <-
+ *
+ * Skip nodes "a" and "g" (prefix and suffix optimization).
+ *
+ *     A: [b c]
+ *     B: []
+ *
+ * Remove nodes "b" and "c".
+ *
+ * 3. Index and unmount removed nodes.
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *     P: [. . . . .] // . == -1
+ *
+ * Create array `P` (`sources`) with the length of the new children list and
+ * fills it with `NewNodeMark` values. This mark indicates that node at this
+ * position should be mounted. Later we will assign node positions in the old
+ * children list to this array.
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *     P: [. . . . .] // . == -1
+ *     I: {
+ *       c: 0, // B[0] == c
+ *       b: 1, // B[1] == b
+ *       h: 2,
+ *       f: 3,
+ *       e: 4,
+ *     }
+ *     last = 0
+ *
+ * Create reverse index `I` that maps keys to node positions in the new
+ * children list.
+ *
+ *     A: [b c d e f]
+ *         ^
+ *     B: [c b h f e]
+ *     P: [. 0 . . .] // . == -1
+ *     I: {
+ *       c: 0,
+ *       b: 1, <-
+ *       h: 2,
+ *       f: 3,
+ *       e: 4,
+ *     }
+ *     last = 1
+ *
+ * Assign original positions of the nodes from the old children list to the
+ * array `P`.
+ *
+ * Iterate through nodes in the old children list and gets their new positions
+ * from the index `I`. Assign old node position to the array `P`. When index
+ * `I` doesn't have a key for the old node, it means that it should be
+ * unmounted.
+ *
+ * When we assigning positions to the array `P`, we also store position of the
+ * last seen node in the new children list `pos`, if the last seen position is
+ * greater than the current position of the node at the new list, then we are
+ * switching `rearrangeNodes` flag to `true` (`pos === RearrangeNodes`).
+ *
+ *     A: [b c d e f]
+ *           ^
+ *     B: [c b h f e]
+ *     P: [1 0 . . .] // . == -1
+ *     I: {
+ *       c: 0, <-
+ *       b: 1,
+ *       h: 2,
+ *       f: 3,
+ *       e: 4,
+ *     }
+ *     last = 1 // last > 0; rearrangeNodes = true
+ *
+ * The last position `1` is greater than the current position of the node at the
+ * new list `0`, switch `rearrangeNodes` flag to `true`.
+ *
+ *     A: [b c d e f]
+ *             ^
+ *     B: [c b h f e]
+ *     P: [1 0 . . .] // . == -1
+ *     I: {
+ *       c: 0,
+ *       b: 1,
+ *       h: 2,
+ *       f: 3,
+ *       e: 4,
+ *     }
+ *     rearrangeNodes = true
+ *
+ * Node with key "d" doesn't exist in the index `I`, unmounts node `d`.
+ *
+ *     A: [b c d e f]
+ *               ^
+ *     B: [c b h f e]
+ *     P: [1 0 . . 3] // . == -1
+ *     I: {
+ *       c: 0,
+ *       b: 1,
+ *       h: 2,
+ *       f: 3,
+ *       e: 4, <-
+ *     }
+ *     rearrangeNodes = true
+ *
+ * Assign position `3` for `e` node.
+ *
+ *     A: [b c d e f]
+ *                 ^
+ *     B: [c b h f e]
+ *     P: [1 0 . 4 3] // . == -1
+ *     I: {
+ *       c: 0,
+ *       b: 1,
+ *       h: 2,
+ *       f: 3, <-
+ *       e: 4,
+ *     }
+ *     rearrangeNodes = true
+ *
+ * Assign position `4` for 'f' node.
+ *
+ * 4. Find minimum number of moves when `rearrangeNodes` flag is on and mount
+ *    new nodes.
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *     P: [1 * . 4 *] // . == -1  * == -2
+ *
+ * When `rearrangeNodes` is on, mark all nodes in the array `P` that belong to
+ * the [longest increasing subsequence](http://en.wikipedia.org/wiki/Longest_increasing_subsequence)
+ * and move all nodes that doesn't belong to this subsequence.
+ *
+ * Iterate over the new children list and the `P` array simultaneously. When
+ * value from `P` array is equal to `NewNodeMark`, mount a new node. When it
+ * isn't equal to `LisMark`, move it to a new position.
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *                 ^  // new_pos == 4
+ *     P: [1 * . 4 *] // . == NewNodeMark  * == LisMark
+ *                 ^
+ *
+ * Node "e" has `LisMark` value in the array `P`, nothing changes.
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *               ^    // new_pos == 3
+ *     P: [1 * . 4 *] // . == NewNodeMark  * == LisMark
+ *               ^
+ *
+ * Node "f" has `4` value in the array `P`, move it before the next node "e".
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *             ^      // new_pos == 2
+ *     P: [1 * . 4 *] // . == NewNodeMark  * == LisMark
+ *             ^
+ *
+ * Node "h" has `NewNodeMark` value in the array `P`, mount new node "h".
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *           ^        // new_pos == 1
+ *     P: [1 * . 4 *] // . == NewNodeMark  * == LisMark
+ *           ^
+ *
+ * Node "b" has `LisMark` value in the array `P`, nothing changes.
+ *
+ *     A: [b c d e f]
+ *     B: [c b h f e]
+ *         ^          // new_pos == 0
+ *     P: [1 * . 4 *] // . == NewNodeMark  * == LisMark
+ *
+ * Node "c" has `1` value in the array `P`, move it before the next node "b".
+ *
+ * When `rearrangeNodes` flag is off, skip LIS algorithm and mount nodes that
+ * have `NewNodeMark` value in the array `P`.
+ *
+ * NOTE: There are many variations of this algorithm that are used by many UI
+ * libraries and many implementations are still using an old optimization
+ * technique that were removed several years ago from this implementation. This
+ * optimization were used to improve performance of simple moves/swaps. E.g.
+ *
+ *     A: -> [a b c] <-
+ *     B: -> [c b a] <-
+ *
+ * Move "a" and "c" nodes to the other edge.
+ *
+ *     A: -> [b] <-
+ *     B: -> [b] <-
+ *
+ * Skip node "b".
+ *
+ * This optimization were removed because it breaks invariant that insert and
+ * remove operations shouldn't trigger a move operation. E.g.
+ *
+ *     A: -> [a b]
+ *     B:    [c a] <-
+ *
+ * Move node "a" to the end.
+ *
+ *     A: [b]
+ *     B: [c a]
+ *
+ * Remove node "b" and insert node "c".
+ *
+ * In this use case, this optimization performs one unnecessary operation.
+ * Instead of removing node "b" and inserting node "c", it also moves node "a".
+ *
+ */
+export const arr = <T>(
+    aKeys: readonly T[],
+    bKeys: readonly T[],
+    onDelete: (item: T) => void,
+    onCreate: (item: T) => void,
+    onRemain: (item: T) => void,
+    onLocate: (item: T) => void,
+): void => {
+    const bLength = bKeys.length;
+    const aLength = aKeys.length;
+
+    if (bLength === 0) {
+        // New children list is empty.
+        if (aLength > 0) {
+            // Unmount nodes from the old children list.
+            aKeys.forEach(onDelete);
+        }
+    } else if (aLength === 0) {
+        // Old children list is empty.
+        bKeys.forEach(onCreate);
+    } else {
+        let aEnd = aLength - 1;
+        let bEnd = bLength - 1;
+        let start = 0;
+
+        // Step 1
+        // Align common elements from the start
+        while (start <= aEnd && start <= bEnd && aKeys[start] === bKeys[start]) {
+            onRemain(aKeys[start++]!);
+        }
+        // Align common elements from the end
+        while (start <= aEnd && start <= bEnd && aKeys[aEnd] === bKeys[bEnd]) {
+            aEnd--;
+            bEnd--;
+        }
+
+        // Step 2
+        if (start > aEnd) {
+            // All nodes from `a` are updated, insert the rest from `b`.
+            while (start <= bEnd) {
+                onCreate(bKeys[start++]!);
+            }
+        } else if (start > bEnd) {
+            // All nodes from `b` are updated, remove the rest from `a`.
+            while (start <= aEnd) {
+                onDelete(aKeys[start++]!);
+            }
+        } else {
+            // Step 3
+            const bLength = bEnd - start + 1;
+            const sources = new Int32Array(bLength); // Maps positions in the new children list to positions in the old list.
+            const keyIndex = new Map<T, number>(); // Maps keys to their positions in the new children list.
+            for (let i = 0, j = start; i < bLength; i++, j++) {
+                // `NewNodeMark` value indicates that node doesn't exist in the old children list.
+                sources[i] = MagicValues.NewNodeMark;
+                keyIndex.set(bKeys[j]!, j);
+            }
+
+            // When `nodePosition === RearrangeNodes`, it means that one of the nodes is in the wrong position and we should
+            // rearrange nodes with LIS-based algorithm `markLIS()`.
+            let nodePosition = 0;
+            for (let i = start; i <= aEnd; i++) {
+                const nextPosition = keyIndex.get(aKeys[i]!);
+                if (nextPosition !== void 0) {
+                    nodePosition = nodePosition < nextPosition ? nextPosition : MagicValues.RearrangeNodes;
+                    sources[nextPosition - start] = i;
+                } else {
+                    onDelete(aKeys[i]!);
+                }
+            }
+
+            // Step 4
+
+            // Mark LIS nodes only when this node weren't moved `moveNode === false` and we've detected that one of the
+            // children nodes were moved `pos === MagicValues.MovedChildren`.
+            if (nodePosition === MagicValues.RearrangeNodes) {
+                markLIS(sources);
+            }
+            for (let i = 0; i < bLength; i++) {
+                const bNode = bKeys[start + i]!;
+                const lisValue = sources[i]!;
+                if (lisValue === -1) {
+                    onCreate(bNode);
+                } else if (nodePosition === MagicValues.RearrangeNodes && lisValue !== MagicValues.LISMark) {
+                    onLocate(bNode);
+                } else {
+                    onRemain(bNode);
+                }
+            }
+        }
+
+        // Delayed update for nodes from Step 1 (prefix only). Reconciliation algorithm always updates nodes from left to
+        // right.
+        for (let i = 1; i + aEnd < aLength /*&& i + bEnd < bLength*/; i++) {
+            onRemain(aKeys[i + aEnd]!);
+        }
+    }
+};
+
+/**
+ * Modified Longest Increased Subsequence algorithm.
+ *
+ * Mutates input array `a` and replaces all values that are part of LIS with -2 value.
+ *
+ * Constraints:
+ * - Doesn't work with negative numbers. -1 values are ignored.
+ * - Input array `a` should contain at least one value that is greater than -1.
+ *
+ * {@link http://en.wikipedia.org/wiki/Longest_increasing_subsequence}
+ *
+ * @example
+ *
+ *     const A = Int32Array.from([-1, 0, 2, 1]);
+ *     markLIS(A);
+ *     // A => [-1, -2, 2, -2]
+ *
+ * @param a Array of numbers.
+ */
+const markLIS = (a: Int32Array): void => {
+    const length = a.length;
+    const parent = new Int32Array(length);
+    const index = new Int32Array(length);
+    let indexLength = 0;
+    let i = 0;
+    let j: number;
+    let k: number;
+    let lo: number;
+    let hi: number;
+
+    // Skip -1 values at the start of the input array `a`.
+    while (a[i] === MagicValues.NewNodeMark) i++;
+
+    index[0] = i++;
+    for (; i < length; i++) {
+        k = a[i]!;
+        if (k !== MagicValues.NewNodeMark) {
+            // Ignore -1 values.
+            j = index[indexLength]!;
+            if (a[j]! < k) {
+                parent[i] = j;
+                index[++indexLength] = i;
+            } else {
+                lo = 0;
+                hi = indexLength;
+
+                while (lo < hi) {
+                    j = (lo + hi) >> 1;
+                    if (a[index[j]!]! < k) {
+                        lo = j + 1;
+                    } else {
+                        hi = j;
+                    }
+                }
+
+                if (k < a[index[lo]!]!) {
+                    if (lo > 0) {
+                        parent[i] = index[lo - 1]!;
+                    }
+                    index[lo] = i;
+                }
+            }
+        }
+    }
+
+    // Mutate input array `a` and assign -2 value to all nodes that are part of LIS.
+    j = index[indexLength]!;
+    while (indexLength-- >= 0) {
+        a[j] = MagicValues.LISMark;
+        j = parent[j]!;
+    }
+};