cx 26.0.1 → 26.0.3

package/build/data/ExposedRecordView.js

@@ -0,0 +1,76 @@
+import { View } from "./View";
+import { Binding } from "./Binding";
+export class ExposedRecordView extends View {
+    itemIndex;
+    immutable;
+    collectionBinding;
+    recordName;
+    indexName;
+    constructor(config) {
+        super(config);
+    }
+    getData() {
+        if (this.sealed &&
+            this.meta.version === this.cache.version &&
+            this.cache.itemIndex === this.itemIndex &&
+            this.meta === this.store.meta)
+            return this.cache.result;
+        this.cache.result = this.embed(this.store.getData());
+        this.cache.version = this.meta.version;
+        this.cache.itemIndex = this.itemIndex;
+        this.meta = this.store.meta;
+        return this.cache.result;
+    }
+    embed(data) {
+        const collection = this.collectionBinding.value(data);
+        const record = collection[this.itemIndex];
+        const copy = this.sealed || this.immutable || this.store.sealed ? { ...data } : data;
+        copy[this.recordName] = record;
+        if (this.indexName)
+            copy[this.indexName] = this.itemIndex;
+        return copy;
+    }
+    setIndex(index) {
+        this.itemIndex = index;
+    }
+    setItem(path, value) {
+        if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
+            const storeData = this.store.getData();
+            const collection = this.collectionBinding.value(storeData);
+            const data = this.embed(storeData);
+            const d = Binding.get(path).set(data, value);
+            if (d === data)
+                return false;
+            const record = d[this.recordName];
+            const newCollection = [
+                ...collection.slice(0, this.itemIndex),
+                record,
+                ...collection.slice(this.itemIndex + 1),
+            ];
+            return this.store.setItem(this.collectionBinding.path, newCollection);
+        }
+        return this.store.setItem(path, value);
+    }
+    deleteItem(path) {
+        let storeData, collection, newCollection;
+        if (path == this.recordName) {
+            storeData = this.store.getData();
+            collection = this.collectionBinding.value(storeData);
+            newCollection = [...collection.slice(0, this.itemIndex), ...collection.slice(this.itemIndex + 1)];
+            return this.store.setItem(this.collectionBinding.path, newCollection);
+        }
+        else if (path.indexOf(this.recordName + ".") == 0) {
+            storeData = this.store.getData();
+            collection = this.collectionBinding.value(storeData);
+            const data = this.embed(storeData);
+            const d = Binding.get(path).delete(data);
+            if (d === data)
+                return false;
+            const record = d[this.recordName];
+            newCollection = [...collection.slice(0, this.itemIndex), record, ...collection.slice(this.itemIndex + 1)];
+            return this.store.setItem(this.collectionBinding.path, newCollection);
+        }
+        return this.store.deleteItem(path);
+    }
+}
+ExposedRecordView.prototype.immutable = false;

package/build/data/ExposedValueView.d.ts

@@ -0,0 +1,20 @@
+import { View, ViewConfig } from "./View";
+import { Binding } from "./Binding";
+export interface ExposedValueViewConfig extends ViewConfig {
+    containerBinding: Binding;
+    key?: string | null;
+    recordName?: string;
+}
+export declare class ExposedValueView extends View {
+    key: string;
+    containerBinding: Binding;
+    recordName: string;
+    immutable?: boolean;
+    store: View;
+    constructor(config: ExposedValueViewConfig);
+    getData(): any;
+    setKey(key: string): void;
+    getKey(): string;
+    setItem(path: string, value: any): boolean;
+    deleteItem(path: string): boolean;
+}

package/build/data/ExposedValueView.js

@@ -0,0 +1,68 @@
+import { View } from "./View";
+import { Binding } from "./Binding";
+export class ExposedValueView extends View {
+    constructor(config) {
+        super(config);
+    }
+    getData() {
+        if (this.sealed &&
+            this.meta.version === this.cache.version &&
+            this.cache.key === this.key &&
+            this.meta == this.store.meta)
+            return this.cache.result;
+        let data = this.store.getData();
+        let container = this.containerBinding.value(data) || {};
+        let record = container[this.key];
+        this.cache.version = this.meta.version;
+        this.cache.key = this.key;
+        this.cache.result = this.sealed || this.immutable || this.store.sealed ? { ...data } : data;
+        this.cache.result[this.recordName] = record;
+        this.meta = this.store.meta;
+        return this.cache.result;
+    }
+    setKey(key) {
+        this.key = key;
+    }
+    getKey() {
+        return this.key;
+    }
+    setItem(path, value) {
+        if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
+            var data = this.getData();
+            var d = Binding.get(path).set(data, value);
+            if (d === data)
+                return false;
+            var container = this.containerBinding.value(d);
+            var record = d[this.recordName];
+            var newContainer = Object.assign({}, container);
+            newContainer[this.key] = record;
+            return this.store.setItem(this.containerBinding.path, newContainer);
+        }
+        return this.store.setItem(path, value);
+    }
+    deleteItem(path) {
+        var data, container, newContainer;
+        if (path == this.recordName) {
+            data = this.getData();
+            container = this.containerBinding.value(data);
+            if (!container || !container.hasOwnProperty(path))
+                return false;
+            newContainer = Object.assign({}, container);
+            delete newContainer[this.key];
+            this.store.set(this.containerBinding.path, newContainer);
+        }
+        else if (path.indexOf(this.recordName + ".") == 0) {
+            data = this.getData();
+            var d = Binding.get(path).delete(data);
+            if (d === data)
+                return false;
+            container = this.containerBinding.value(d);
+            var record = d[this.recordName];
+            newContainer = Object.assign({}, container);
+            newContainer[this.key] = record;
+            return this.store.setItem(this.containerBinding.path, newContainer);
+        }
+        return this.store.deleteItem(path);
+    }
+}
+ExposedValueView.prototype.immutable = false;

package/build/data/Expression.d.ts

@@ -0,0 +1,12 @@
+import { MemoSelector, Selector } from "./Selector";
+export declare function expression(str: string | Selector): MemoSelector;
+export type GetFunction = (bindingPath: string) => any;
+export type SelectorFunction = (get: GetFunction) => any;
+export declare const Expression: {
+    get: (str: string | SelectorFunction) => MemoSelector;
+    compile: (str: string | SelectorFunction) => Selector;
+    registerHelper: (name: string, helper: any) => void;
+};
+export declare function plugFatArrowExpansion(impl: (body: string) => string): void;
+export declare function invalidateExpressionCache(): void;
+export declare function setGetExpressionCacheCallback(callback: () => Record<string, MemoSelector>): void;

package/build/data/Expression.js

@@ -0,0 +1,201 @@
+import { computable } from "./computable";
+import { Format } from "../util/Format";
+import { Binding } from "./Binding";
+import { quoteStr } from "../util/quote";
+import { isFunction } from "../util/isFunction";
+import { isValidIdentifierName } from "../util/isValidIdentifierName";
+/*
+   Helper usage example
+
+   Expression.registerHelper('_', _);
+   let e = Expression.compile('_.min({data})');
+ */
+let helpers = {}, helperNames = [], helperValues = [], expFatArrows = null;
+function getExpr(expr) {
+    if (expr.memoize)
+        return expr;
+    function memoize() {
+        let lastValue, lastRunBindings = {}, lastRunResults = {}, getters = {}, currentData, len = -1;
+        let get = function (bindingWithFormat) {
+            let getter = getters[bindingWithFormat];
+            if (!getter) {
+                let binding = bindingWithFormat, format;
+                let colonIndex = bindingWithFormat.indexOf(":");
+                if (colonIndex != -1) {
+                    format = Format.parse(bindingWithFormat.substring(colonIndex + 1));
+                    binding = bindingWithFormat.substring(0, colonIndex);
+                }
+                else {
+                    let nullSeparatorIndex = bindingWithFormat.indexOf(":");
+                    if (nullSeparatorIndex != -1) {
+                        format = Format.parse(bindingWithFormat.substring(nullSeparatorIndex));
+                        binding = bindingWithFormat.substring(0, nullSeparatorIndex - 1);
+                    }
+                }
+                let b = Binding.get(binding);
+                getter = (data) => {
+                    let value = b.value(data);
+                    lastRunBindings[len] = b.value;
+                    lastRunResults[len] = value;
+                    len++;
+                    return value;
+                };
+                if (format) {
+                    let valueGetter = getter;
+                    getter = (data) => format(valueGetter(data));
+                }
+                getters[bindingWithFormat] = getter;
+            }
+            return getter(currentData);
+        };
+        return function (data) {
+            let i = 0;
+            for (; i < len; i++)
+                if (lastRunBindings[i](data) !== lastRunResults[i])
+                    break;
+            if (i !== len) {
+                len = 0;
+                currentData = data;
+                lastValue = expr(get);
+            }
+            return lastValue;
+        };
+    }
+    let result = memoize();
+    result.memoize = memoize;
+    return result;
+}
+export function expression(str) {
+    if (isFunction(str))
+        return getExpr(str);
+    let cache = getExpressionCache();
+    let r = cache[str];
+    if (r)
+        return r;
+    let quote = false;
+    let termStart = -1, curlyBrackets = 0, percentExpression;
+    let fb = ["return ("];
+    let args = {};
+    let formats = [];
+    let subExprCount = 0;
+    let invalidNameCount = 0;
+    for (let i = 0; i < str.length; i++) {
+        let c = str[i];
+        switch (c) {
+            case "{":
+                if (curlyBrackets > 0 && !quote)
+                    curlyBrackets++;
+                else if (!quote && termStart < 0 && (str[i + 1] != "{" || str[i - 1] == "%")) {
+                    termStart = i + 1;
+                    curlyBrackets = 1;
+                    percentExpression = str[i - 1] == "%";
+                    if (percentExpression)
+                        fb.pop(); //%
+                }
+                else if (termStart < 0 && (quote || str[i - 1] != "{"))
+                    fb.push(c);
+                break;
+            case "}":
+                if (termStart >= 0) {
+                    if (quote)
+                        continue;
+                    if (--curlyBrackets == 0) {
+                        let term = str.substring(termStart, i);
+                        let formatStart = 0;
+                        if (term[0] == "[")
+                            formatStart = term.indexOf("]");
+                        let colon = term.indexOf(":", formatStart > 0 ? formatStart : 0);
+                        let binding = colon == -1 ? term : term.substring(0, colon);
+                        let format = colon == -1 ? null : term.substring(colon + 1);
+                        if (colon == -1) {
+                            let nullSepIndex = binding.indexOf("|", formatStart);
+                            if (nullSepIndex != -1) {
+                                format = binding.substring(nullSepIndex);
+                                binding = binding.substring(0, nullSepIndex);
+                            }
+                        }
+                        let argName = binding.replace(/\./g, "_");
+                        if (!isValidIdentifierName(argName))
+                            argName = "inv" + ++invalidNameCount;
+                        if (percentExpression || (binding[0] == "[" && binding[binding.length - 1] == "]")) {
+                            argName = `expr${++subExprCount}`;
+                            args[argName] = expression(percentExpression ? binding : binding.substring(1, binding.length - 1));
+                        }
+                        else
+                            args[argName] = binding;
+                        if (format) {
+                            let formatter = "fmt" + formats.length;
+                            fb.push(formatter, "(", argName, ", ", quoteStr(format), ")");
+                            formats.push(Format.parse(format));
+                        }
+                        else
+                            fb.push(argName);
+                        termStart = -1;
+                    }
+                }
+                else
+                    fb.push(c);
+                break;
+            case '"':
+            case "'":
+                if (!quote)
+                    quote = c;
+                else if (quote == c) {
+                    let at = i - 1;
+                    let slashCount = 0;
+                    while (at >= 0 && str[at] === "\\") {
+                        slashCount++;
+                        at--;
+                    }
+                    if (slashCount % 2 == 0)
+                        quote = false;
+                }
+                if (curlyBrackets == 0)
+                    fb.push(c);
+                break;
+            default:
+                if (termStart < 0)
+                    fb.push(c);
+                break;
+        }
+    }
+    fb.push(")");
+    let body = fb.join("");
+    if (expFatArrows)
+        body = expFatArrows(body);
+    //console.log(body);
+    let keys = Object.keys(args);
+    try {
+        let compute = new Function("fmt", ...formats.map((f, i) => "fmt" + i), ...helperNames, ...keys, body).bind(Format, Format.value, ...formats, ...helperValues);
+        let selector = computable(...keys.map((k) => args[k]), compute);
+        cache[str] = selector;
+        return selector;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse expression: '${str}'. ${err}`);
+    }
+}
+export const Expression = {
+    get: function (str) {
+        return expression(str);
+    },
+    compile: function (str) {
+        return this.get(str).memoize();
+    },
+    registerHelper: function (name, helper) {
+        helpers[name] = helper;
+        helperNames = Object.keys(helpers);
+        helperValues = helperNames.map((n) => helpers[n]);
+    },
+};
+export function plugFatArrowExpansion(impl) {
+    expFatArrows = impl;
+}
+export function invalidateExpressionCache() {
+    expCache = {};
+}
+let expCache = {};
+let getExpressionCache = () => expCache;
+export function setGetExpressionCacheCallback(callback) {
+    getExpressionCache = callback;
+}

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

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

package/build/data/Expression.spec.js

@@ -0,0 +1,196 @@
+import { Expression } from "./Expression";
+import assert from "assert";
+import { StringTemplate } from "./StringTemplate";
+describe("Expression", function () {
+    describe("#compile()", function () {
+        it("returns a selector", function () {
+            let e = Expression.compile("{person.name}");
+            let state = {
+                person: {
+                    name: "Jim",
+                },
+            };
+            assert.equal(e(state), "Jim");
+        });
+        it("ignores bindings in strings", function () {
+            let e = Expression.compile('"{person.name}"');
+            let state = {
+                person: {
+                    name: "Jim",
+                },
+            };
+            assert.equal(e(state), "{person.name}");
+        });
+        it("allows mixed curly braces in strings", () => {
+            let e = Expression.compile('"Hello {" + "person.name}"');
+            assert.equal(e({}), "Hello {person.name}");
+        });
+        it("properly encodes quotes #1", function () {
+            let e = Expression.compile('"\'"');
+            let state = {};
+            assert.equal(e(state), "'");
+        });
+        it("properly encodes quotes #2", function () {
+            let e = Expression.compile('"\\""');
+            let state = {};
+            assert.equal(e(state), '"');
+        });
+        it("properly encodes quotes #3", function () {
+            let e = Expression.compile('"\\\\\\""');
+            let state = {};
+            assert.equal(e(state), '\\"');
+        });
+        it("properly encodes quotes #4", function () {
+            let e = Expression.compile('"\\\\"');
+            let state = {};
+            assert.equal(e(state), "\\");
+        });
+    });
+    describe("allow subexpressions", function () {
+        it("in square brackets", function () {
+            let e = Expression.compile("{[{person.name}]}");
+            let state = {
+                person: {
+                    name: "Jim",
+                },
+            };
+            assert.equal(e(state), "Jim");
+        });
+        it("in square brackets", function () {
+            let e = Expression.compile("{[{person.alias} || {person.name}]}");
+            let state = {
+                person: {
+                    name: "Jim",
+                    alias: "J",
+                },
+            };
+            assert.equal(e(state), "J");
+        });
+        it("prefixed with % sign", function () {
+            let e = Expression.compile("%{1+1}");
+            assert.equal(e({}), "2");
+        });
+        it("can be formatted", function () {
+            let e = Expression.compile("{[1+1]:f;2}");
+            assert.equal(e({}), "2.00");
+        });
+        it("n level deep", function () {
+            let e = Expression.compile("{[{[{[1+1]}]}]:f;2}");
+            assert.equal(e({}), "2.00");
+        });
+        it("with complex math inside", function () {
+            let e = Expression.compile("%{{data}.reduce((a,b)=>a+b, 0):f;2}");
+            let state = {
+                data: [1, 2, 3],
+            };
+            assert.equal(e(state), "6.00");
+        });
+        it("with a conditional operator inside", function () {
+            let e = Expression.compile('{[true ? "T" : "F"]}');
+            assert.equal(e({}), "T");
+        });
+        it("with string interpolation inside", function () {
+            let e = Expression.compile("{[`${{test}}`]}");
+            assert.equal(e({ test: "T" }), "T");
+        });
+    });
+    describe("are working", function () {
+        it("function expressions with get", function () {
+            let e = Expression.get((get) => get("a") + get("b"));
+            assert.equal(e({ a: 1, b: 2 }), 3);
+        });
+        it("are properly memoized", function () {
+            let inv = 0;
+            let e = Expression.get((get) => {
+                inv++;
+                return get("a") + get("b");
+            }).memoize();
+            assert.equal(e({ a: 1, b: 1 }), 2);
+            assert.equal(inv, 1);
+            assert.equal(e({ a: 1, b: 1 }), 2);
+            assert.equal(inv, 1);
+            assert.equal(e({ a: 1, b: 2 }), 3);
+            assert.equal(inv, 2);
+            assert.equal(e({ a: 1, b: 2 }), 3);
+            assert.equal(inv, 2);
+            assert.equal(e({ a: 2, b: 2 }), 4);
+            assert.equal(inv, 3);
+        });
+        it("formatting can be used inside bindings", function () {
+            let e = Expression.get((get) => get("name:prefix;Hello "));
+            assert(e({ name: "CxJS" }), "Hello CxJS");
+        });
+        it("allows using the fmt function inside", function () {
+            let e = Expression.compile('{[fmt({text}, "prefix;Hello ")]}');
+            assert.equal(e({ text: "CxJS" }), "Hello CxJS");
+        });
+        it("allows using dashes inside names", function () {
+            let e = Expression.compile("{framework-name}");
+            assert.equal(e({ "framework-name": "CxJS" }), "CxJS");
+        });
+        it("allows using spaces and other characters inside names", function () {
+            let e = Expression.compile("{1nv@lid js ident1fier}");
+            assert.equal(e({ "1nv@lid js ident1fier": "CxJS" }), "CxJS");
+        });
+        it("allows strings in subexpressions", () => {
+            let e = Expression.compile("{['1']}");
+            assert.equal(e({}), "1");
+            let e2 = Expression.compile('%{"1"}');
+            assert.equal(e({}), "1");
+        });
+        it("allows string templates in nested expressions", () => {
+            Expression.registerHelper("tpl", StringTemplate.format);
+            let e = Expression.compile("tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})");
+            assert.equal(e({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
+            let e2 = Expression.compile("{[tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})]}");
+            assert.equal(e2({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
+            // we're going to need a better parser for this
+            // let e3 = Expression.compile("%{tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})}");
+            // assert.equal(e3({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
+        });
+        it("string templates can be in the data", () => {
+            Expression.registerHelper("tpl", StringTemplate.format);
+            let e = Expression.compile("tpl({template}, {value}, {percentage})");
+            assert.equal(e({ value: 1, percentage: 0.02, template: "{0:n;2} {1:p;2:wrap;(;)}" }), "1.00 (2.00%)");
+        });
+        // it('are properly memoized with proxies', function () {
+        //    let inv = 0;
+        //    let e = Expression.get(d => { inv++; return d.a + d.b}).memoize();
+        //
+        //    assert.equal(e({ a: 1, b: 1 }), 2);
+        //    assert.equal(inv, 1);
+        //
+        //    assert.equal(e({ a: 1, b: 1 }), 2);
+        //    assert.equal(inv, 1);
+        //
+        //    assert.equal(e({ a: 1, b: 2 }), 3);
+        //    assert.equal(inv, 2);
+        //
+        //    assert.equal(e({ a: 1, b: 2 }), 3);
+        //    assert.equal(inv, 2);
+        //
+        //    assert.equal(e({ a: 2, b: 2 }), 4);
+        //    assert.equal(inv, 3);
+        // });
+        //
+        // it('are properly memoized with proxies and deep data', function () {
+        //    let inv = 0;
+        //    let e = Expression.get(d => { inv++; return d.v.a + d.v.b}).memoize();
+        //
+        //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
+        //    assert.equal(inv, 1);
+        //
+        //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
+        //    assert.equal(inv, 1);
+        //
+        //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
+        //    assert.equal(inv, 2);
+        //
+        //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
+        //    assert.equal(inv, 2);
+        //
+        //    assert.equal(e({ v: { a: 2, b: 2 }}), 4);
+        //    assert.equal(inv, 3);
+        // });
+    });
+});

package/build/data/Grouper.d.ts

@@ -0,0 +1,29 @@
+export interface GroupResult {
+    key: any;
+    name?: any;
+    records: any[];
+    indexes: number[];
+    aggregates?: Record<string, any>;
+}
+export declare class Grouper {
+    keys: any[];
+    nameGetter?: any;
+    dataGetter: any;
+    aggregates?: any;
+    groups: any;
+    constructor(key: any, aggregates?: any, dataGetter?: any, nameGetter?: any);
+    reset(): void;
+    initGroup(leaf: boolean): {
+        records?: undefined;
+        indexes?: undefined;
+        aggregates?: undefined;
+    } | {
+        records: never[];
+        indexes: never[];
+        aggregates: any;
+    };
+    process(record: any, index: number): void;
+    processAll(records: any[], indexes?: number[]): void;
+    report(g: any, path: any[], level: number, results: GroupResult[]): void;
+    getResults(): GroupResult[];
+}