cx 26.3.9 → 26.4.0

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

@@ -1,30 +1,30 @@
-export * from "./Binding";
-export * from "./Expression";
-export * from "./StringTemplate";
-export * from "./View";
-export * from "./SubscribableView";
-export * from "./Store";
-export * from "./ExposedRecordView";
-export * from "./ExposedValueView";
-export * from "./ReadOnlyDataView";
-export * from "./ZoomIntoPropertyView";
-export * from "./StructuredSelector";
-export * from "./computable";
-export * from "./getSelector";
-export * from "./isSelector";
-export * from "./Grouper";
-export * from "./comparer";
-export * from "./enableFatArrowExpansion";
-export * from "./ops/index";
-export * from "./diff/index";
-export * from "./Ref";
-export * from "./ArrayRef";
-export * from "./StoreProxy";
-export * from "./AugmentedViewBase";
-export * from "./ArrayElementView";
-export * from "./getAccessor";
-export * from "./defaultCompare";
-export * from "./NestedDataView";
-
-export * from "./createAccessorModelProxy";
-export * from "./Selector";
+export * from "./Binding";
+export * from "./Expression";
+export * from "./StringTemplate";
+export * from "./View";
+export * from "./SubscribableView";
+export * from "./Store";
+export * from "./ExposedRecordView";
+export * from "./ExposedValueView";
+export * from "./ReadOnlyDataView";
+export * from "./ZoomIntoPropertyView";
+export * from "./StructuredSelector";
+export * from "./computable";
+export * from "./getSelector";
+export * from "./isSelector";
+export * from "./Grouper";
+export * from "./comparer";
+export * from "./enableFatArrowExpansion";
+export * from "./ops/index";
+export * from "./diff/index";
+export * from "./Ref";
+export * from "./ArrayRef";
+export * from "./StoreProxy";
+export * from "./AugmentedViewBase";
+export * from "./ArrayElementView";
+export * from "./getAccessor";
+export * from "./defaultCompare";
+export * from "./NestedDataView";
+
+export * from "./createAccessorModelProxy";
+export * from "./Selector";

package/src/data/isSelector.ts

@@ -1,26 +1,26 @@
-export function isSelector(config: any): boolean {
-
-   if (config == null)
-      return true;
-
-   switch (typeof config) {
-      case 'object':
-         if (config.type || config.$type)
-            return false;
-         return !!(config.bind || config.tpl || config.expr || config.get);
-
-      case 'function':
-         return true;
-
-      case 'string':
-         return true;
-
-      case 'number':
-         return true;
-
-      case 'boolean':
-         return true;
-   }
-
-   return false;
-}
+export function isSelector(config: any): boolean {
+
+   if (config == null)
+      return true;
+
+   switch (typeof config) {
+      case 'object':
+         if (config.type || config.$type)
+            return false;
+         return !!(config.bind || config.tpl || config.expr || config.get);
+
+      case 'function':
+         return true;
+
+      case 'string':
+         return true;
+
+      case 'number':
+         return true;
+
+      case 'boolean':
+         return true;
+   }
+
+   return false;
+}

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

@@ -1,28 +1,28 @@
-import assert from 'assert';
-import { Store } from '../Store';
-import { append } from './append';
-
-describe('append', function() {
-   it('should add elements to an array', function () {
-      let store = new Store({
-         data: {
-            array: []
-         }
-      });
-
-      assert(store.update('array', append, 1));
-      assert.deepEqual(store.get('array'), [1]);
-   });
-
-   it('should work with undefined arrays', function () {
-      let store = new Store();
-      assert(store.update('array', append, 1));
-      assert.deepEqual(store.get('array'), [1]);
-   });
-
-   it('accepts multiple arguments', function () {
-      let store = new Store();
-      assert(store.update('array', append, 1, 2, 3));
-      assert.deepEqual(store.get('array'), [1, 2, 3]);
-   });
-});
+import assert from 'assert';
+import { Store } from '../Store';
+import { append } from './append';
+
+describe('append', function() {
+   it('should add elements to an array', function () {
+      let store = new Store({
+         data: {
+            array: []
+         }
+      });
+
+      assert(store.update('array', append, 1));
+      assert.deepEqual(store.get('array'), [1]);
+   });
+
+   it('should work with undefined arrays', function () {
+      let store = new Store();
+      assert(store.update('array', append, 1));
+      assert.deepEqual(store.get('array'), [1]);
+   });
+
+   it('accepts multiple arguments', function () {
+      let store = new Store();
+      assert(store.update('array', append, 1, 2, 3));
+      assert.deepEqual(store.get('array'), [1, 2, 3]);
+   });
+});

package/src/data/ops/append.ts

@@ -1,5 +1,5 @@
-export function append<T>(array: T[], ...items: T[]): T[] {
-   if (items.length === 0) return array ?? [];
-   if (!array) return items;
-   return [...array, ...items];
-}
+export function append<T>(array: T[], ...items: T[]): T[] {
+   if (items.length === 0) return array ?? [];
+   if (!array) return items;
+   return [...array, ...items];
+}

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.spec.ts

@@ -1,23 +1,23 @@
-import assert from 'assert';
-import { findTreeNode } from './findTreeNode';
-
-describe('removeTreeNodes', function() {
-   it('removes all nodes that satisfy criteria', function () {
-      let array = [{
-         id: 'n1',
-         value: 1,
-         children: [{
-            id: 'n11',
-            value: 2
-         }, {
-            id: 'n12',
-            value: 3
-         }]
-      }];
-
-      let node = findTreeNode(array, x => x.value == 3, 'children');
-
-      assert(node);
-      assert.equal(node.value, 3)
-   });
-});
+import assert from 'assert';
+import { findTreeNode } from './findTreeNode';
+
+describe('removeTreeNodes', function() {
+   it('removes all nodes that satisfy criteria', function () {
+      let array = [{
+         id: 'n1',
+         value: 1,
+         children: [{
+            id: 'n11',
+            value: 2
+         }, {
+            id: 'n12',
+            value: 3
+         }]
+      }];
+
+      let node = findTreeNode(array, x => x.value == 3, 'children');
+
+      assert(node);
+      assert.equal(node.value, 3)
+   });
+});

package/src/data/ops/findTreeNode.ts

@@ -1,33 +1,33 @@
-/**
- * Recursively searches a tree structure for a node matching the criteria.
- *
- * @param array - The tree data array to search.
- * @param criteria - Predicate that returns `true` when a matching node is found.
- * @param childrenField - Name of the property containing child nodes.
- * @returns The first matching node, or `false` if not found.
- *
- * @example
- * // Find node by ID
- * const node = findTreeNode(data, n => n.id === targetId, "$children");
- *
- * @example
- * // Check if selected node is a leaf
- * const node = findTreeNode(data, n => n.id === selectedId, "$children");
- * if (node && node.$leaf) {
- *   // Cannot add children to a leaf node
- * }
- */
-export function findTreeNode<T = any>(array: T[], criteria: (node: T) => boolean, childrenField: NoInfer<keyof T>): T | false {
-   if (!Array.isArray(array)) return false;
-
-   for (const node of array) {
-      if (criteria(node)) return node;
-
-      const children = node[childrenField] as T[];
-
-      const found = findTreeNode(children, criteria, childrenField);
-      if (found) return found;
-   }
-
-   return false;
-}
+/**
+ * Recursively searches a tree structure for a node matching the criteria.
+ *
+ * @param array - The tree data array to search.
+ * @param criteria - Predicate that returns `true` when a matching node is found.
+ * @param childrenField - Name of the property containing child nodes.
+ * @returns The first matching node, or `false` if not found.
+ *
+ * @example
+ * // Find node by ID
+ * const node = findTreeNode(data, n => n.id === targetId, "$children");
+ *
+ * @example
+ * // Check if selected node is a leaf
+ * const node = findTreeNode(data, n => n.id === selectedId, "$children");
+ * if (node && node.$leaf) {
+ *   // Cannot add children to a leaf node
+ * }
+ */
+export function findTreeNode<T = any>(array: T[], criteria: (node: T) => boolean, childrenField: NoInfer<keyof T>): T | false {
+   if (!Array.isArray(array)) return false;
+
+   for (const node of array) {
+      if (criteria(node)) return node;
+
+      const children = node[childrenField] as T[];
+
+      const found = findTreeNode(children, criteria, childrenField);
+      if (found) return found;
+   }
+
+   return false;
+}

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