cx 26.0.14 → 26.1.0

package/src/data/computable.spec.ts

@@ -1,87 +1,87 @@
-import { computable } from "./computable";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-
-describe("computable", function () {
-   it("creates a selector", function () {
-      let state = { person: { name: "Joe" } };
-      let nameLength = computable("person.name", (name: string) => name.length);
-      assert.equal(nameLength(state), 3);
-   });
-
-   it("fires every time if not memoized", function () {
-      let state = { person: { name: "Joe" } };
-      let fired = 0;
-      let nameLength = computable("person.name", (name: string) => {
-         fired++;
-         return name.length;
-      });
-      assert.equal(nameLength(state), 3);
-      assert.equal(nameLength(state), 3);
-      assert.equal(fired, 2);
-   });
-
-   it("fires once if memoized and data has not changed", function () {
-      let state = { person: { name: "Joe" } };
-      let fired = 0;
-      let nameLength = computable("person.name", (name: string) => {
-         fired++;
-         return name.length;
-      }).memoize();
-      assert.equal(nameLength(state), 3);
-      assert.equal(nameLength(state), 3);
-      assert.equal(fired, 1);
-   });
-
-   //weird but that's how triggers work and
-   it("memoize with warmup data will not call compute", function () {
-      let state = { person: { name: "Joe" } };
-      let fired = 0;
-      let nameLength = computable("person.name", (name: string) => {
-         fired++;
-         return name.length;
-      }).memoize(state);
-      assert.equal(nameLength(state), undefined);
-      assert.equal(nameLength(state), undefined);
-      assert.equal(fired, 0);
-   });
-
-   it("works with accessors", function () {
-      var m = createAccessorModelProxy<{ person: { name: string } }>();
-      let state = { person: { name: "Joe" } };
-      let nameLength = computable(m.person.name, (name) => {
-         // name should be inferred as string
-         const typedName: string = name;
-         // @ts-expect-error - name should not be number
-         const wrongType: number = name;
-         return typedName.length;
-      });
-      assert.equal(nameLength(state), 3);
-   });
-
-   it("works with array length accessor", function () {
-      var m = createAccessorModelProxy<{ items: string[] }>();
-      let state = { items: ["a", "b", "c"] };
-      let itemCount = computable(m.items.length, (length) => {
-         // length should be inferred as number
-         const typedLength: number = length;
-         // @ts-expect-error - length should not be string
-         const wrongType: string = length;
-         return typedLength;
-      });
-      assert.equal(itemCount(state), 3);
-   });
-
-   it("resolves AccessorChain<any> and nested properties to any", function () {
-      var m = createAccessorModelProxy<{ data: any }>();
-      let state = { data: { nested: { value: 42 } } };
-      let result = computable(m.data.nested.value, (value) => {
-         // value should be any, so all assignments should work
-         const asString: string = value;
-         const asNumber: number = value;
-         const asBoolean: boolean = value;
-         return value;
-      });
-      assert.equal(result(state), 42);
-   });
-});
+import { computable } from "./computable";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+
+describe("computable", function () {
+   it("creates a selector", function () {
+      let state = { person: { name: "Joe" } };
+      let nameLength = computable("person.name", (name: string) => name.length);
+      assert.equal(nameLength(state), 3);
+   });
+
+   it("fires every time if not memoized", function () {
+      let state = { person: { name: "Joe" } };
+      let fired = 0;
+      let nameLength = computable("person.name", (name: string) => {
+         fired++;
+         return name.length;
+      });
+      assert.equal(nameLength(state), 3);
+      assert.equal(nameLength(state), 3);
+      assert.equal(fired, 2);
+   });
+
+   it("fires once if memoized and data has not changed", function () {
+      let state = { person: { name: "Joe" } };
+      let fired = 0;
+      let nameLength = computable("person.name", (name: string) => {
+         fired++;
+         return name.length;
+      }).memoize();
+      assert.equal(nameLength(state), 3);
+      assert.equal(nameLength(state), 3);
+      assert.equal(fired, 1);
+   });
+
+   //weird but that's how triggers work and
+   it("memoize with warmup data will not call compute", function () {
+      let state = { person: { name: "Joe" } };
+      let fired = 0;
+      let nameLength = computable("person.name", (name: string) => {
+         fired++;
+         return name.length;
+      }).memoize(state);
+      assert.equal(nameLength(state), undefined);
+      assert.equal(nameLength(state), undefined);
+      assert.equal(fired, 0);
+   });
+
+   it("works with accessors", function () {
+      var m = createAccessorModelProxy<{ person: { name: string } }>();
+      let state = { person: { name: "Joe" } };
+      let nameLength = computable(m.person.name, (name) => {
+         // name should be inferred as string
+         const typedName: string = name;
+         // @ts-expect-error - name should not be number
+         const wrongType: number = name;
+         return typedName.length;
+      });
+      assert.equal(nameLength(state), 3);
+   });
+
+   it("works with array length accessor", function () {
+      var m = createAccessorModelProxy<{ items: string[] }>();
+      let state = { items: ["a", "b", "c"] };
+      let itemCount = computable(m.items.length, (length) => {
+         // length should be inferred as number
+         const typedLength: number = length;
+         // @ts-expect-error - length should not be string
+         const wrongType: string = length;
+         return typedLength;
+      });
+      assert.equal(itemCount(state), 3);
+   });
+
+   it("resolves AccessorChain<any> and nested properties to any", function () {
+      var m = createAccessorModelProxy<{ data: any }>();
+      let state = { data: { nested: { value: 42 } } };
+      let result = computable(m.data.nested.value, (value) => {
+         // value should be any, so all assignments should work
+         const asString: string = value;
+         const asNumber: number = value;
+         const asBoolean: boolean = value;
+         return value;
+      });
+      assert.equal(result(state), 42);
+   });
+});

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