cx 26.0.1 → 26.0.2

package/build/data/StringTemplate.js

@@ -0,0 +1,81 @@
+import { expression } from "./Expression";
+import { quoteStr } from "../util/quote";
+function plus(str) {
+    return str.length ? str + " + " : str;
+}
+export function stringTemplate(str) {
+    let tplCache = getTplCache();
+    let cached = tplCache[str];
+    if (cached)
+        return cached;
+    let expr = "";
+    let termStart = -1, quoteStart = 0, term, bracketsOpen = 0, percentSign = false;
+    for (let i = 0; i < str.length; i++) {
+        switch (str[i]) {
+            case "{":
+                if (termStart < 0) {
+                    if (str[i + 1] == "{" && str[i - 1] != "%") {
+                        expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "{");
+                        i++;
+                        quoteStart = i + 1;
+                    }
+                    else {
+                        termStart = i + 1;
+                        percentSign = str[i - 1] == "%";
+                        if (i > quoteStart)
+                            expr = plus(expr) + quoteStr(str.substring(quoteStart, percentSign ? i - 1 : i));
+                        bracketsOpen = 1;
+                        quoteStart = i; // for the case where the brackets are not closed
+                    }
+                }
+                else
+                    bracketsOpen++;
+                break;
+            case "}":
+                if (termStart >= 0) {
+                    if (--bracketsOpen == 0) {
+                        term = str.substring(termStart, i);
+                        if (term.indexOf(":") == -1) {
+                            let nullSepIndex = term.indexOf("|");
+                            if (nullSepIndex == -1)
+                                term += ":s";
+                            else
+                                term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
+                        }
+                        expr = plus(expr) + (percentSign ? "%{" : "{") + term + "}";
+                        termStart = -1;
+                        quoteStart = i + 1;
+                        bracketsOpen = 0;
+                    }
+                }
+                else if (str[i + 1] == "}") {
+                    expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "}");
+                    i++;
+                    quoteStart = i + 1;
+                }
+                break;
+        }
+    }
+    if (quoteStart < str.length || expr.length == 0)
+        expr = plus(expr) + quoteStr(str.substring(quoteStart));
+    return (tplCache[str] = expression(expr));
+}
+export const StringTemplate = {
+    get: function (str) {
+        return stringTemplate(str);
+    },
+    compile: function (str) {
+        return stringTemplate(str).memoize();
+    },
+    format: function (format, ...args) {
+        return stringTemplate(format)(args);
+    },
+};
+let tplCache = {};
+let getTplCache = () => tplCache;
+export function invalidateStringTemplateCache() {
+    tplCache = {};
+}
+export function setGetStringTemplateCacheCallback(callback) {
+    getTplCache = callback;
+}

package/build/data/StringTemplate.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/data/StringTemplate.spec.js

@@ -0,0 +1,112 @@
+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/build/data/StructuredSelector.d.ts

@@ -0,0 +1,12 @@
+import { View } from "./View";
+export declare class StructuredSelector {
+    nameMap: Record<string, string>;
+    config: any;
+    constructor({ props, values }: {
+        props: any;
+        values: any;
+    });
+    init(store: View): void;
+    create(memoize?: boolean): import("./Selector").Selector<any>;
+    createStoreSelector(): (store: View) => any;
+}

package/build/data/StructuredSelector.js

@@ -0,0 +1,131 @@
+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 {
+    nameMap;
+    config;
+    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/build/data/StructuredSelector.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/data/StructuredSelector.spec.js

@@ -0,0 +1,102 @@
+//@ts-nocheck
+import { StructuredSelector } from "./StructuredSelector";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+describe("StructuredSelector", function () {
+    describe("#create()", function () {
+        it("constants", function () {
+            var x = {};
+            var s = new StructuredSelector({
+                props: {
+                    a: undefined,
+                    b: undefined,
+                },
+                values: {
+                    a: 1,
+                    b: 2,
+                },
+            }).create(x);
+            assert.deepEqual(s(x), { a: 1, b: 2 });
+        });
+        it("bindings", function () {
+            var x = { a: 1, b: 2 };
+            var s = new StructuredSelector({
+                props: {
+                    a: undefined,
+                    b: undefined,
+                },
+                values: {
+                    a: { bind: "b" },
+                    b: { bind: "a" },
+                },
+            }).create(x);
+            assert.deepEqual(s(x), { a: 2, b: 1 });
+        });
+        it("templates", function () {
+            var x = { a: 1, b: 2 };
+            var s = new StructuredSelector({
+                props: {
+                    a: undefined,
+                    b: undefined,
+                },
+                values: {
+                    a: { tpl: "b{a}" },
+                    b: { tpl: "a{b}" },
+                },
+            }).create(x);
+            assert.deepEqual(s(x), { a: "b1", b: "a2" });
+        });
+        it("structured", function () {
+            var x = { a: 1, b: 2 };
+            var s = new StructuredSelector({
+                props: {
+                    a: {
+                        structured: true,
+                    },
+                    b: undefined,
+                },
+                values: {
+                    a: {
+                        x: { expr: "{a} == 1" },
+                        y: { expr: "{b} == 1" },
+                    },
+                    b: { tpl: "a{b}" },
+                },
+            }).create(x);
+            assert.deepEqual(s(x), { a: { x: true, y: false }, b: "a2" });
+        });
+    });
+    it("structures do not change if data doesn't change", function () {
+        var x = { a: 1, b: 2 };
+        var s = new StructuredSelector({
+            props: {
+                a: {
+                    structured: true,
+                },
+            },
+            values: {
+                a: {
+                    x: { expr: "{a} == 1" },
+                    y: { expr: "{b} == 1" },
+                },
+                b: { tpl: "a{b}" },
+            },
+        }).create(x);
+        let r1 = s(x);
+        let r2 = s(x);
+        assert.equal(r1, r2);
+    });
+    it("structures do not change if data doesn't change", function () {
+        var x = { a: { b: 2 } };
+        var m = createAccessorModelProxy();
+        var s = new StructuredSelector({
+            props: {
+                b: undefined,
+            },
+            values: {
+                b: m.a.b,
+            },
+        }).create(x);
+        assert.deepEqual(s(x), { b: 2 });
+    });
+});

package/build/data/SubscribableView.d.ts

@@ -0,0 +1,15 @@
+import { View, ViewConfig } from "./View";
+export interface SubscribableViewConfig extends ViewConfig {
+    async?: boolean;
+}
+export declare class SubscribableView<D> extends View<D> {
+    subscribers?: any;
+    changes: string[];
+    async: boolean;
+    scheduled: boolean;
+    constructor(config?: SubscribableViewConfig);
+    subscribe(callback: () => void): any;
+    unsubscribeAll(): void;
+    doNotify(path: string): void;
+    silently(callback: (store?: View) => void): boolean;
+}

package/build/data/SubscribableView.js

@@ -0,0 +1,52 @@
+import { View } from "./View";
+import { SubscriberList } from "../util/SubscriberList";
+export class SubscribableView extends View {
+    subscribers;
+    changes;
+    scheduled;
+    constructor(config) {
+        super(config);
+        this.subscribers = new SubscriberList();
+        this.changes = [];
+    }
+    subscribe(callback) {
+        return this.subscribers.subscribe(callback);
+    }
+    unsubscribeAll() {
+        this.subscribers.clear();
+    }
+    doNotify(path) {
+        if (this.notificationsSuspended)
+            return;
+        if (!this.async) {
+            this.subscribers.notify([path]);
+        }
+        else {
+            this.changes.push(path || "");
+            if (!this.scheduled) {
+                this.scheduled = true;
+                setTimeout(() => {
+                    this.scheduled = false;
+                    let changes = this.changes;
+                    this.changes = [];
+                    this.subscribers.notify(changes);
+                }, 0);
+            }
+        }
+    }
+    silently(callback) {
+        this.notificationsSuspended = (this.notificationsSuspended || 0) + 1;
+        let wasDirty = this.dirty, dirty;
+        this.dirty = false;
+        try {
+            callback(this);
+        }
+        finally {
+            this.notificationsSuspended--;
+            dirty = this.dirty;
+            this.dirty = wasDirty;
+        }
+        return dirty;
+    }
+}
+SubscribableView.prototype.async = false;

package/build/data/View.d.ts

@@ -0,0 +1,125 @@
+import { Binding } from "./Binding";
+import { AccessorChain } from "./createAccessorModelProxy";
+import { Ref } from "./Ref";
+type Path = string | Binding;
+export interface ViewConfig {
+    store?: View;
+    immutable?: boolean;
+    sealed?: boolean;
+}
+export interface ViewMethods<D = Record<string, any>> {
+    getData(): D;
+    init(path: Path, value: unknown): boolean;
+    init<V>(path: AccessorChain<V>, value: V): boolean;
+    init<T extends Record<string, unknown>>(initObject: T): boolean;
+    set(path: Path, value: 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.
+     * @param paths - One or more paths to be deleted.
+     * @return {boolean}
+     */
+    delete(path: Path): boolean;
+    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;
+    toggle(path: AccessorChain<boolean>): boolean;
+    update(updateFn: (currentValue: D, ...args: any[]) => any, ...args: any): boolean;
+    update<A extends any[]>(path: Path, updateFn: (currentValue: any, ...args: A) => any, ...args: A): 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: any[]) => void, ...args: any[]): boolean;
+    mutate<A extends any[]>(path: Path, updateFn: (currentValue: any, ...args: A) => void, ...args: A): 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>;
+}
+export declare class View<D = any> implements ViewMethods<D> {
+    store?: View;
+    meta: any;
+    sealed: boolean;
+    cache: {
+        version: number;
+        data?: any;
+        result?: any;
+        itemIndex?: number;
+        key?: string;
+        parentStoreData?: any;
+    };
+    notificationsSuspended: number;
+    dirty: boolean;
+    constructor(config?: ViewConfig);
+    getData(): D;
+    init(path: Path, value: unknown): boolean;
+    init<V>(path: AccessorChain<V>, value: V): boolean;
+    init<T extends Record<string, unknown>>(initObject: T): boolean;
+    set(path: Path, value: any): boolean;
+    set<T extends Record<string, any>>(changes: T): boolean;
+    set<V>(path: AccessorChain<V>, value: V): boolean;
+    copy(from: Path, to: Path): boolean;
+    copy<V>(from: AccessorChain<V>, to: AccessorChain<V>): boolean;
+    move(from: Path, to: Path): boolean;
+    move<V>(from: AccessorChain<V>, to: AccessorChain<V>): boolean;
+    setItem(path: string, value: any): boolean;
+    delete(path: Path): boolean;
+    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;
+    deleteItem(path: string): boolean;
+    clear(): void;
+    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;
+    toggle(path: Path): boolean;
+    toggle(path: AccessorChain<boolean>): boolean;
+    update(updateFn: (currentValue: D, ...args: any[]) => any, ...args: any): boolean;
+    update<A extends any[]>(path: Path, updateFn: (currentValue: any, ...args: A) => any, ...args: A): boolean;
+    update<V, A extends any[]>(path: AccessorChain<V>, updateFn: (currentValue: V, ...args: A) => V, ...args: A): boolean;
+    mutate(updateFn: (currentValue: D, ...args: any[]) => void, ...args: any[]): boolean;
+    mutate<A extends any[]>(path: Path, updateFn: (currentValue: any, ...args: A) => void, ...args: A): boolean;
+    mutate<V, A extends any[]>(path: AccessorChain<V>, updateFn: (currentValue: V, ...args: A) => void, ...args: A): boolean;
+    batch(callback: (store?: View) => void): boolean;
+    silently(callback: (store?: View) => void): boolean;
+    notify(path?: string): void;
+    doNotify(path?: string): void;
+    subscribe(callback: (changes?: any) => void): () => void;
+    load(data: Record<string, any>): boolean;
+    dispatch(action: any): void;
+    getMeta(): any;
+    setStore(store: View): void;
+    ref<T = any>(path: string | AccessorChain<T>, defaultValue?: T): Ref<T>;
+    getMethods(): ViewMethods<D>;
+}
+export {};