cx 26.4.0 → 26.4.1

package/src/data/ops/findTreePath.ts

@@ -1,28 +1,28 @@
-export function findTreePath<T = any>(
-   array: T[] | undefined,
-   criteria: (node: T) => boolean,
-   childrenField: NoInfer<keyof T>,
-   currentPath: T[] = [],
-): T[] | false {
-   if (!Array.isArray(array)) return false;
-
-   for (const node of array) {
-      currentPath.push(node);
-
-      if (criteria(node)) return [...currentPath];
-
-      const children = node[childrenField] as T[] | undefined;
-
-      const childPath = findTreePath(
-         children,
-         criteria,
-         childrenField,
-         currentPath,
-      );
-      if (childPath) return childPath;
-
-      currentPath.pop();
-   }
-
-   return false;
-}
+export function findTreePath<T = any>(
+   array: T[] | undefined,
+   criteria: (node: T) => boolean,
+   childrenField: NoInfer<keyof T>,
+   currentPath: T[] = [],
+): T[] | false {
+   if (!Array.isArray(array)) return false;
+
+   for (const node of array) {
+      currentPath.push(node);
+
+      if (criteria(node)) return [...currentPath];
+
+      const children = node[childrenField] as T[] | undefined;
+
+      const childPath = findTreePath(
+         children,
+         criteria,
+         childrenField,
+         currentPath,
+      );
+      if (childPath) return childPath;
+
+      currentPath.pop();
+   }
+
+   return false;
+}

package/src/data/ops/index.ts

@@ -1,11 +1,11 @@
-export * from './append';
-export * from './merge';
-export * from './filter';
-export * from './updateArray';
-export * from './updateTree';
-export * from './removeTreeNodes';
-export * from './findTreeNode';
-export * from './moveElement';
-export * from './insertElement';
-export * from './findTreePath';
-
+export * from './append';
+export * from './merge';
+export * from './filter';
+export * from './updateArray';
+export * from './updateTree';
+export * from './removeTreeNodes';
+export * from './findTreeNode';
+export * from './moveElement';
+export * from './insertElement';
+export * from './findTreePath';
+

package/src/data/ops/insertElement.ts

@@ -1,3 +1,3 @@
-export function insertElement<T>(array: T[], index: number, ...elements: T[]): T[] {
-   return [...array.slice(0, index), ...elements, ...array.slice(index)];
-}
+export function insertElement<T>(array: T[], index: number, ...elements: T[]): T[] {
+   return [...array.slice(0, index), ...elements, ...array.slice(index)];
+}

package/src/data/ops/merge.spec.ts

@@ -1,27 +1,27 @@
-import { Store } from "../Store";
-import { merge } from "./merge";
-import assert from "assert";
-
-describe("merge", function () {
-   it("performs multiple set operations", function () {
-      let store = new Store({
-         data: {
-            person: { firstName: "John", lastName: "Doe" },
-         },
-      });
-
-      assert(store.update("person", merge, { firstName: "Johny", age: 18 }));
-      assert.deepEqual(store.get("person"), { firstName: "Johny", lastName: "Doe", age: 18 });
-   });
-
-   it("does not modify data if not necessary", function () {
-      let store = new Store({
-         data: {
-            person: { firstName: "John", lastName: "Doe" },
-         },
-      });
-
-      assert(store.update("person", merge, { firstName: "John" }) == false);
-      assert.deepEqual(store.get("person"), { firstName: "John", lastName: "Doe" });
-   });
-});
+import { Store } from "../Store";
+import { merge } from "./merge";
+import assert from "assert";
+
+describe("merge", function () {
+   it("performs multiple set operations", function () {
+      let store = new Store({
+         data: {
+            person: { firstName: "John", lastName: "Doe" },
+         },
+      });
+
+      assert(store.update("person", merge, { firstName: "Johny", age: 18 }));
+      assert.deepEqual(store.get("person"), { firstName: "Johny", lastName: "Doe", age: 18 });
+   });
+
+   it("does not modify data if not necessary", function () {
+      let store = new Store({
+         data: {
+            person: { firstName: "John", lastName: "Doe" },
+         },
+      });
+
+      assert(store.update("person", merge, { firstName: "John" }) == false);
+      assert.deepEqual(store.get("person"), { firstName: "John", lastName: "Doe" });
+   });
+});

package/src/data/ops/merge.ts

@@ -1,13 +1,13 @@
-import { Binding } from "../Binding";
-
-export function merge<T extends object>(item: T, data?: Partial<T>): T {
-   let result = item;
-
-   if (data) {
-      for (const key in data) {
-         result = Binding.get(key).set(result, data[key] as any);
-      }
-   }
-
-   return result;
-}
+import { Binding } from "../Binding";
+
+export function merge<T extends object>(item: T, data?: Partial<T>): T {
+   let result = item;
+
+   if (data) {
+      for (const key in data) {
+         result = Binding.get(key).set(result, data[key] as any);
+      }
+   }
+
+   return result;
+}

package/src/data/ops/moveElement.ts

@@ -1,21 +1,21 @@
-export function moveElement<T>(array: T[], sourceIndex: number, targetIndex: number): T[] {
-   if (sourceIndex === targetIndex) return array;
-
-   const result = [...array];
-   const element = result[sourceIndex];
-
-   if (sourceIndex < targetIndex) {
-      for (let i = sourceIndex; i < targetIndex - 1; i++) {
-         result[i] = result[i + 1];
-      }
-      result[targetIndex - 1] = result[targetIndex];
-      targetIndex--;
-   } else {
-      for (let i = sourceIndex; i > targetIndex; i--) {
-         result[i] = result[i - 1];
-      }
-   }
-
-   result[targetIndex] = element;
-   return result;
-}
+export function moveElement<T>(array: T[], sourceIndex: number, targetIndex: number): T[] {
+   if (sourceIndex === targetIndex) return array;
+
+   const result = [...array];
+   const element = result[sourceIndex];
+
+   if (sourceIndex < targetIndex) {
+      for (let i = sourceIndex; i < targetIndex - 1; i++) {
+         result[i] = result[i + 1];
+      }
+      result[targetIndex - 1] = result[targetIndex];
+      targetIndex--;
+   } else {
+      for (let i = sourceIndex; i > targetIndex; i--) {
+         result[i] = result[i - 1];
+      }
+   }
+
+   result[targetIndex] = element;
+   return result;
+}

package/src/data/ops/removeTreeNodes.spec.ts

@@ -1,37 +1,37 @@
-import { Store } from "../Store";
-import { removeTreeNodes } from "./removeTreeNodes";
-import assert from "assert";
-
-describe("removeTreeNodes", function () {
-   it("removes all nodes that satisfy criteria", function () {
-      let store = new Store({
-         data: {
-            array: [
-               {
-                  id: "n1",
-                  value: 1,
-                  children: [
-                     {
-                        id: "n11",
-                        value: 2,
-                     },
-                     {
-                        id: "n12",
-                        value: 3,
-                     },
-                  ],
-               },
-            ],
-         },
-      });
-
-      assert(store.update("array", removeTreeNodes, (x: any) => x.value > 1, "children"));
-      assert.deepEqual(store.get("array"), [
-         {
-            id: "n1",
-            value: 1,
-            children: [],
-         },
-      ]);
-   });
-});
+import { Store } from "../Store";
+import { removeTreeNodes } from "./removeTreeNodes";
+import assert from "assert";
+
+describe("removeTreeNodes", function () {
+   it("removes all nodes that satisfy criteria", function () {
+      let store = new Store({
+         data: {
+            array: [
+               {
+                  id: "n1",
+                  value: 1,
+                  children: [
+                     {
+                        id: "n11",
+                        value: 2,
+                     },
+                     {
+                        id: "n12",
+                        value: 3,
+                     },
+                  ],
+               },
+            ],
+         },
+      });
+
+      assert(store.update("array", removeTreeNodes, (x: any) => x.value > 1, "children"));
+      assert.deepEqual(store.get("array"), [
+         {
+            id: "n1",
+            value: 1,
+            children: [],
+         },
+      ]);
+   });
+});

package/src/data/ops/removeTreeNodes.ts

@@ -1,28 +1,28 @@
-import { updateTree } from "./updateTree";
-
-/**
- * Recursively removes nodes from a tree structure that match the criteria.
- * Returns a new tree without the matching nodes, or the original tree if no nodes were removed.
- *
- * @param array - The tree data array to filter.
- * @param criteria - Predicate that returns `true` for nodes to remove.
- * @param childrenField - Name of the property containing child nodes.
- * @returns A new tree with matching nodes removed, or the original array if unchanged.
- *
- * @example
- * // Remove node by ID
- * removeTreeNodes(data, node => node.id === targetId, "$children");
- */
-export function removeTreeNodes<T = any>(
-   array: T[] | undefined,
-   criteria: (node: T) => boolean,
-   childrenField: NoInfer<keyof T>,
-): T[] | undefined {
-   return updateTree(
-      array,
-      (x) => x,
-      () => false,
-      childrenField,
-      criteria,
-   );
-}
+import { updateTree } from "./updateTree";
+
+/**
+ * Recursively removes nodes from a tree structure that match the criteria.
+ * Returns a new tree without the matching nodes, or the original tree if no nodes were removed.
+ *
+ * @param array - The tree data array to filter.
+ * @param criteria - Predicate that returns `true` for nodes to remove.
+ * @param childrenField - Name of the property containing child nodes.
+ * @returns A new tree with matching nodes removed, or the original array if unchanged.
+ *
+ * @example
+ * // Remove node by ID
+ * removeTreeNodes(data, node => node.id === targetId, "$children");
+ */
+export function removeTreeNodes<T = any>(
+   array: T[] | undefined,
+   criteria: (node: T) => boolean,
+   childrenField: NoInfer<keyof T>,
+): T[] | undefined {
+   return updateTree(
+      array,
+      (x) => x,
+      () => false,
+      childrenField,
+      criteria,
+   );
+}

package/src/data/ops/updateArray.spec.ts

@@ -1,69 +1,69 @@
-import { Store } from "../Store";
-import { updateArray } from "./updateArray";
-import assert from "assert";
-
-describe("updateArray", function () {
-   it("updates all elements that satisfy criteria", function () {
-      let store = new Store({
-         data: { array: [1, 2, 3, 4, 5, 6] },
-      });
-
-      assert(
-         store.update(
-            "array",
-            updateArray,
-            (x) => x + 1,
-            (x) => x > 3,
-         ),
-      );
-      assert.deepEqual(store.get("array"), [1, 2, 3, 5, 6, 7]);
-   });
-
-   it("does not modify data if not necessary", function () {
-      let array = [1, 2, 3, 4, 5, 6];
-      let store = new Store({
-         data: { array },
-      });
-
-      assert(
-         false ===
-            store.update(
-               "array",
-               updateArray,
-               (x) => x + 1,
-               (x) => x > 10,
-            ),
-      );
-      assert(store.get("array") === array);
-   });
-
-   it("works with null or undefined", function () {
-      let store = new Store();
-      assert(
-         false ===
-            store.update(
-               "array",
-               updateArray,
-               (x) => x + 1,
-               (x) => x > 0,
-            ),
-      );
-   });
-
-   it("can remove elements given the criteria", function () {
-      let store = new Store({
-         data: { array: [1, 2, 3, 4, 5, 6] },
-      });
-
-      assert(
-         store.update(
-            "array",
-            updateArray,
-            (x) => x + 1,
-            (x) => x > 3,
-            (x) => x <= 3,
-         ),
-      );
-      assert.deepEqual(store.get("array"), [5, 6, 7]);
-   });
-});
+import { Store } from "../Store";
+import { updateArray } from "./updateArray";
+import assert from "assert";
+
+describe("updateArray", function () {
+   it("updates all elements that satisfy criteria", function () {
+      let store = new Store({
+         data: { array: [1, 2, 3, 4, 5, 6] },
+      });
+
+      assert(
+         store.update(
+            "array",
+            updateArray,
+            (x) => x + 1,
+            (x) => x > 3,
+         ),
+      );
+      assert.deepEqual(store.get("array"), [1, 2, 3, 5, 6, 7]);
+   });
+
+   it("does not modify data if not necessary", function () {
+      let array = [1, 2, 3, 4, 5, 6];
+      let store = new Store({
+         data: { array },
+      });
+
+      assert(
+         false ===
+            store.update(
+               "array",
+               updateArray,
+               (x) => x + 1,
+               (x) => x > 10,
+            ),
+      );
+      assert(store.get("array") === array);
+   });
+
+   it("works with null or undefined", function () {
+      let store = new Store();
+      assert(
+         false ===
+            store.update(
+               "array",
+               updateArray,
+               (x) => x + 1,
+               (x) => x > 0,
+            ),
+      );
+   });
+
+   it("can remove elements given the criteria", function () {
+      let store = new Store({
+         data: { array: [1, 2, 3, 4, 5, 6] },
+      });
+
+      assert(
+         store.update(
+            "array",
+            updateArray,
+            (x) => x + 1,
+            (x) => x > 3,
+            (x) => x <= 3,
+         ),
+      );
+      assert.deepEqual(store.get("array"), [5, 6, 7]);
+   });
+});

package/src/data/ops/updateArray.ts

@@ -1,31 +1,31 @@
-export function updateArray<T = any, A extends T[] | undefined = T[] | undefined>(
-   array: A,
-   updateCallback: (item: T, index: number) => T,
-   itemFilter?: null | ((item: T, index: number) => boolean),
-   removeFilter?: (item: T, index: number) => boolean,
-): A {
-   if (!array) return array;
-
-   const newArray: T[] = [];
-   let dirty: boolean = false;
-
-   for (let index = 0; index < array.length; index++) {
-      const item = array[index];
-
-      if (removeFilter && removeFilter(item, index)) {
-         dirty = true;
-         continue;
-      }
-
-      if (!itemFilter || itemFilter(item, index)) {
-         const newItem = updateCallback(item, index);
-         newArray.push(newItem);
-
-         if (newItem !== item) dirty = true;
-      } else {
-         newArray.push(item);
-      }
-   }
-
-   return (dirty ? newArray : array) as A;
-}
+export function updateArray<T = any, A extends T[] | undefined = T[] | undefined>(
+   array: A,
+   updateCallback: (item: T, index: number) => T,
+   itemFilter?: null | ((item: T, index: number) => boolean),
+   removeFilter?: (item: T, index: number) => boolean,
+): A {
+   if (!array) return array;
+
+   const newArray: T[] = [];
+   let dirty: boolean = false;
+
+   for (let index = 0; index < array.length; index++) {
+      const item = array[index];
+
+      if (removeFilter && removeFilter(item, index)) {
+         dirty = true;
+         continue;
+      }
+
+      if (!itemFilter || itemFilter(item, index)) {
+         const newItem = updateCallback(item, index);
+         newArray.push(newItem);
+
+         if (newItem !== item) dirty = true;
+      } else {
+         newArray.push(item);
+      }
+   }
+
+   return (dirty ? newArray : array) as A;
+}

package/src/data/ops/updateTree.spec.ts

@@ -1,54 +1,54 @@
-import { Store } from "../Store";
-import { updateTree } from "./updateTree";
-import assert from "assert";
-
-describe("updateTree", function () {
-   it("updates all nodes that satisfy criteria", function () {
-      let store = new Store({
-         data: {
-            array: [
-               {
-                  id: "n1",
-                  value: 1,
-                  children: [
-                     {
-                        id: "n11",
-                        value: 2,
-                     },
-                     {
-                        id: "n12",
-                        value: 3,
-                     },
-                  ],
-               },
-            ],
-         },
-      });
-
-      assert(
-         store.update(
-            "array",
-            updateTree,
-            (x) => ({ ...x, value: x.value + 1 }),
-            (x) => x.value > 1,
-            "children",
-         ),
-      );
-      assert.deepEqual(store.get("array"), [
-         {
-            id: "n1",
-            value: 1,
-            children: [
-               {
-                  id: "n11",
-                  value: 3,
-               },
-               {
-                  id: "n12",
-                  value: 4,
-               },
-            ],
-         },
-      ]);
-   });
-});
+import { Store } from "../Store";
+import { updateTree } from "./updateTree";
+import assert from "assert";
+
+describe("updateTree", function () {
+   it("updates all nodes that satisfy criteria", function () {
+      let store = new Store({
+         data: {
+            array: [
+               {
+                  id: "n1",
+                  value: 1,
+                  children: [
+                     {
+                        id: "n11",
+                        value: 2,
+                     },
+                     {
+                        id: "n12",
+                        value: 3,
+                     },
+                  ],
+               },
+            ],
+         },
+      });
+
+      assert(
+         store.update(
+            "array",
+            updateTree,
+            (x) => ({ ...x, value: x.value + 1 }),
+            (x) => x.value > 1,
+            "children",
+         ),
+      );
+      assert.deepEqual(store.get("array"), [
+         {
+            id: "n1",
+            value: 1,
+            children: [
+               {
+                  id: "n11",
+                  value: 3,
+               },
+               {
+                  id: "n12",
+                  value: 4,
+               },
+            ],
+         },
+      ]);
+   });
+});