cx 25.2.1 → 25.4.0

package/src/data/StringTemplate.spec.js

@@ -1,132 +1,132 @@
-import { StringTemplate } from "./StringTemplate";
-import assert from "assert";
-
-describe("StringTemplate", function () {
-   describe("#compile()", function () {
-      it("returns a selector", function () {
-         var e = StringTemplate.compile("Hello {person.name}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Hello Jim");
-      });
-
-      it("allows empty strings", function () {
-         let e = StringTemplate.compile("");
-         assert.equal(e(), "");
-      });
-
-      it("properly encodes ' and \"", function () {
-         var e = StringTemplate.compile('It\'s "working"!');
-         assert.equal(e({}), 'It\'s "working"!');
-      });
-
-      it("allows \\ before a binding", function () {
-         var e = StringTemplate.compile("t\\{person.name}");
-         assert.equal(e({ person: { name: "Ogi" } }), "t\\Ogi");
-      });
-
-      it("supports multi-line strings", function () {
-         var e = StringTemplate.compile("a\nb");
-         assert.equal(e(), "a\nb");
-
-         var e = StringTemplate.compile("a\r\nb");
-         assert.equal(e(), "a\r\nb");
-      });
-   });
-
-   describe("double brackets are used to escape brackets", function () {
-      it("double brackets are preserved", function () {
-         var e = StringTemplate.compile("Hello {{person.name}}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Hello {person.name}");
-      });
-
-      it("triple brackets are converted to single brackets and a binding", function () {
-         var e = StringTemplate.compile("Hello {{{person.name}}}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Hello {Jim}");
-      });
-
-      it("open brackets are ignored", function () {
-         var e = StringTemplate.compile("B { A");
-         assert.equal(e({}), "B { A");
-      });
-   });
-
-   describe("supports formatting", function () {
-      it("with colon", function () {
-         var e = StringTemplate.compile("{str:suffix;kg}");
-         assert.equal(e({ str: "5" }), "5kg");
-      });
-
-      it("with multiple formats", function () {
-         var e = StringTemplate.compile("{str:suffix;kg:wrap;(;)}");
-         assert.equal(e({ str: "5" }), "(5kg)");
-      });
-
-      it("with null values", function () {
-         var e = StringTemplate.compile("{str:suffix;kg:|N/A}");
-         assert.equal(e({ str: null }), "N/A");
-      });
-
-      it("of null values", function () {
-         var e = StringTemplate.compile("{str|N/A}");
-         assert.equal(e({ str: null }), "N/A");
-      });
-   });
-
-   describe("properly handles backslashes", function () {
-      it("in a string", function () {
-         var e = StringTemplate.compile("a\\b");
-         assert.equal(e(), "a\\b");
-      });
-
-      it("before a special character", function () {
-         var e = StringTemplate.compile("\\t");
-         assert.equal(e(), "\\t");
-      });
-   });
-
-   describe("supports expressions", function () {
-      it("using []", function () {
-         var e = StringTemplate.compile("1 + 2 = {[1+2]}");
-         assert.equal(e(), "1 + 2 = 3");
-      });
-
-      it("using %", function () {
-         var e = StringTemplate.compile("1 + 2 = %{1+2}");
-         assert.equal(e(), "1 + 2 = 3");
-      });
-
-      it("with subexpressions", function () {
-         var e = StringTemplate.compile("1 + 2 = {[%{1+2}]}");
-         assert.equal(e(), "1 + 2 = 3");
-      });
-
-      it("with a conditional operator", function () {
-         var e = StringTemplate.compile("1 + 2 = {[true ? 3 : 2]:s}");
-         assert.equal(e(), "1 + 2 = 3");
-      });
-
-      it("with sub-expression formatting", function () {
-         var e = StringTemplate.compile("{[!!{person.age} ? {person.age:suffix; years old} : 'Age unknown']}");
-         var state = {
-            person: {
-               age: 32,
-            },
-         };
-         assert.equal(e(state), "32 years old");
-      });
-   });
-});
+import { StringTemplate } from "./StringTemplate";
+import assert from "assert";
+
+describe("StringTemplate", function () {
+   describe("#compile()", function () {
+      it("returns a selector", function () {
+         var e = StringTemplate.compile("Hello {person.name}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Hello Jim");
+      });
+
+      it("allows empty strings", function () {
+         let e = StringTemplate.compile("");
+         assert.equal(e(), "");
+      });
+
+      it("properly encodes ' and \"", function () {
+         var e = StringTemplate.compile('It\'s "working"!');
+         assert.equal(e({}), 'It\'s "working"!');
+      });
+
+      it("allows \\ before a binding", function () {
+         var e = StringTemplate.compile("t\\{person.name}");
+         assert.equal(e({ person: { name: "Ogi" } }), "t\\Ogi");
+      });
+
+      it("supports multi-line strings", function () {
+         var e = StringTemplate.compile("a\nb");
+         assert.equal(e(), "a\nb");
+
+         var e = StringTemplate.compile("a\r\nb");
+         assert.equal(e(), "a\r\nb");
+      });
+   });
+
+   describe("double brackets are used to escape brackets", function () {
+      it("double brackets are preserved", function () {
+         var e = StringTemplate.compile("Hello {{person.name}}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Hello {person.name}");
+      });
+
+      it("triple brackets are converted to single brackets and a binding", function () {
+         var e = StringTemplate.compile("Hello {{{person.name}}}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Hello {Jim}");
+      });
+
+      it("open brackets are ignored", function () {
+         var e = StringTemplate.compile("B { A");
+         assert.equal(e({}), "B { A");
+      });
+   });
+
+   describe("supports formatting", function () {
+      it("with colon", function () {
+         var e = StringTemplate.compile("{str:suffix;kg}");
+         assert.equal(e({ str: "5" }), "5kg");
+      });
+
+      it("with multiple formats", function () {
+         var e = StringTemplate.compile("{str:suffix;kg:wrap;(;)}");
+         assert.equal(e({ str: "5" }), "(5kg)");
+      });
+
+      it("with null values", function () {
+         var e = StringTemplate.compile("{str:suffix;kg:|N/A}");
+         assert.equal(e({ str: null }), "N/A");
+      });
+
+      it("of null values", function () {
+         var e = StringTemplate.compile("{str|N/A}");
+         assert.equal(e({ str: null }), "N/A");
+      });
+   });
+
+   describe("properly handles backslashes", function () {
+      it("in a string", function () {
+         var e = StringTemplate.compile("a\\b");
+         assert.equal(e(), "a\\b");
+      });
+
+      it("before a special character", function () {
+         var e = StringTemplate.compile("\\t");
+         assert.equal(e(), "\\t");
+      });
+   });
+
+   describe("supports expressions", function () {
+      it("using []", function () {
+         var e = StringTemplate.compile("1 + 2 = {[1+2]}");
+         assert.equal(e(), "1 + 2 = 3");
+      });
+
+      it("using %", function () {
+         var e = StringTemplate.compile("1 + 2 = %{1+2}");
+         assert.equal(e(), "1 + 2 = 3");
+      });
+
+      it("with subexpressions", function () {
+         var e = StringTemplate.compile("1 + 2 = {[%{1+2}]}");
+         assert.equal(e(), "1 + 2 = 3");
+      });
+
+      it("with a conditional operator", function () {
+         var e = StringTemplate.compile("1 + 2 = {[true ? 3 : 2]:s}");
+         assert.equal(e(), "1 + 2 = 3");
+      });
+
+      it("with sub-expression formatting", function () {
+         var e = StringTemplate.compile("{[!!{person.age} ? {person.age:suffix; years old} : 'Age unknown']}");
+         var state = {
+            person: {
+               age: 32,
+            },
+         };
+         assert.equal(e(state), "32 years old");
+      });
+   });
+});

package/src/data/StructuredSelector.js

@@ -1,132 +1,132 @@
-import { Binding } from "./Binding";
-import { Expression } from "./Expression";
-import { StringTemplate } from "./StringTemplate";
-import { createStructuredSelector } from "../data/createStructuredSelector";
-import { getSelector } from "../data/getSelector";
-import { isFunction } from "../util/isFunction";
-import { isUndefined } from "../util/isUndefined";
-import { isDefined } from "../util/isDefined";
-import { isArray } from "../util/isArray";
-import { isAccessorChain } from "./createAccessorModelProxy";
-import { isString } from "../util/isString";
-
-function defaultValue(pv) {
-   if (typeof pv == "object" && pv && pv.structured) return pv.defaultValue;
-
-   return pv;
-}
-
-function getSelectorConfig(props, values, nameMap) {
-   let functions = {},
-      structures = {},
-      defaultValues = {},
-      constants,
-      p,
-      v,
-      pv,
-      constant = true;
-
-   for (p in props) {
-      v = values[p];
-      pv = props[p];
-
-      if (isUndefined(v) && pv && (pv.bind || pv.tpl || pv.expr)) v = pv;
-
-      if (v === null) {
-         if (!constants) constants = {};
-         constants[p] = null;
-      } else if (typeof v == "object") {
-         if (v.bind) {
-            if (isUndefined(v.defaultValue) && v != pv) v.defaultValue = defaultValue(pv);
-            if (isDefined(v.defaultValue)) defaultValues[v.bind] = v.defaultValue;
-            nameMap[p] = v.bind;
-            functions[p] = Binding.get(v.bind).value;
-            constant = false;
-         } else if (v.expr) {
-            functions[p] = Expression.get(v.expr);
-            constant = false;
-         } else if (v.get) {
-            functions[p] = v.get;
-            constant = false;
-         } else if (isString(v.tpl)) {
-            functions[p] = StringTemplate.get(v.tpl);
-            constant = false;
-         } else if (pv && typeof pv == "object" && pv.structured) {
-            if (isArray(v)) functions[p] = getSelector(v);
-            else {
-               let s = getSelectorConfig(v, v, {});
-               structures[p] = s;
-               Object.assign(defaultValues, s.defaultValues);
-            }
-            constant = false;
-         } else {
-            if (!constants) constants = {};
-            constants[p] = v;
-         }
-      } else if (isFunction(v)) {
-         if (isAccessorChain(v)) {
-            let path = v.toString();
-            nameMap[p] = path;
-            functions[p] = Binding.get(path).value;
-         } else functions[p] = v;
-         constant = false;
-      } else {
-         if (isUndefined(v)) {
-            if (isUndefined(pv)) continue;
-            v = defaultValue(pv);
-         }
-
-         if (isUndefined(v)) continue;
-
-         if (!constants) constants = {};
-
-         constants[p] = v;
-      }
-   }
-
-   return {
-      functions,
-      structures,
-      defaultValues,
-      constants,
-      constant,
-   };
-}
-
-function createSelector({ functions, structures, constants, defaultValues }) {
-   let selector = {};
-
-   for (let n in functions) {
-      selector[n] = functions[n];
-   }
-
-   for (let n in structures) selector[n] = createSelector(structures[n]);
-
-   return createStructuredSelector(selector, constants);
-}
-
-export class StructuredSelector {
-   constructor({ props, values }) {
-      this.nameMap = {};
-      this.config = getSelectorConfig(props, values, this.nameMap);
-   }
-
-   init(store) {
-      store.init(this.config.defaultValues);
-   }
-
-   create(memoize = true) {
-      let selector = createSelector(this.config);
-      if (memoize && selector.memoize) return selector.memoize();
-      return selector;
-   }
-
-   createStoreSelector() {
-      if (this.config.constant) {
-         let result = { ...this.config.constants };
-         return () => result;
-      }
-      let selector = this.create();
-      return (store) => selector(store.getData());
-   }
-}
+import { Binding } from "./Binding";
+import { Expression } from "./Expression";
+import { StringTemplate } from "./StringTemplate";
+import { createStructuredSelector } from "../data/createStructuredSelector";
+import { getSelector } from "../data/getSelector";
+import { isFunction } from "../util/isFunction";
+import { isUndefined } from "../util/isUndefined";
+import { isDefined } from "../util/isDefined";
+import { isArray } from "../util/isArray";
+import { isAccessorChain } from "./createAccessorModelProxy";
+import { isString } from "../util/isString";
+
+function defaultValue(pv) {
+   if (typeof pv == "object" && pv && pv.structured) return pv.defaultValue;
+
+   return pv;
+}
+
+function getSelectorConfig(props, values, nameMap) {
+   let functions = {},
+      structures = {},
+      defaultValues = {},
+      constants,
+      p,
+      v,
+      pv,
+      constant = true;
+
+   for (p in props) {
+      v = values[p];
+      pv = props[p];
+
+      if (isUndefined(v) && pv && (pv.bind || pv.tpl || pv.expr)) v = pv;
+
+      if (v === null) {
+         if (!constants) constants = {};
+         constants[p] = null;
+      } else if (typeof v == "object") {
+         if (v.bind) {
+            if (isUndefined(v.defaultValue) && v != pv) v.defaultValue = defaultValue(pv);
+            if (isDefined(v.defaultValue)) defaultValues[v.bind] = v.defaultValue;
+            nameMap[p] = v.bind;
+            functions[p] = Binding.get(v.bind).value;
+            constant = false;
+         } else if (v.expr) {
+            functions[p] = Expression.get(v.expr);
+            constant = false;
+         } else if (v.get) {
+            functions[p] = v.get;
+            constant = false;
+         } else if (isString(v.tpl)) {
+            functions[p] = StringTemplate.get(v.tpl);
+            constant = false;
+         } else if (pv && typeof pv == "object" && pv.structured) {
+            if (isArray(v)) functions[p] = getSelector(v);
+            else {
+               let s = getSelectorConfig(v, v, {});
+               structures[p] = s;
+               Object.assign(defaultValues, s.defaultValues);
+            }
+            constant = false;
+         } else {
+            if (!constants) constants = {};
+            constants[p] = v;
+         }
+      } else if (isFunction(v)) {
+         if (isAccessorChain(v)) {
+            let path = v.toString();
+            nameMap[p] = path;
+            functions[p] = Binding.get(path).value;
+         } else functions[p] = v;
+         constant = false;
+      } else {
+         if (isUndefined(v)) {
+            if (isUndefined(pv)) continue;
+            v = defaultValue(pv);
+         }
+
+         if (isUndefined(v)) continue;
+
+         if (!constants) constants = {};
+
+         constants[p] = v;
+      }
+   }
+
+   return {
+      functions,
+      structures,
+      defaultValues,
+      constants,
+      constant,
+   };
+}
+
+function createSelector({ functions, structures, constants, defaultValues }) {
+   let selector = {};
+
+   for (let n in functions) {
+      selector[n] = functions[n];
+   }
+
+   for (let n in structures) selector[n] = createSelector(structures[n]);
+
+   return createStructuredSelector(selector, constants);
+}
+
+export class StructuredSelector {
+   constructor({ props, values }) {
+      this.nameMap = {};
+      this.config = getSelectorConfig(props, values, this.nameMap);
+   }
+
+   init(store) {
+      store.init(this.config.defaultValues);
+   }
+
+   create(memoize = true) {
+      let selector = createSelector(this.config);
+      if (memoize && selector.memoize) return selector.memoize();
+      return selector;
+   }
+
+   createStoreSelector() {
+      if (this.config.constant) {
+         let result = { ...this.config.constants };
+         return () => result;
+      }
+      let selector = this.create();
+      return (store) => selector(store.getData());
+   }
+}

package/src/data/View.d.ts

@@ -1,4 +1,4 @@
-import { Record, AccessorChain } from "../core";
+import { AccessorChain } from "../core";
 import { Binding } from "./Binding";
 import { Ref } from "./Ref";
 
@@ -14,20 +14,22 @@ export interface ViewConfig {
    sealed?: boolean;
 }
 
-export interface ViewMethods<D = Record> {
+export interface ViewMethods<D = Record<string, any>> {
    getData(): D;
 
    init(path: Path, value: any): boolean;
-   init<V>(path: AccessorChain<V>, value: V | any): boolean;
+   init<V>(path: AccessorChain<V>, value: V): boolean;
 
    set(path: Path, value: any): boolean;
-   set(changes: Record): boolean;
-   set<V>(path: AccessorChain<V>, value: V | any): boolean;
+   set<T extends Record<string, any>>(changes: T): boolean;
+   set<V>(path: AccessorChain<V>, value: V): boolean;
 
    get(path: Path): any;
    get(paths: Path[]): any[];
    get(...paths: Path[]): any[];
    get<V>(path: AccessorChain<V>): V;
+   get<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
+   get<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
 
    /**
     * Removes data from the Store.
@@ -38,19 +40,29 @@ export interface ViewMethods<D = Record> {
    delete(paths: Path[]): boolean;
    delete(...paths: Path[]): boolean;
    delete<V>(path: AccessorChain<V>): boolean;
+   delete<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
+   delete<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
 
    toggle(path: Path): boolean;
 
    update(updateFn: (currentValue: D, ...args) => D, ...args): boolean;
    update(path: Path, updateFn: (currentValue: any, ...args) => any, ...args): boolean;
-   update<V>(path: AccessorChain<V>, updateFn: (currentValue: V, ...args) => V, ...args): boolean;
+   update<V, A extends any[]>(
+      path: AccessorChain<V>,
+      updateFn: (currentValue: V, ...args: A) => V,
+      ...args: A
+   ): boolean;
 
    /**
     *  Mutates the content of the store using Immer
     */
    mutate(updateFn: (currentValue: D, ...args) => D, ...args): boolean;
    mutate(path: Path, updateFn: (currentValue: any, ...args) => any, ...args): boolean;
-   mutate<V>(path: AccessorChain<V>, updateFn: (currentValue: V, ...args) => V, ...args): boolean;
+   mutate<V, A extends any[]>(
+      path: AccessorChain<V>,
+      updateFn: (currentValue: V, ...args: A) => void,
+      ...args: A
+   ): boolean;
 
    ref<T = any>(path: string | AccessorChain<T>, defaultValue?: T): Ref<T>;
 }
@@ -64,8 +76,8 @@ export class View<D = any> implements ViewMethods<D> {
    init<V>(path: AccessorChain<V>, value: V): boolean;
 
    set(path: Path, value: any): boolean;
-   set(changes: Record): boolean;
-   set<V>(path: AccessorChain<V>, value: V | any): boolean;
+   set<T extends Record<string, any>>(changes: T): boolean;
+   set<V>(path: AccessorChain<V>, value: V): boolean;
 
    /**
     * Copies the value stored under the `from` path and saves it under the `to` path.
@@ -87,6 +99,8 @@ export class View<D = any> implements ViewMethods<D> {
    delete(paths: Path[]): boolean;
    delete(...paths: Path[]): boolean;
    delete<V>(path: AccessorChain<V>): boolean;
+   delete<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
+   delete<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
 
    clear(): void;
 
@@ -94,17 +108,27 @@ export class View<D = any> implements ViewMethods<D> {
    get(paths: Path[]): any;
    get(...paths: Path[]): any;
    get<V>(path: AccessorChain<V>): V;
+   get<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
+   get<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
 
    toggle(path: Path): boolean;
    toggle(path: AccessorChain<boolean>): boolean;
 
    update(updateFn: (currentValue: D, ...args) => any, ...args): boolean;
    update(path: Path, updateFn: (currentValue: any, ...args) => any, ...args): boolean;
-   update<V>(path: AccessorChain<V>, updateFn: (currentValue: V, ...args) => V, ...args): boolean;
+   update<V, A extends any[]>(
+      path: AccessorChain<V>,
+      updateFn: (currentValue: V, ...args: A) => V,
+      ...args: A
+   ): boolean;
 
    mutate(updateFn: (currentValue: D, ...args) => void, ...args): boolean;
    mutate(path: Path, updateFn: (currentValue: any, ...args) => void, ...args): boolean;
-   mutate<V>(path: AccessorChain<V>, updateFn: (currentValue: V, ...args) => void, ...args): boolean;
+   mutate<V, A extends any[]>(
+      path: AccessorChain<V>,
+      updateFn: (currentValue: V, ...args: A) => void,
+      ...args: A
+   ): boolean;
 
    /**
     * `batch` method can be used to perform multiple Store operations silently
@@ -121,7 +145,7 @@ export class View<D = any> implements ViewMethods<D> {
 
    subscribe(callback: (changes?) => void): () => void;
 
-   load(data: Record): boolean;
+   load(data: Record<string, any>): boolean;
 
    dispatch(action): void;
 

package/src/data/getAccessor.spec.js

@@ -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();
-      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();
+      let accessor = getAccessor(m.a.b);
+      assert(typeof accessor.set == "function");
+   });
+});