cx 26.0.1 → 26.0.3

package/build/data/AggregateFunction.js

@@ -0,0 +1,155 @@
+export class AggregateFunction {
+    static sum() {
+        return new Sum();
+    }
+    static avg() {
+        return new Avg();
+    }
+    static count() {
+        return new Count();
+    }
+    static distinct() {
+        return new Distinct();
+    }
+    static min() {
+        return new Min();
+    }
+    static max() {
+        return new Max();
+    }
+    static last() {
+        return new LastValue();
+    }
+}
+class Sum {
+    result = 0;
+    empty = true;
+    invalid;
+    process(value) {
+        this.empty = false;
+        if (!isNaN(value))
+            this.result += value;
+        else
+            this.invalid = true;
+    }
+    getResult() {
+        if (this.invalid)
+            return null;
+        return this.result;
+    }
+}
+Sum.prototype.result = 0;
+Sum.prototype.empty = true;
+class Avg {
+    result = 0;
+    count = 0;
+    empty = true;
+    invalid;
+    process(value, count = 1) {
+        this.empty = false;
+        if (!isNaN(value) && !isNaN(count)) {
+            this.result += value * count;
+            this.count += count;
+        }
+        else
+            this.invalid = true;
+    }
+    getResult() {
+        if (this.empty || this.invalid || this.count == 0)
+            return null;
+        return this.result / this.count;
+    }
+}
+Avg.prototype.result = 0;
+Avg.prototype.count = 0;
+Avg.prototype.empty = true;
+class Count {
+    result = 0;
+    process(value) {
+        if (value != null)
+            this.result++;
+    }
+    getResult() {
+        return this.result;
+    }
+}
+Count.prototype.result = 0;
+class Distinct {
+    values = {};
+    empty = true;
+    result = 0;
+    invalid;
+    constructor() {
+        this.values = {};
+    }
+    process(value) {
+        if (value == null || this.values[value])
+            return;
+        this.values[value] = true;
+        this.empty = false;
+        this.result++;
+    }
+    getResult() {
+        if (this.empty || this.invalid)
+            return null;
+        return this.result;
+    }
+}
+Distinct.prototype.result = 0;
+Distinct.prototype.empty = true;
+class Max {
+    result = 0;
+    empty = true;
+    invalid;
+    process(value) {
+        if (!isNaN(value)) {
+            if (this.empty)
+                this.result = value;
+            else if (value > this.result)
+                this.result = value;
+            this.empty = false;
+        }
+        else if (value != null)
+            this.invalid = true;
+    }
+    getResult() {
+        if (this.empty || this.invalid)
+            return null;
+        return this.result;
+    }
+}
+Max.prototype.result = 0;
+Max.prototype.empty = true;
+class Min {
+    result = 0;
+    empty = true;
+    invalid;
+    process(value) {
+        if (!isNaN(value)) {
+            if (this.empty)
+                this.result = value;
+            else if (value < this.result)
+                this.result = value;
+            this.empty = false;
+        }
+        else if (value != null)
+            this.invalid = true;
+    }
+    getResult() {
+        if (this.empty || this.invalid)
+            return null;
+        return this.result;
+    }
+}
+Min.prototype.result = 0;
+Min.prototype.empty = true;
+class LastValue {
+    result = null;
+    process(value) {
+        this.result = value;
+    }
+    getResult() {
+        return this.result;
+    }
+}
+LastValue.prototype.result = null;

package/build/data/ArrayElementView.d.ts

@@ -0,0 +1,33 @@
+import { AugmentedViewBase } from "./AugmentedViewBase";
+import { View } from "./View";
+export interface ArrayElementViewConfig {
+    store: View;
+    arrayAccessor: any;
+    immutable?: boolean;
+    recordAlias?: string;
+    indexAlias?: string;
+    lengthAlias?: string;
+    hasNestedAliases?: boolean;
+    recordBinding?: any;
+    indexBinding?: any;
+    lengthBinding?: any;
+    itemIndex: number;
+    sealed?: boolean;
+}
+export declare class ArrayElementView extends AugmentedViewBase {
+    arrayAccessor: any;
+    recordAlias: string;
+    indexAlias: string;
+    lengthAlias: string;
+    hasNestedAliases?: boolean;
+    recordBinding?: any;
+    indexBinding?: any;
+    lengthBinding?: any;
+    itemIndex: number;
+    constructor(config: ArrayElementViewConfig);
+    getExtraKeyBinding(key: string): any;
+    deleteExtraKeyValue(key: string): boolean;
+    setExtraKeyValue(key: string, value: any): boolean;
+    embedAugmentData(result: any, parentStoreData: any): void;
+    setIndex(itemIndex: number): void;
+}

package/build/data/ArrayElementView.js

@@ -0,0 +1,65 @@
+import { AugmentedViewBase } from "./AugmentedViewBase";
+import { isArray } from "../util/isArray";
+import { Binding } from "./Binding";
+export class ArrayElementView extends AugmentedViewBase {
+    constructor(config) {
+        super(config);
+        this.hasNestedAliases =
+            this.recordAlias.indexOf(".") >= 0 || this.indexAlias.indexOf(".") >= 0 || this.lengthAlias.indexOf(".") >= 0;
+        this.recordBinding = Binding.get(this.recordAlias);
+        if (this.hasNestedAliases) {
+            this.indexBinding = Binding.get(this.indexAlias);
+            this.lengthBinding = Binding.get(this.lengthAlias);
+        }
+    }
+    getExtraKeyBinding(key) {
+        if (!key.startsWith(this.recordAlias))
+            return null;
+        if (key.length == this.recordAlias.length || key[this.recordAlias.length] == ".")
+            return this.recordBinding;
+        return null;
+    }
+    deleteExtraKeyValue(key) {
+        if (key != this.recordAlias)
+            throw new Error(`Field ${key} cannot be deleted.`);
+        const array = this.arrayAccessor.get(this.store.getData());
+        if (!array)
+            return false;
+        const newArray = [...array.slice(0, this.itemIndex), ...array.slice(this.itemIndex + 1)];
+        return this.arrayAccessor.set(newArray, this.store);
+    }
+    setExtraKeyValue(key, value) {
+        if (key != this.recordAlias)
+            throw new Error(`Field ${key} is read-only.`);
+        const array = this.arrayAccessor.get(this.store.getData());
+        if (!array || value === array[this.itemIndex])
+            return false;
+        const newArray = [...array.slice(0, this.itemIndex), value, ...array.slice(this.itemIndex + 1)];
+        return this.arrayAccessor.set(newArray, this.store);
+    }
+    embedAugmentData(result, parentStoreData) {
+        let array = this.arrayAccessor.get(parentStoreData);
+        if (!isArray(array))
+            return;
+        if (!this.hasNestedAliases) {
+            result[this.recordAlias] = array[this.itemIndex];
+            result[this.indexAlias] = this.itemIndex;
+            result[this.lengthAlias] = array.length;
+        }
+        else {
+            let copy = result;
+            copy = this.recordBinding.set(copy, array[this.itemIndex]);
+            copy = this.indexBinding.set(copy, this.itemIndex);
+            copy = this.lengthBinding.set(copy, array.length);
+            result[this.recordBinding.parts[0]] = copy[this.recordBinding.parts[0]];
+            result[this.indexBinding.parts[0]] = copy[this.indexBinding.parts[0]];
+            result[this.lengthBinding.parts[0]] = copy[this.lengthBinding.parts[0]];
+        }
+    }
+    setIndex(itemIndex) {
+        this.itemIndex = itemIndex;
+    }
+}
+ArrayElementView.prototype.recordAlias = "$record";
+ArrayElementView.prototype.indexAlias = "$index";
+ArrayElementView.prototype.lengthAlias = "$length";

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

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

package/build/data/ArrayElementView.spec.js

@@ -0,0 +1,81 @@
+//@ts-nocheck
+import assert from "assert";
+import { ArrayElementView } from "./ArrayElementView";
+import { getAccessor } from "./getAccessor";
+import { Store } from "./Store";
+describe("ArrayElementView", function () {
+    it("exposes the element as under the $record alias", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters } });
+        let elementView = new ArrayElementView({ store, itemIndex: 1, arrayAccessor: getAccessor({ bind: "letters" }) });
+        let record = elementView.get("$record");
+        assert.equal(record, letters[1]);
+    });
+    it("changes of the $record are propagated", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters } });
+        let elementView = new ArrayElementView({ store, itemIndex: 1, arrayAccessor: getAccessor({ bind: "letters" }) });
+        elementView.set("$record.letter", "C");
+        assert.deepEqual(store.get("letters"), [letters[0], { letter: "C" }]);
+    });
+    it("removes the element if the $record is deleted", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters } });
+        let elementView = new ArrayElementView({ store, itemIndex: 1, arrayAccessor: getAccessor({ bind: "letters" }) });
+        elementView.delete("$record");
+        assert.deepEqual(store.get("letters"), [...letters[0]]);
+    });
+    it("exposes the element as under the given alias", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters } });
+        let elementView = new ArrayElementView({
+            store,
+            itemIndex: 1,
+            arrayAccessor: getAccessor({ bind: "letters" }),
+            recordAlias: "$letter",
+        });
+        let record = elementView.get("$letter");
+        assert.equal(record, letters[1]);
+    });
+    it("aliases allow nesting", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters } });
+        let elementView = new ArrayElementView({
+            store,
+            itemIndex: 1,
+            arrayAccessor: getAccessor({ bind: "letters" }),
+            recordAlias: "$iter.letter",
+            indexAlias: "$iter.index.letter",
+        });
+        let record = elementView.get("$iter.letter");
+        assert.equal(record, letters[1]);
+        assert.equal(elementView.get("$iter.index.letter"), 1);
+        elementView.set("$iter.letter.letter", "C");
+        assert.equal(store.get("letters.1.letter"), "C");
+    });
+    it("when immutable preserves the parent data object", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters } });
+        let elementView = new ArrayElementView({
+            store,
+            itemIndex: 1,
+            arrayAccessor: getAccessor({ bind: "letters" }),
+            immutable: true,
+        });
+        let record = elementView.get("$record");
+        assert.equal(record, letters[1]);
+        assert(!store.getData().hasOwnProperty("$record"));
+    });
+    it("respects the parent's store sealed flag", function () {
+        let letters = [{ letter: "A" }, { letter: "B" }];
+        let store = new Store({ data: { letters }, sealed: true });
+        let elementView = new ArrayElementView({
+            store,
+            itemIndex: 1,
+            arrayAccessor: getAccessor({ bind: "letters" }),
+        });
+        let record = elementView.get("$record");
+        assert.equal(record, letters[1]);
+        assert(!store.getData().hasOwnProperty("$record"));
+    });
+});

package/build/data/ArrayRef.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from "./Ref";
+export declare class ArrayRef<T = any> extends Ref<T[]> {
+    append(...args: T[]): void;
+    insert(index: number, ...args: T[]): void;
+    filter(predicate: (item: T, index?: number) => boolean): void;
+    move(fromIndex: number, toIndex: number): void;
+    clear(): void;
+    sort(compare: (a: T, b: T) => number): void;
+}

package/build/data/ArrayRef.js

@@ -0,0 +1,29 @@
+import { Ref } from "./Ref";
+import { append } from "./ops/append";
+import { moveElement } from "./ops/moveElement";
+import { insertElement } from "./ops/insertElement";
+export class ArrayRef extends Ref {
+    append(...args) {
+        this.update(append, ...args);
+    }
+    insert(index, ...args) {
+        this.update(insertElement, ...args);
+    }
+    filter(predicate) {
+        this.update(array => array.filter(a => predicate(a)));
+    }
+    move(fromIndex, toIndex) {
+        this.update(moveElement, fromIndex, toIndex);
+    }
+    clear() {
+        this.set([]);
+    }
+    sort(compare) {
+        let data = this.get();
+        if (!data)
+            return;
+        let x = [...data];
+        x.sort(compare);
+        this.set(x);
+    }
+}

package/build/data/AugmentedViewBase.d.ts

@@ -0,0 +1,18 @@
+import { View, ViewConfig } from "./View";
+export interface AugmentedViewBaseConfig extends ViewConfig {
+    store: View<any>;
+}
+export declare class AugmentedViewBase<D = any> extends View<D> {
+    immutable: boolean;
+    store: View;
+    constructor(config: AugmentedViewBaseConfig);
+    getData(): any;
+    protected getBaseData(parentStoreData: any): any;
+    protected embedAugmentData(result: any, parentStoreData: any): void;
+    protected isExtraKey(key: string): boolean;
+    protected getExtraKeyBinding(key: string): any;
+    protected setExtraKeyValue(key: string, value: any): boolean;
+    protected deleteExtraKeyValue(key: string): boolean;
+    setItem(path: string, value: any): boolean;
+    deleteItem(path: string): boolean;
+}

package/build/data/AugmentedViewBase.js

@@ -0,0 +1,72 @@
+import { View } from "./View";
+import { Binding } from "./Binding";
+export class AugmentedViewBase extends View {
+    constructor(config) {
+        super(config);
+    }
+    getData() {
+        if (this.sealed && this.meta.version === this.cache.version && this.meta === this.store.meta)
+            return this.cache.result;
+        let parentStoreData = this.store.getData();
+        let result = this.getBaseData(parentStoreData);
+        this.embedAugmentData(result, parentStoreData);
+        this.cache.result = result;
+        this.cache.parentStoreData = parentStoreData;
+        this.cache.version = this.meta.version;
+        this.meta = this.store.meta;
+        return this.cache.result;
+    }
+    getBaseData(parentStoreData) {
+        if (this.sealed || this.immutable || this.store.sealed)
+            return { ...parentStoreData };
+        return parentStoreData;
+    }
+    embedAugmentData(result, parentStoreData) {
+        throw new Error("abstract");
+    }
+    isExtraKey(key) {
+        throw new Error("abstract");
+    }
+    // Stores which need to support nested aliases should override this method
+    getExtraKeyBinding(key) {
+        let binding = Binding.get(key);
+        return this.isExtraKey(binding.parts[0]) ? Binding.get(binding.parts[0]) : null;
+    }
+    setExtraKeyValue(key, value) {
+        throw new Error("abstract");
+    }
+    deleteExtraKeyValue(key) {
+        throw new Error("abstract");
+    }
+    setItem(path, value) {
+        let extraKeyBinding = this.getExtraKeyBinding(path);
+        if (extraKeyBinding) {
+            let binding = Binding.get(path);
+            let newValue = value;
+            if (binding.parts.length > extraKeyBinding.parts.length) {
+                let data = {};
+                this.embedAugmentData(data, this.store.getData());
+                let binding = Binding.get(path);
+                data = binding.set(data, value);
+                newValue = extraKeyBinding.value(data);
+            }
+            return this.setExtraKeyValue(extraKeyBinding.path, newValue);
+        }
+        return super.setItem(path, value);
+    }
+    deleteItem(path) {
+        let extraKeyBinding = this.getExtraKeyBinding(path);
+        if (extraKeyBinding) {
+            if (path == extraKeyBinding.path)
+                return this.deleteExtraKeyValue(extraKeyBinding.path);
+            let data = {};
+            this.embedAugmentData(data, this.store.getData());
+            let binding = Binding.get(path);
+            data = binding.delete(data);
+            let newValue = extraKeyBinding.value(data);
+            return this.setExtraKeyValue(extraKeyBinding.path, newValue);
+        }
+        return super.deleteItem(path);
+    }
+}
+AugmentedViewBase.prototype.immutable = false;

package/build/data/Binding.d.ts

@@ -0,0 +1,23 @@
+import { AccessorChain } from "./createAccessorModelProxy";
+declare let bindingCache: Record<string, Binding<any>>;
+export interface BindingObject {
+    bind: string;
+    defaultValue?: any;
+    throttle?: number;
+    debounce?: number;
+}
+export type BindingInput<T = any> = string | BindingObject | Binding<T> | AccessorChain<T>;
+export type ValueGetter<T> = (state: any) => T | undefined;
+export declare class Binding<T = any> {
+    readonly path: string;
+    readonly parts: readonly string[];
+    readonly value: ValueGetter<T>;
+    constructor(path: string);
+    set<S extends Record<string, any> = any>(state: S, value: T): S;
+    delete<S extends Record<string, any> = any>(state: S): S;
+    static get<T = any>(path: BindingInput<T>): Binding<T>;
+}
+export declare function isBinding(value: unknown): value is BindingInput;
+export type BindingValue<B> = B extends Binding<infer T> ? T : unknown;
+export declare function isBindingObject(value: unknown): value is BindingObject;
+export { bindingCache };

package/build/data/Binding.js

@@ -0,0 +1,78 @@
+import { isString } from "../util/isString";
+import { isObject } from "../util/isObject";
+import { isAccessorChain } from "./createAccessorModelProxy";
+import { hasStringAtKey, hasValueAtKey } from "../util/hasKey";
+let bindingCache = {};
+export class Binding {
+    path;
+    parts;
+    value;
+    constructor(path) {
+        this.path = path;
+        this.parts = path.split(".");
+        let body = "return x";
+        for (let i = 0; i < this.parts.length; i++)
+            body += '?.["' + this.parts[i] + '"]';
+        this.value = new Function("x", body);
+    }
+    set(state, value) {
+        const cv = this.value(state);
+        if (cv === value)
+            return state;
+        const ns = Object.assign({}, state);
+        let o = ns;
+        for (let i = 0; i < this.parts.length; i++) {
+            const part = this.parts[i];
+            const no = i === this.parts.length - 1 ? value : Object.assign({}, o[part]);
+            o[part] = no;
+            o = no;
+        }
+        return ns;
+    }
+    delete(state) {
+        const ns = Object.assign({}, state);
+        let o = ns;
+        let part;
+        for (let i = 0; i < this.parts.length - 1; i++) {
+            part = this.parts[i];
+            const no = Object.assign({}, o[part]);
+            o[part] = no;
+            o = no;
+        }
+        part = this.parts[this.parts.length - 1];
+        if (!o.hasOwnProperty(part))
+            return state;
+        delete o[part];
+        return ns;
+    }
+    static get(path) {
+        if (isString(path)) {
+            let b = bindingCache[path];
+            if (b)
+                return b;
+            b = new Binding(path);
+            bindingCache[path] = b;
+            return b;
+        }
+        if (isBindingObject(path))
+            return this.get(path.bind);
+        if (path instanceof Binding)
+            return path;
+        if (isAccessorChain(path))
+            return this.get(path.toString());
+        throw new Error("Invalid binding definition provided.");
+    }
+}
+export function isBinding(value) {
+    if (isObject(value)) {
+        if (hasStringAtKey(value, "bind"))
+            return true;
+        if (hasValueAtKey(value, "isAccessorChain", true))
+            return true;
+    }
+    return value instanceof Binding;
+}
+export function isBindingObject(value) {
+    return isObject(value) && hasStringAtKey(value, "bind");
+}
+export { bindingCache };

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

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

package/build/data/Binding.spec.js

@@ -0,0 +1,61 @@
+import { Binding } from "./Binding";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+describe("Binding", function () {
+    describe("#get()", function () {
+        it("should get value if value is defined", function () {
+            var state = { person: { name: "Joe" } };
+            var b = Binding.get("person.name");
+            assert.equal(b.value(state), "Joe");
+        });
+        it("allows non-standard property identifiers", function () {
+            var state = { person: { "@schema": "Person" } };
+            var b = Binding.get("person.@schema");
+            assert.equal(b.path, "person.@schema");
+            assert.equal(b.value(state), "Person");
+        });
+        it("properly resolves accessor models", function () {
+            var state = { person: { schema: "Person" } };
+            var b = Binding.get(createAccessorModelProxy("person.schema"));
+            assert.equal(b.value(state), "Person");
+        });
+    });
+    describe("#set()", function () {
+        it("produces new objects along the binding path", function () {
+            var state = { person: { name: "Joe" } };
+            var b = Binding.get("person.name");
+            var ns = b.set(state, "Jack");
+            assert.equal(ns.person.name, "Jack");
+            assert.notEqual(state, ns);
+            assert.notEqual(state.person, ns.person);
+            assert.notEqual(state.person.name, ns.person.name);
+        });
+        it("returns same state object if value does not change", function () {
+            var state = { person: { name: "Joe" } };
+            var b = Binding.get("person.name");
+            var ns = b.set(state, "Joe");
+            assert.equal(state, ns);
+        });
+        it("allows non-standard property identifiers", function () {
+            var state = { person: { "@schema": "Person" } };
+            var b = Binding.get("person.@schema");
+            var ns = b.set(state, "Test");
+            assert.equal(ns.person["@schema"], "Test");
+        });
+    });
+    describe(".delete()", function () {
+        it("correctly removes pointed properties", function () {
+            var state = { person: { name: "Joe" } };
+            var b = Binding.get("person.name");
+            var ns = b.delete(state);
+            assert("person" in ns);
+            assert(!("name" in ns.person));
+        });
+        it("does not change state if property is non-existent", function () {
+            var state = { person: { name: "Joe" } };
+            var b = Binding.get("person.name2");
+            var ns = b.delete(state);
+            assert(ns == state);
+        });
+    });
+});

package/build/data/ExposedRecordView.d.ts

@@ -0,0 +1,24 @@
+import { View } from "./View";
+import { Binding } from "./Binding";
+export interface ExposedRecordViewConfig {
+    store: View;
+    itemIndex: number;
+    immutable?: boolean;
+    collectionBinding: any;
+    recordName: string;
+    indexName: string;
+}
+export declare class ExposedRecordView<D = any> extends View<D> {
+    store: View;
+    itemIndex: number;
+    immutable: boolean;
+    collectionBinding: Binding;
+    recordName: string;
+    indexName: string;
+    constructor(config: ExposedRecordViewConfig);
+    getData(): any;
+    embed(data: any): any;
+    setIndex(index: number): void;
+    setItem(path: string, value: any): boolean;
+    deleteItem(path: string): boolean;
+}