cx 26.0.4 → 26.0.6

package/src/data/getSelector.ts

@@ -1,66 +1,66 @@
-import { expr } from "cx/ui";
-import { Binding } from "./Binding";
-import { Expression } from "./Expression";
-import { StringTemplate } from "./StringTemplate";
-import { isArray } from "../util/isArray";
-import { createStructuredSelector, StructuredSelectorConfig } from "./createStructuredSelector";
-import { isSelector } from "./isSelector";
-import { isAccessorChain } from "./createAccessorModelProxy";
-import { isString } from "../util/isString";
-import { hasKey, hasStringAtKey, hasFunctionAtKey } from "../util/hasKey";
-import { isFunction } from "../util";
-
-type Selector<T> = (data: any) => T;
-
-var undefinedF = () => undefined;
-var nullF = () => null;
-
-export function getSelector(config: unknown): Selector<any> {
-   if (config === undefined) return undefinedF;
-   if (config === null) return nullF;
-
-   switch (typeof config) {
-      case "object":
-         if (isArray(config)) {
-            let selectors = config.map((x) => getSelector(x));
-            return (data) => selectors.map((elementSelector) => elementSelector(data));
-         }
-
-         //toString converts accessor chains to binding paths
-         if (hasKey(config, "bind") && config.bind != null) return Binding.get(config.bind.toString()).value;
-
-         if (hasStringAtKey(config, "tpl")) return StringTemplate.get(config.tpl);
-
-         if (hasKey(config, "expr") && (isString(config.expr) || isFunction(config.expr)))
-            return Expression.get(config.expr as any);
-
-         if (hasFunctionAtKey(config, "get")) return config.get;
-
-         let selectors: StructuredSelectorConfig = {};
-         let constants: Record<string, any> = {};
-
-         let obj = config as Record<string, any>;
-         for (let key in obj) {
-            switch (typeof obj[key]) {
-               case "bigint":
-               case "boolean":
-               case "number":
-               case "string":
-                  constants[key] = obj[key];
-                  break;
-               default:
-                  if (isSelector(obj[key])) selectors[key] = getSelector(obj[key]);
-                  else constants[key] = obj[key];
-                  break;
-            }
-         }
-         return createStructuredSelector(selectors, constants);
-
-      case "function":
-         if (isAccessorChain(config)) return Binding.get(config.toString()).value;
-         return config as Selector<any>;
-
-      default:
-         return () => config;
-   }
-}
+import { expr } from "cx/ui";
+import { Binding } from "./Binding";
+import { Expression } from "./Expression";
+import { StringTemplate } from "./StringTemplate";
+import { isArray } from "../util/isArray";
+import { createStructuredSelector, StructuredSelectorConfig } from "./createStructuredSelector";
+import { isSelector } from "./isSelector";
+import { isAccessorChain } from "./createAccessorModelProxy";
+import { isString } from "../util/isString";
+import { hasKey, hasStringAtKey, hasFunctionAtKey } from "../util/hasKey";
+import { isFunction } from "../util";
+
+type Selector<T> = (data: any) => T;
+
+var undefinedF = () => undefined;
+var nullF = () => null;
+
+export function getSelector(config: unknown): Selector<any> {
+   if (config === undefined) return undefinedF;
+   if (config === null) return nullF;
+
+   switch (typeof config) {
+      case "object":
+         if (isArray(config)) {
+            let selectors = config.map((x) => getSelector(x));
+            return (data) => selectors.map((elementSelector) => elementSelector(data));
+         }
+
+         //toString converts accessor chains to binding paths
+         if (hasKey(config, "bind") && config.bind != null) return Binding.get(config.bind.toString()).value;
+
+         if (hasStringAtKey(config, "tpl")) return StringTemplate.get(config.tpl);
+
+         if (hasKey(config, "expr") && (isString(config.expr) || isFunction(config.expr)))
+            return Expression.get(config.expr as any);
+
+         if (hasFunctionAtKey(config, "get")) return config.get;
+
+         let selectors: StructuredSelectorConfig = {};
+         let constants: Record<string, any> = {};
+
+         let obj = config as Record<string, any>;
+         for (let key in obj) {
+            switch (typeof obj[key]) {
+               case "bigint":
+               case "boolean":
+               case "number":
+               case "string":
+                  constants[key] = obj[key];
+                  break;
+               default:
+                  if (isSelector(obj[key])) selectors[key] = getSelector(obj[key]);
+                  else constants[key] = obj[key];
+                  break;
+            }
+         }
+         return createStructuredSelector(selectors, constants);
+
+      case "function":
+         if (isAccessorChain(config)) return Binding.get(config.toString()).value;
+         return config as Selector<any>;
+
+      default:
+         return () => config;
+   }
+}

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

@@ -1,35 +1,35 @@
-import assert from "assert";
-import { Store } from "../Store";
-import { filter } from "./filter";
-
-describe("filter", function () {
-   it("should filter array elements", function () {
-      let store = new Store({
-         data: {
-            array: [1, 2, 3],
-         },
-      });
-
-      assert(store.update("array", filter, (x: number) => x > 1));
-      assert.deepEqual(store.get("array"), [2, 3]);
-   });
-
-   it("should work with undefined arrays", function () {
-      let store = new Store();
-      assert.equal(
-         false,
-         store.update("array", filter, (x) => x > 1),
-      );
-      assert.deepEqual(store.get("array"), undefined);
-   });
-
-   it("returns same array if all elements satisfy condition", function () {
-      let array = [1, 2, 3];
-      let store = new Store({ data: { array } });
-      assert.equal(
-         false,
-         store.update("array", filter, (x) => x > 0),
-      );
-      assert(store.get("array") === array);
-   });
-});
+import assert from "assert";
+import { Store } from "../Store";
+import { filter } from "./filter";
+
+describe("filter", function () {
+   it("should filter array elements", function () {
+      let store = new Store({
+         data: {
+            array: [1, 2, 3],
+         },
+      });
+
+      assert(store.update("array", filter, (x: number) => x > 1));
+      assert.deepEqual(store.get("array"), [2, 3]);
+   });
+
+   it("should work with undefined arrays", function () {
+      let store = new Store();
+      assert.equal(
+         false,
+         store.update("array", filter, (x) => x > 1),
+      );
+      assert.deepEqual(store.get("array"), undefined);
+   });
+
+   it("returns same array if all elements satisfy condition", function () {
+      let array = [1, 2, 3];
+      let store = new Store({ data: { array } });
+      assert.equal(
+         false,
+         store.update("array", filter, (x) => x > 0),
+      );
+      assert(store.get("array") === array);
+   });
+});

package/src/data/ops/filter.ts

@@ -1,9 +1,9 @@
-export function filter<T = any>(array: T[], callback: (item: T, index: number, array: T[]) => boolean): T[] {
-   if (array == null) return array;
-
-   const result = array.filter(callback);
-
-   if (result.length === array.length) return array;
-
-   return result;
-}
+export function filter<T = any>(array: T[], callback: (item: T, index: number, array: T[]) => boolean): T[] {
+   if (array == null) return array;
+
+   const result = array.filter(callback);
+
+   if (result.length === array.length) return array;
+
+   return result;
+}

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/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 extends Record<string, any>>(
-   array: T[] | undefined,
-   criteria: (node: T) => boolean,
-   childrenField: keyof T = "$children" as keyof T,
-): T[] | undefined {
-   return updateTree(
-      array,
-      (x) => x,
-      () => false,
-      childrenField,
-      criteria,
-   );
-}
+import { updateTree } from "./updateTree";
+
+export function removeTreeNodes<T extends Record<string, any>>(
+   array: T[] | undefined,
+   criteria: (node: T) => boolean,
+   childrenField: keyof T = "$children" as 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.ts

@@ -1,23 +1,23 @@
-import { updateArray } from "./updateArray";
-
-export function updateTree<T extends Record<string, any> = 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 extends Record<string, any> = 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?