utils: add handleDiffArray

Author: thetarnav

packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solid-primitives/utils",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "A bunch of reactive utility types and functions, for building primitives with Solid.js",
   "author": "Damian Tarnawski @thetarnav <gthetarnav@gmail.com>",
   "license": "MIT",

packages/utils/src/index.ts

@@ -378,3 +378,48 @@ export function createStaticStore<T extends Readonly<AnyStatic>>(
 
   return [store, setter];
 }
+
+/**
+ * Handle items removed and added to the array by diffing it by refference.
+ *
+ * @param current new array instance
+ * @param prev previous array copy
+ * @param handleAdded called once for every added item to array
+ * @param handleRemoved called once for every removed from array
+ */
+export function handleDiffArray<T>(
+  current: T[],
+  prev: T[],
+  handleAdded: (item: T) => void,
+  handleRemoved: (item: T) => void
+): void {
+  const currLength = current.length;
+  const prevLength = prev.length;
+  let i = 0;
+
+  if (!prevLength) {
+    for (; i < currLength; i++) handleAdded(current[i]);
+    return;
+  }
+
+  if (!currLength) {
+    for (; i < prevLength; i++) handleRemoved(prev[i]);
+    return;
+  }
+
+  for (; i < prevLength; i++) {
+    if (prev[i] !== current[i]) break;
+  }
+
+  let prevEl: T;
+  let currEl: T;
+  prev = prev.slice(i);
+  current = current.slice(i);
+
+  for (prevEl of prev) {
+    if (!current.includes(prevEl)) handleRemoved(prevEl);
+  }
+  for (currEl of current) {
+    if (!prev.includes(currEl)) handleAdded(currEl);
+  }
+}

packages/utils/test/index.test.ts

@@ -1,5 +1,5 @@
 import { createComputed, createRoot } from "solid-js";
-import { createStaticStore } from "../src";
+import { createStaticStore, handleDiffArray } from "../src";
 import { suite } from "uvu";
 import * as assert from "uvu/assert";
 
@@ -63,3 +63,85 @@ tss("individual keys only update when changed", () =>
 // );
 
 tss.run();
+
+const da = suite("handleDiffArray");
+
+da("handleAdded called for new array", () => {
+  const a: string[] = [];
+  const b = ["foo", "bar", "baz", "hello", "world"];
+  const captured: any[] = [];
+  handleDiffArray(
+    b,
+    a,
+    item => {
+      captured.push(item);
+    },
+    () => {
+      throw "Should never run";
+    }
+  );
+  assert.is(captured.length, 5);
+  assert.ok(captured.includes("foo"));
+  assert.ok(captured.includes("bar"));
+  assert.ok(captured.includes("baz"));
+  assert.ok(captured.includes("hello"));
+  assert.ok(captured.includes("world"));
+});
+
+da("handleRemoved for cleared array", () => {
+  const a = ["foo", "bar", "baz", "hello", "world"];
+  const b: string[] = [];
+  const captured: any[] = [];
+  handleDiffArray(
+    b,
+    a,
+    () => {
+      throw "Should never run";
+    },
+    item => {
+      captured.push(item);
+    }
+  );
+  assert.is(captured.length, 5);
+  assert.ok(captured.includes("foo"));
+  assert.ok(captured.includes("bar"));
+  assert.ok(captured.includes("baz"));
+  assert.ok(captured.includes("hello"));
+  assert.ok(captured.includes("world"));
+});
+
+da("callbacks shouldn't run for same array", () => {
+  const a = ["foo", "bar", "baz", "hello", "world"];
+  const b = ["foo", "bar", "baz", "hello", "world"];
+  handleDiffArray(
+    b,
+    a,
+    () => {
+      throw "Should never run";
+    },
+    () => {
+      throw "Should never run";
+    }
+  );
+});
+
+da("calls callbacks for added and removed items", () => {
+  const a = ["foo", "baz", "hello"];
+  const b = ["foo", "bar", "hello", "world"];
+  const capturedAdded: any[] = [];
+  const capturedRemoved: any[] = [];
+  handleDiffArray(
+    b,
+    a,
+    item => capturedAdded.push(item),
+    item => capturedRemoved.push(item)
+  );
+  assert.is(capturedAdded.length, 2);
+  assert.ok(capturedAdded.includes("bar"));
+  assert.ok(capturedAdded.includes("world"));
+
+  assert.is(capturedRemoved.length, 1);
+  assert.ok(capturedRemoved.includes("baz"));
+});
+
+da.run();