cx 26.0.12 → 26.0.13

package/src/data/getSelector.spec.ts

@@ -1,43 +1,43 @@
-import { getSelector } from "./getSelector";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-
-describe("getSelector", function () {
-   it("array of selectors converts each element into a selector", function () {
-      let arraySelector = [{ bind: "name" }, { expr: "{name}" }];
-      let state = { name: "Joe" };
-      let selector = getSelector(arraySelector);
-      assert.deepEqual(selector(state), ["Joe", "Joe"]);
-   });
-
-   it("get can be used for selectors that have set defined too ", function () {
-      let selector = getSelector({ get: (data: any) => data.name, set: () => {} });
-      assert.deepEqual(selector({ name: "Jack" }), "Jack");
-   });
-
-   it("0 is a valid selector", function () {
-      let selector = getSelector(0);
-      assert.deepEqual(selector({}), 0);
-   });
-
-   it("false is a valid selector", function () {
-      let selector = getSelector(false);
-      assert.deepEqual(selector({}), false);
-   });
-
-   it("undefined is a valid selector", function () {
-      let selector = getSelector(undefined);
-      assert(selector({}) === undefined);
-   });
-
-   it("null is a valid selector", function () {
-      let selector = getSelector(null);
-      assert(selector({}) === null);
-   });
-
-   it("works with accessor chains", function () {
-      let m = createAccessorModelProxy<{ a: { b: any } }>();
-      let selector = getSelector(m.a.b);
-      assert(selector({ a: { b: 1 } }) === 1);
-   });
-});
+import { getSelector } from "./getSelector";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+
+describe("getSelector", function () {
+   it("array of selectors converts each element into a selector", function () {
+      let arraySelector = [{ bind: "name" }, { expr: "{name}" }];
+      let state = { name: "Joe" };
+      let selector = getSelector(arraySelector);
+      assert.deepEqual(selector(state), ["Joe", "Joe"]);
+   });
+
+   it("get can be used for selectors that have set defined too ", function () {
+      let selector = getSelector({ get: (data: any) => data.name, set: () => {} });
+      assert.deepEqual(selector({ name: "Jack" }), "Jack");
+   });
+
+   it("0 is a valid selector", function () {
+      let selector = getSelector(0);
+      assert.deepEqual(selector({}), 0);
+   });
+
+   it("false is a valid selector", function () {
+      let selector = getSelector(false);
+      assert.deepEqual(selector({}), false);
+   });
+
+   it("undefined is a valid selector", function () {
+      let selector = getSelector(undefined);
+      assert(selector({}) === undefined);
+   });
+
+   it("null is a valid selector", function () {
+      let selector = getSelector(null);
+      assert(selector({}) === null);
+   });
+
+   it("works with accessor chains", function () {
+      let m = createAccessorModelProxy<{ a: { b: any } }>();
+      let selector = getSelector(m.a.b);
+      assert(selector({ a: { b: 1 } }) === 1);
+   });
+});

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/findTreeNode.ts

@@ -1,8 +1,4 @@
-export function findTreeNode<T extends Record<string, any>>(
-   array: T[],
-   criteria: (node: T) => boolean,
-   childrenField: keyof T = "$children" as keyof T,
-): T | false {
+export function findTreeNode<T = any>(array: T[], criteria: (node: T) => boolean, childrenField: keyof T): T | false {
    if (!Array.isArray(array)) return false;
 
    for (const node of array) {

package/src/data/ops/findTreePath.ts

@@ -1,4 +1,4 @@
-export function findTreePath<T extends Record<string, any>>(
+export function findTreePath<T = any>(
    array: T[] | undefined,
    criteria: (node: T) => boolean,
    childrenField: keyof T = "$children" as keyof T,

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

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,6 +1,6 @@
 import { updateArray } from "./updateArray";
 
-export function updateTree<T extends Record<string, any> = any>(
+export function updateTree<T = any>(
    array: T[] | undefined,
    updateCallback: (item: T) => T,
    itemFilter: ((item: T) => boolean) | null,