cx 26.4.0 → 26.4.2

package/src/data/createStructuredSelector.ts

@@ -1,62 +1,62 @@
-import { MemoSelector, Selector } from "./Selector";
-
-export interface StructuredSelectorConfig {
-   [prop: string]: Selector;
-}
-
-// Helper type to infer result type from selector config
-type InferStructuredSelectorResult<T extends StructuredSelectorConfig, C = {}> = {
-   [K in keyof T]: T[K] extends Selector<infer R> ? R : any;
-} & C;
-
-export function createStructuredSelector<S extends StructuredSelectorConfig, C extends Record<string, any> = {}>(
-   selector: S,
-   constants?: C,
-): MemoSelector<InferStructuredSelectorResult<S, C>> {
-   let keys = Object.keys(selector);
-   constants = constants ?? ({} as C);
-   if (keys.length == 0) {
-      let result: Selector = () => constants;
-      result.memoize = () => result;
-      return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
-   }
-
-   function memoize() {
-      let lastResult: Record<string, any> = Object.assign({}, constants);
-
-      let memoizedSelectors: Record<string, Selector> = {};
-
-      keys.forEach((key) => {
-         memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
-         lastResult[key] = undefined;
-      });
-
-      return function (data: any) {
-         let result = lastResult,
-            k,
-            v,
-            i;
-         for (i = 0; i < keys.length; i++) {
-            k = keys[i];
-            v = memoizedSelectors[k](data);
-            if (result === lastResult) {
-               if (v === lastResult[k]) continue;
-               result = Object.assign({}, lastResult);
-            }
-            result[k] = v;
-         }
-         return (lastResult = result);
-      };
-   }
-
-   let result: Selector = function evaluate(data: any) {
-      let result: Record<string, any> = Object.assign({}, constants);
-      for (let i = 0; i < keys.length; i++) {
-         result[keys[i]] = selector[keys[i]](data);
-      }
-      return result;
-   };
-
-   result.memoize = memoize;
-   return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
-}
+import { MemoSelector, Selector } from "./Selector";
+
+export interface StructuredSelectorConfig {
+   [prop: string]: Selector;
+}
+
+// Helper type to infer result type from selector config
+type InferStructuredSelectorResult<T extends StructuredSelectorConfig, C = {}> = {
+   [K in keyof T]: T[K] extends Selector<infer R> ? R : any;
+} & C;
+
+export function createStructuredSelector<S extends StructuredSelectorConfig, C extends Record<string, any> = {}>(
+   selector: S,
+   constants?: C,
+): MemoSelector<InferStructuredSelectorResult<S, C>> {
+   let keys = Object.keys(selector);
+   constants = constants ?? ({} as C);
+   if (keys.length == 0) {
+      let result: Selector = () => constants;
+      result.memoize = () => result;
+      return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
+   }
+
+   function memoize() {
+      let lastResult: Record<string, any> = Object.assign({}, constants);
+
+      let memoizedSelectors: Record<string, Selector> = {};
+
+      keys.forEach((key) => {
+         memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
+         lastResult[key] = undefined;
+      });
+
+      return function (data: any) {
+         let result = lastResult,
+            k,
+            v,
+            i;
+         for (i = 0; i < keys.length; i++) {
+            k = keys[i];
+            v = memoizedSelectors[k](data);
+            if (result === lastResult) {
+               if (v === lastResult[k]) continue;
+               result = Object.assign({}, lastResult);
+            }
+            result[k] = v;
+         }
+         return (lastResult = result);
+      };
+   }
+
+   let result: Selector = function evaluate(data: any) {
+      let result: Record<string, any> = Object.assign({}, constants);
+      for (let i = 0; i < keys.length; i++) {
+         result[keys[i]] = selector[keys[i]](data);
+      }
+      return result;
+   };
+
+   result.memoize = memoize;
+   return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
+}

package/src/data/defaultCompare.ts

@@ -1,15 +1,15 @@
-export function defaultCompare(av: any, bv: any): number {
-   if (av == null) {
-      if (bv == null)
-         return 0;
-      return -1;
-   }
-
-   if (bv == null || av > bv)
-      return 1;
-
-   if (av < bv)
-      return -1;
-
-   return 0;
+export function defaultCompare(av: any, bv: any): number {
+   if (av == null) {
+      if (bv == null)
+         return 0;
+      return -1;
+   }
+
+   if (bv == null || av > bv)
+      return 1;
+
+   if (av < bv)
+      return -1;
+
+   return 0;
 }

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