cx 26.1.0 → 26.1.2

package/src/data/diff/diffArrays.ts

@@ -1,49 +1,49 @@
-import { isUndefined } from "../../util/isUndefined";
-
-type KeyFn<T> = (item: T) => any;
-
-interface DiffResult<T> {
-   added: T[];
-   changed: { before: T; after: T }[];
-   unchanged: T[];
-   removed: T[];
-}
-
-export function diffArrays<T>(oldArray: T[], newArray: T[], keyFn: KeyFn<T> = (e) => e): DiffResult<T> {
-   const map = new Map<any, T>();
-
-   oldArray.forEach((item) => {
-      const key = keyFn(item);
-      map.set(key, item);
-   });
-
-   const added: T[] = [];
-   const changed: { before: T; after: T }[] = [];
-   const unchanged: T[] = [];
-
-   newArray.forEach((item) => {
-      const key = keyFn(item);
-      const oldItem = map.get(key);
-
-      if (isUndefined(oldItem)) {
-         added.push(item);
-      } else {
-         map.delete(key);
-
-         if (item === oldItem) {
-            unchanged.push(item);
-         } else {
-            changed.push({ before: oldItem, after: item });
-         }
-      }
-   });
-
-   const removed = Array.from(map.values());
-
-   return {
-      added,
-      changed,
-      unchanged,
-      removed,
-   };
-}
+import { isUndefined } from "../../util/isUndefined";
+
+type KeyFn<T> = (item: T) => any;
+
+interface DiffResult<T> {
+   added: T[];
+   changed: { before: T; after: T }[];
+   unchanged: T[];
+   removed: T[];
+}
+
+export function diffArrays<T>(oldArray: T[], newArray: T[], keyFn: KeyFn<T> = (e) => e): DiffResult<T> {
+   const map = new Map<any, T>();
+
+   oldArray.forEach((item) => {
+      const key = keyFn(item);
+      map.set(key, item);
+   });
+
+   const added: T[] = [];
+   const changed: { before: T; after: T }[] = [];
+   const unchanged: T[] = [];
+
+   newArray.forEach((item) => {
+      const key = keyFn(item);
+      const oldItem = map.get(key);
+
+      if (isUndefined(oldItem)) {
+         added.push(item);
+      } else {
+         map.delete(key);
+
+         if (item === oldItem) {
+            unchanged.push(item);
+         } else {
+            changed.push({ before: oldItem, after: item });
+         }
+      }
+   });
+
+   const removed = Array.from(map.values());
+
+   return {
+      added,
+      changed,
+      unchanged,
+      removed,
+   };
+}

package/src/data/diff/diffs.spec.ts

@@ -1,49 +1,49 @@
-import assert from 'assert';
-import {diffArrays} from './diffArrays';
-
-
-describe('diffArrays', function() {
-   it('should detect new elements', function () {
-      var a: {k: number, v?: number}[] = [];
-      var b = [{k: 1}, {k: 2}]
-      var d = diffArrays(a, b);
-      assert.deepEqual(d, {
-         added: [{k: 1}, {k: 2}],
-         removed: [],
-         unchanged: [],
-         changed: []
-      });
-   });
-
-   it('should detect removed elements', function () {
-      var a: {k: number}[] = [];
-      var b = [{k: 1}, {k: 2}]
-      var d = diffArrays(b, a);
-      assert.deepEqual(d, {
-         removed: [{k: 1}, {k: 2}],
-         added: [],
-         unchanged: [],
-         changed: []
-      });
-   });
-
-   it('should detect changed elements', function () {
-      var a = [{k: 1, v: 2}];
-      var b = [{k: 1}, {k: 2}]
-      var d = diffArrays(a, b, x=>x.k);
-      assert.deepEqual(d, {
-         added: [{k: 2}],
-         removed: [],
-         unchanged: [],
-         changed: [{
-            after: {
-               k: 1
-            },
-            before: {
-               k: 1, v: 2
-            }
-         }]
-      });
-   });
-});
-
+import assert from 'assert';
+import {diffArrays} from './diffArrays';
+
+
+describe('diffArrays', function() {
+   it('should detect new elements', function () {
+      var a: {k: number, v?: number}[] = [];
+      var b = [{k: 1}, {k: 2}]
+      var d = diffArrays(a, b);
+      assert.deepEqual(d, {
+         added: [{k: 1}, {k: 2}],
+         removed: [],
+         unchanged: [],
+         changed: []
+      });
+   });
+
+   it('should detect removed elements', function () {
+      var a: {k: number}[] = [];
+      var b = [{k: 1}, {k: 2}]
+      var d = diffArrays(b, a);
+      assert.deepEqual(d, {
+         removed: [{k: 1}, {k: 2}],
+         added: [],
+         unchanged: [],
+         changed: []
+      });
+   });
+
+   it('should detect changed elements', function () {
+      var a = [{k: 1, v: 2}];
+      var b = [{k: 1}, {k: 2}]
+      var d = diffArrays(a, b, x=>x.k);
+      assert.deepEqual(d, {
+         added: [{k: 2}],
+         removed: [],
+         unchanged: [],
+         changed: [{
+            after: {
+               k: 1
+            },
+            before: {
+               k: 1, v: 2
+            }
+         }]
+      });
+   });
+});
+

package/src/data/diff/index.ts

@@ -1 +1 @@
-export * from "./diffArrays";
+export * from "./diffArrays";

package/src/data/enableFatArrowExpansion.ts

@@ -1,6 +1,6 @@
-import { expandFatArrows } from '../util/expandFatArrows';
-import { plugFatArrowExpansion } from './Expression';
-
-export function enableFatArrowExpansion(): void {
-   plugFatArrowExpansion(expandFatArrows);
-}
+import { expandFatArrows } from '../util/expandFatArrows';
+import { plugFatArrowExpansion } from './Expression';
+
+export function enableFatArrowExpansion(): void {
+   plugFatArrowExpansion(expandFatArrows);
+}

package/src/data/getAccessor.spec.ts

@@ -1,11 +1,11 @@
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-import { getAccessor } from "./getAccessor";
-
-describe("getAccessor", function () {
-   it("works with accessor chains", function () {
-      let m = createAccessorModelProxy<{ a: { b: any } }>();
-      let accessor = getAccessor(m.a.b);
-      assert(typeof accessor.set == "function");
-   });
-});
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+import { getAccessor } from "./getAccessor";
+
+describe("getAccessor", function () {
+   it("works with accessor chains", function () {
+      let m = createAccessorModelProxy<{ a: { b: any } }>();
+      let accessor = getAccessor(m.a.b);
+      assert(typeof accessor.set == "function");
+   });
+});

package/src/data/getAccessor.ts

@@ -1,74 +1,74 @@
-import { Binding, isBinding } from "./Binding";
-import { isSelector } from "./isSelector";
-import { getSelector } from "./getSelector";
-import { isObject } from "../util/isObject";
-import { AccessorChain, isAccessorChain } from "./createAccessorModelProxy";
-import { Prop } from "../ui/Prop";
-import { View } from "./View";
-
-/*
-   Accessor provides a common ground between refs and bindings.
-   Refs offer simplicity, bindings have better performance with more arguments.
-   Accessor works as a common interface which works with both patterns.
- */
-
-export interface Accessor<T = any> {
-   get: (data: any) => T;
-   set?: (value: T, store: View) => boolean;
-   bindInstance?(instance: any): Accessor;
-   isAccessor?: boolean;
-   isRef?: boolean;
-}
-
-export function getAccessor<T = any>(accessor: Prop<T>): Accessor;
-export function getAccessor(accessor: Accessor): Accessor;
-
-export function getAccessor(accessor: any): Accessor | undefined {
-   if (accessor == null) return undefined;
-
-   if (isObject(accessor)) {
-      if ("isAccessor" in accessor || "isRef" in accessor) return accessor as Accessor;
-      if (isBinding(accessor)) {
-         let binding = Binding.get(accessor);
-         return {
-            get: binding.value,
-            set: (v, store) => store.set(binding.path, v),
-            isAccessor: true,
-         };
-      }
-   }
-
-   if (isAccessorChain(accessor)) {
-      let binding = Binding.get(accessor);
-      return {
-         get: binding.value,
-         set: (v, store) => store.set(binding.path, v),
-         isAccessor: true,
-      };
-   }
-
-   if (isSelector(accessor)) {
-      let selector = getSelector(accessor);
-      if (accessor && accessor.set)
-         return {
-            get: selector,
-            isAccessor: true,
-            bindInstance(instance) {
-               return {
-                  get: selector,
-                  set: (value) => accessor.set(value, instance),
-                  isAccessor: true,
-               };
-            },
-         };
-
-      return {
-         get: selector,
-         isAccessor: true,
-      };
-   }
-
-   return {
-      get: () => accessor,
-   };
-}
+import { Binding, isBinding } from "./Binding";
+import { isSelector } from "./isSelector";
+import { getSelector } from "./getSelector";
+import { isObject } from "../util/isObject";
+import { AccessorChain, isAccessorChain } from "./createAccessorModelProxy";
+import { Prop } from "../ui/Prop";
+import { View } from "./View";
+
+/*
+   Accessor provides a common ground between refs and bindings.
+   Refs offer simplicity, bindings have better performance with more arguments.
+   Accessor works as a common interface which works with both patterns.
+ */
+
+export interface Accessor<T = any> {
+   get: (data: any) => T;
+   set?: (value: T, store: View) => boolean;
+   bindInstance?(instance: any): Accessor;
+   isAccessor?: boolean;
+   isRef?: boolean;
+}
+
+export function getAccessor<T = any>(accessor: Prop<T>): Accessor;
+export function getAccessor(accessor: Accessor): Accessor;
+
+export function getAccessor(accessor: any): Accessor | undefined {
+   if (accessor == null) return undefined;
+
+   if (isObject(accessor)) {
+      if ("isAccessor" in accessor || "isRef" in accessor) return accessor as Accessor;
+      if (isBinding(accessor)) {
+         let binding = Binding.get(accessor);
+         return {
+            get: binding.value,
+            set: (v, store) => store.set(binding.path, v),
+            isAccessor: true,
+         };
+      }
+   }
+
+   if (isAccessorChain(accessor)) {
+      let binding = Binding.get(accessor);
+      return {
+         get: binding.value,
+         set: (v, store) => store.set(binding.path, v),
+         isAccessor: true,
+      };
+   }
+
+   if (isSelector(accessor)) {
+      let selector = getSelector(accessor);
+      if (accessor && accessor.set)
+         return {
+            get: selector,
+            isAccessor: true,
+            bindInstance(instance) {
+               return {
+                  get: selector,
+                  set: (value) => accessor.set(value, instance),
+                  isAccessor: true,
+               };
+            },
+         };
+
+      return {
+         get: selector,
+         isAccessor: true,
+      };
+   }
+
+   return {
+      get: () => accessor,
+   };
+}

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/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";