cx 26.1.1 → 26.1.2

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,15 +1,15 @@
-import { updateTree } from "./updateTree";
-
-export function removeTreeNodes<T = any>(
-   array: T[] | undefined,
-   criteria: (node: T) => boolean,
-   childrenField: keyof T,
-): T[] | undefined {
-   return updateTree(
-      array,
-      (x) => x,
-      () => false,
-      childrenField,
-      criteria,
-   );
-}
+import { updateTree } from "./updateTree";
+
+export function removeTreeNodes<T = any>(
+   array: T[] | undefined,
+   criteria: (node: T) => boolean,
+   childrenField: 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>(
-   array: T[] | undefined,
-   updateCallback: (item: T, index: number) => T,
-   itemFilter?: null | ((item: T, index: number) => boolean),
-   removeFilter?: (item: T, index: number) => boolean,
-): T[] | undefined {
-   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;
-}
+export function updateArray<T = any>(
+   array: T[] | undefined,
+   updateCallback: (item: T, index: number) => T,
+   itemFilter?: null | ((item: T, index: number) => boolean),
+   removeFilter?: (item: T, index: number) => boolean,
+): T[] | undefined {
+   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;
+}

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,
+               },
+            ],
+         },
+      ]);
+   });
+});

package/src/data/ops/updateTree.ts

@@ -1,23 +1,23 @@
-import { updateArray } from "./updateArray";
-
-export function updateTree<T = any>(
-   array: T[] | undefined,
-   updateCallback: (item: T) => T,
-   itemFilter: ((item: T) => boolean) | null,
-   childrenField: keyof T,
-   removeFilter?: (item: T) => boolean,
-): T[] | undefined {
-   return updateArray(
-      array,
-      (item: T) => {
-         if (!itemFilter || itemFilter(item)) item = updateCallback(item);
-         const children = item[childrenField];
-         if (!Array.isArray(children)) return item;
-         const updatedChildren = updateTree(children, updateCallback, itemFilter, childrenField, removeFilter);
-         if (updatedChildren != children) return { ...item, [childrenField]: updatedChildren };
-         return item;
-      },
-      null,
-      removeFilter,
-   );
-}
+import { updateArray } from "./updateArray";
+
+export function updateTree<T = any>(
+   array: T[] | undefined,
+   updateCallback: (item: T) => T,
+   itemFilter: ((item: T) => boolean) | null,
+   childrenField: keyof T,
+   removeFilter?: (item: T) => boolean,
+): T[] | undefined {
+   return updateArray(
+      array,
+      (item: T) => {
+         if (!itemFilter || itemFilter(item)) item = updateCallback(item);
+         const children = item[childrenField];
+         if (!Array.isArray(children)) return item;
+         const updatedChildren = updateTree(children, updateCallback, itemFilter, childrenField, removeFilter);
+         if (updatedChildren != children) return { ...item, [childrenField]: updatedChildren };
+         return item;
+      },
+      null,
+      removeFilter,
+   );
+}

package/src/data/test-types.ts

@@ -1,7 +1,7 @@
-import { AccessorChain } from "./createAccessorModelProxy";
-
-// Test what AccessorChain<string[]> looks like
-type Test1 = AccessorChain<string[]>;
-type Test2 = AccessorChain<string[]>["length"];
-
-// The issue: does AccessorChain properly map array properties?
+import { AccessorChain } from "./createAccessorModelProxy";
+
+// Test what AccessorChain<string[]> looks like
+type Test1 = AccessorChain<string[]>;
+type Test2 = AccessorChain<string[]>["length"];
+
+// The issue: does AccessorChain properly map array properties?

package/src/global.scss

@@ -1,14 +1,14 @@
-
-$cx-include-global-rules: false !default;
-
-@mixin cx-global-rules() {
-   @each $tag, $styles in $cx-element-style-map {
-      #{$tag} {
-         @include cx-add-rules($styles)
-      }
-   }
-}
-
-@if ($cx-include-global-rules and cx-call-once('cx/globals')) {
-   @include cx-global-rules();
+
+$cx-include-global-rules: false !default;
+
+@mixin cx-global-rules() {
+   @each $tag, $styles in $cx-element-style-map {
+      #{$tag} {
+         @include cx-add-rules($styles)
+      }
+   }
+}
+
+@if ($cx-include-global-rules and cx-call-once('cx/globals')) {
+   @include cx-global-rules();
 }

package/src/hooks/createLocalStorageRef.ts

@@ -1,21 +1,21 @@
-import { useStore } from "./store";
-import { Ref } from "../data/Ref";
-
-export function createLocalStorageRef<T = any>(key: string): Ref<T> {
-   let store = useStore();
-
-   return new Ref<T>({
-      get(): T {
-         let json = localStorage.getItem(key);
-         if (!json) return localStorage.hasOwnProperty(key) ? (null as any) : (undefined as any);
-         return JSON.parse(json) as T;
-      },
-      set(value: T): boolean {
-         if (value === undefined) localStorage.removeItem(key);
-         else localStorage.setItem(key, JSON.stringify(value));
-         store.meta.version++;
-         store.notify();
-         return true;
-      },
-   });
-}
+import { useStore } from "./store";
+import { Ref } from "../data/Ref";
+
+export function createLocalStorageRef<T = any>(key: string): Ref<T> {
+   let store = useStore();
+
+   return new Ref<T>({
+      get(): T {
+         let json = localStorage.getItem(key);
+         if (!json) return localStorage.hasOwnProperty(key) ? (null as any) : (undefined as any);
+         return JSON.parse(json) as T;
+      },
+      set(value: T): boolean {
+         if (value === undefined) localStorage.removeItem(key);
+         else localStorage.setItem(key, JSON.stringify(value));
+         store.meta.version++;
+         store.notify();
+         return true;
+      },
+   });
+}

package/src/hooks/index.ts

@@ -1,8 +1,8 @@
-export * from "./store";
-export * from "./useEffect";
-export * from "./useInterval";
-export * from "./useTrigger";
-export * from "./useState";
-export * from "./createLocalStorageRef";
-export * from "./resolveCallback";
-export * from "./invokeCallback";
+export * from "./store";
+export * from "./useEffect";
+export * from "./useInterval";
+export * from "./useTrigger";
+export * from "./useState";
+export * from "./createLocalStorageRef";
+export * from "./resolveCallback";
+export * from "./invokeCallback";