cx 26.0.1 → 26.0.3

package/build/data/Grouper.js

@@ -0,0 +1,138 @@
+import { getSelector } from "./getSelector";
+import { AggregateFunction } from "./AggregateFunction";
+import { Binding } from "./Binding";
+export class Grouper {
+    keys;
+    nameGetter;
+    dataGetter;
+    aggregates;
+    groups;
+    constructor(key, aggregates, dataGetter, nameGetter) {
+        this.keys = Object.keys(key).map((keyField) => {
+            let isSimpleField = keyField.indexOf(".") === -1;
+            let keySetter;
+            if (isSimpleField) {
+                // use simple field setter wherever possible
+                keySetter = function set(result, value) {
+                    result[keyField] = value;
+                    return result;
+                };
+            }
+            else {
+                // for complex paths, use deep setter
+                let binding = Binding.get(keyField);
+                keySetter = (result, value) => binding.set(result, value);
+            }
+            return {
+                name: keyField,
+                keySetter,
+                value: getSelector(key[keyField]),
+            };
+        });
+        if (nameGetter)
+            this.nameGetter = getSelector(nameGetter);
+        this.dataGetter = dataGetter || ((x) => x);
+        this.aggregates =
+            aggregates &&
+                transformValues(aggregates, (prop) => {
+                    if (!(prop.type in AggregateFunction))
+                        throw new Error(`Unknown aggregate function '${prop.type}'.`);
+                    return {
+                        value: getSelector(prop.value),
+                        weight: getSelector(prop.weight ?? 1),
+                        type: prop.type,
+                    };
+                });
+        this.reset();
+    }
+    reset() {
+        this.groups = this.initGroup(this.keys.length == 0);
+    }
+    initGroup(leaf) {
+        if (!leaf)
+            return {};
+        return {
+            records: [],
+            indexes: [],
+            aggregates: this.aggregates &&
+                transformValues(this.aggregates, (prop) => {
+                    let f = AggregateFunction[prop.type];
+                    return {
+                        processor: f(),
+                        value: prop.value,
+                        weight: prop.weight,
+                    };
+                }),
+        };
+    }
+    process(record, index) {
+        let data = this.dataGetter(record);
+        let key = this.keys.map((k) => k.value(data));
+        let g = this.groups;
+        for (let i = 0; i < key.length; i++) {
+            let sg = g[key[i]];
+            if (!sg) {
+                sg = g[key[i]] = this.initGroup(i + 1 == key.length);
+                if (this.nameGetter)
+                    sg.name = this.nameGetter(data);
+            }
+            g = sg;
+        }
+        g.records.push(record);
+        g.indexes.push(index);
+        if (g.aggregates) {
+            for (let k in g.aggregates)
+                g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
+        }
+    }
+    processAll(records, indexes) {
+        if (indexes) {
+            for (let i = 0; i < records.length; i++)
+                this.process(records[i], indexes[i]);
+        }
+        else
+            records.forEach((r, i) => this.process(r, i));
+    }
+    report(g, path, level, results) {
+        if (level == this.keys.length) {
+            let key = {};
+            this.keys.forEach((k, i) => {
+                key = k.keySetter(key, path[i]);
+            });
+            results.push({
+                key: key,
+                name: g.name,
+                records: g.records,
+                indexes: g.indexes,
+                aggregates: resolveKeyPaths(transformValues(g.aggregates, (p) => p.processor.getResult())),
+            });
+        }
+        else {
+            Object.keys(g).forEach((k) => this.report(g[k], [...path, k], level + 1, results));
+        }
+    }
+    getResults() {
+        let g = this.groups;
+        let results = [];
+        this.report(g, [], 0, results);
+        return results;
+    }
+}
+// transform object values using a function
+function transformValues(o, f) {
+    let res = {};
+    for (let k in o)
+        res[k] = f(o[k], k);
+    return res;
+}
+// transform keys like 'a.b.c' into nested objects
+function resolveKeyPaths(o) {
+    let res = {};
+    for (let k in o) {
+        if (k.indexOf(".") > 0)
+            res = Binding.get(k).set(res, o[k]);
+        else
+            res[k] = o[k];
+    }
+    return res;
+}

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

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

package/build/data/Grouper.spec.js

@@ -0,0 +1,48 @@
+import { Grouper } from "./Grouper";
+import assert from "assert";
+describe("Grouper", function () {
+    describe("single grouping", function () {
+        it("should work", function () {
+            let data = [
+                { name: "John", age: 12 },
+                { name: "Jane", age: 12 },
+            ];
+            let grouper = new Grouper({ name: { bind: "name" } });
+            grouper.processAll(data);
+            let results = grouper.getResults();
+            // console.log(results);
+            assert.equal(results.length, 2);
+        });
+        it("keys can have nested properties", function () {
+            let data = [
+                { name: "John", age: 12 },
+                { name: "Jane", age: 12 },
+            ];
+            let grouper = new Grouper({ "person.name": { bind: "name" } });
+            grouper.processAll(data);
+            let results = grouper.getResults();
+            assert.equal(results.length, 2);
+            assert.equal(results[0].key.person?.name, "John");
+            assert.equal(results[1].key.person?.name, "Jane");
+        });
+    });
+    describe("multi grouping", function () {
+        it("should work", function () {
+            let data = [
+                { name: "John", age: 12 },
+                { name: "John", age: 12 },
+                { name: "John", age: 13 },
+                { name: "John", age: 14 },
+                { name: "Jane", age: 12 },
+                { name: "Jane", age: 13 },
+                { name: "Jane", age: 14 },
+            ];
+            let grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
+            grouper.processAll(data);
+            let results = grouper.getResults();
+            // console.log(results);
+            assert.equal(results.length, 6);
+            assert.equal(results[0].records.length, 2);
+        });
+    });
+});

package/build/data/NestedDataView.d.ts

@@ -0,0 +1,21 @@
+import { View, ViewConfig } from "./View";
+import { AugmentedViewBase } from "../data/AugmentedViewBase";
+export interface StructuredDataAccessor {
+    getSelector(): (data: object) => Record<string, any>;
+    get(): object;
+    setItem(key: string, value: any): boolean;
+    containsKey(key: string): boolean;
+    getKeys(): string[];
+}
+export interface NestedDataViewConfig extends ViewConfig {
+    nestedData?: StructuredDataAccessor;
+    store: View;
+}
+export declare class NestedDataView extends AugmentedViewBase {
+    nestedData?: StructuredDataAccessor;
+    constructor(config: NestedDataViewConfig);
+    protected embedAugmentData(result: Record<string, any>, parentStoreData: Record<string, any>): void;
+    protected isExtraKey(key: string): boolean;
+    protected setExtraKeyValue(key: string, value: any): boolean;
+    protected deleteExtraKeyValue(key: string): boolean;
+}

package/build/data/NestedDataView.js

@@ -0,0 +1,24 @@
+import { AugmentedViewBase } from "../data/AugmentedViewBase";
+export class NestedDataView extends AugmentedViewBase {
+    constructor(config) {
+        super(config);
+    }
+    embedAugmentData(result, parentStoreData) {
+        if (this.nestedData) {
+            let nested = this.nestedData.getSelector()(parentStoreData);
+            for (let key in nested)
+                result[key] = nested[key];
+        }
+    }
+    isExtraKey(key) {
+        return !!this.nestedData && this.nestedData.containsKey(key);
+    }
+    setExtraKeyValue(key, value) {
+        if (!this.nestedData)
+            throw new Error("Internal error. This should not happen.");
+        return this.nestedData.setItem(key, value);
+    }
+    deleteExtraKeyValue(key) {
+        return this.setExtraKeyValue(key, undefined);
+    }
+}

package/build/data/ReadOnlyDataView.d.ts

@@ -0,0 +1,13 @@
+import { View, ViewConfig } from "./View";
+export interface ReadOnlyDataViewConfig extends ViewConfig {
+    data?: any;
+}
+export declare class ReadOnlyDataView extends View {
+    store: View;
+    data?: any;
+    immutable?: boolean;
+    constructor(config?: ReadOnlyDataViewConfig);
+    getData(): any;
+    getAdditionalData(data?: any): any;
+    setData(data: any): void;
+}

package/build/data/ReadOnlyDataView.js

@@ -0,0 +1,25 @@
+import { View } from "./View";
+export class ReadOnlyDataView extends View {
+    constructor(config) {
+        super(config);
+    }
+    getData() {
+        if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
+            return this.cache.result;
+        let data = this.store.getData();
+        this.cache.result =
+            this.sealed || this.immutable || this.store.sealed
+                ? Object.assign({}, data, this.getAdditionalData(data))
+                : Object.assign(data, this.getAdditionalData(data));
+        this.cache.version = this.meta.version;
+        this.cache.data = this.data;
+        return this.cache.result;
+    }
+    getAdditionalData(data) {
+        return this.data;
+    }
+    setData(data) {
+        this.data = data;
+    }
+}
+ReadOnlyDataView.prototype.immutable = false;

package/build/data/Ref.d.ts

@@ -0,0 +1,23 @@
+import { Component } from "../util/Component";
+import { View } from "./View";
+import { CanMemoize } from "./Selector";
+export interface RefConfig<T> {
+    store?: View;
+    path?: string;
+    get?: () => T;
+    set?: (value: T) => boolean;
+}
+export declare class Ref<T = any> extends Component implements CanMemoize<T> {
+    isRef?: boolean;
+    constructor(config: RefConfig<T>);
+    get(): T;
+    set(value: T): boolean;
+    delete(): boolean;
+    init(): void;
+    init(value: T): boolean;
+    toggle(): boolean;
+    update(cb: (currentValue: T, ...args: any[]) => T, ...args: any[]): boolean;
+    as(config: any): Ref;
+    ref<ST = any>(path: string): Ref<ST>;
+    memoize(): () => T;
+}

package/build/data/Ref.js

@@ -0,0 +1,79 @@
+import { isFunction } from "../util/isFunction";
+import { Component } from "../util/Component";
+import { Binding } from "./Binding";
+export class Ref extends Component {
+    constructor(config) {
+        super(config);
+        this.get = this.get.bind(this);
+        if (this.set)
+            this.set = this.set.bind(this);
+    }
+    get() {
+        throw new Error("Ref's get method is not implemented.");
+    }
+    set(value) {
+        throw new Error("Ref's set method is not implemented.");
+    }
+    delete() {
+        throw new Error("Ref's delete method is not implemented.");
+    }
+    init(value) {
+        if (value === undefined)
+            return; // Component.init() compatibility
+        if (this.get() === undefined)
+            return this.set(value);
+        return false;
+    }
+    toggle() {
+        return this.set(!this.get());
+    }
+    update(cb, ...args) {
+        return this.set(cb(this.get(), ...args));
+    }
+    as(config) {
+        return Ref.create(config, {
+            get: this.get,
+            set: this.set,
+        });
+    }
+    ref(path) {
+        let binding = Binding.get(path);
+        return Ref.create({
+            get: () => binding.value(this.get()),
+            set: (value) => {
+                let data = this.get();
+                let newData = binding.set(data, value);
+                if (data === newData)
+                    return false;
+                return this.set(newData);
+            },
+        });
+    }
+    //allows the function to be passed as a selector, e.g. to computable or addTrigger
+    memoize() {
+        return this.get;
+    }
+}
+Ref.prototype.isRef = true;
+Ref.factory = function (alias, config, more) {
+    if (isFunction(alias)) {
+        let cfg = {
+            ...config,
+            ...more,
+        };
+        if (cfg.store)
+            Object.assign(cfg, cfg.store.getMethods());
+        let result = alias(cfg);
+        if (result instanceof Ref)
+            return result;
+        return this.create({
+            ...config,
+            ...more,
+            ...result,
+        });
+    }
+    return this.create({
+        ...config,
+        ...more,
+    });
+};

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

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

package/build/data/Ref.spec.js

@@ -0,0 +1,72 @@
+//@ts-nocheck
+import assert from "assert";
+import { Store } from "./Store";
+import { Ref } from "./Ref";
+import { append } from "./ops/append";
+import { StoreRef } from "./StoreRef";
+const getStore = () => {
+    return new Store({
+        data: {
+            a: 3,
+            item: {
+                firstName: "Jack",
+            },
+            array: [],
+        },
+    });
+};
+describe("Ref", () => {
+    it("can init data", () => {
+        let store = getStore();
+        let b = store.ref("b", 1);
+        assert.equal(store.get("b"), 1);
+    });
+    it("can set data", () => {
+        let store = getStore();
+        let b = store.ref("b", 1);
+        b.set(2);
+        assert.equal(store.get("b"), 2);
+    });
+    it("can delete data", () => {
+        let store = getStore();
+        let b = store.ref("item");
+        b.delete();
+        assert.equal(store.get("item"), undefined);
+    });
+    it("can cast itself to a ref of another type", () => {
+        class ArrayRef extends StoreRef {
+            append(...args) {
+                this.update(append, ...args);
+            }
+        }
+        let store = getStore();
+        let array = store.ref("array").as(ArrayRef);
+        array.append(1, 2, 3);
+        assert.deepEqual(array.get(), [1, 2, 3]);
+    });
+    it("can extend itself in a functional way", () => {
+        let store = getStore();
+        let array = store.ref("array").as(({ update, set, path }) => ({
+            append(...args) {
+                update(path, append, ...args);
+            },
+            clear() {
+                set(path, []);
+            },
+        }));
+        array.append(1, 2, 3);
+        assert.deepEqual(array.get(), [1, 2, 3]);
+        array.clear();
+        assert.deepEqual(array.get(), []);
+    });
+    it("can get subrefs", () => {
+        let store = getStore();
+        let person = new Ref({
+            get: () => store.get("person"),
+            set: (value) => store.set("person", value),
+        });
+        let name = person.ref("name");
+        name.set("John");
+        assert.equal(name.get(), "John");
+    });
+});

package/build/data/Selector.d.ts

@@ -0,0 +1,8 @@
+export interface Selector<T = any> {
+    (data: any): T;
+    memoize?: (warmupData?: unknown) => Selector<T>;
+}
+export interface CanMemoize<T = any> {
+    memoize(warmupData?: unknown): Selector<T>;
+}
+export type MemoSelector<T = any> = Selector<T> & CanMemoize<Selector<T>>;

package/build/data/Selector.js

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

package/build/data/Store.d.ts

@@ -0,0 +1,12 @@
+import { SubscribableView, SubscribableViewConfig } from "./SubscribableView";
+export interface StoreConfig<D = any> extends Omit<SubscribableViewConfig, "store"> {
+    data?: D;
+}
+export declare class Store<D extends Record<string, any> = any> extends SubscribableView<D> {
+    data: D;
+    constructor(config?: StoreConfig<D>);
+    getData(): D;
+    setItem(path: string, value: any): boolean;
+    deleteItem(path: string): boolean;
+    clear(): void;
+}

package/build/data/Store.js

@@ -0,0 +1,41 @@
+import { Binding } from "./Binding";
+import { SubscribableView } from "./SubscribableView";
+export class Store extends SubscribableView {
+    data;
+    constructor(config = {}) {
+        super(config);
+        this.data = config.data ?? {};
+        this.meta = {
+            version: 0,
+        };
+    }
+    getData() {
+        return this.data;
+    }
+    setItem(path, value) {
+        let next = Binding.get(path).set(this.data, value);
+        if (next != this.data) {
+            this.data = next;
+            this.meta.version++;
+            this.notify(path);
+            return true;
+        }
+        return false;
+    }
+    deleteItem(path) {
+        let next = Binding.get(path).delete(this.data);
+        if (next != this.data) {
+            this.data = next;
+            this.meta.version++;
+            this.notify(path);
+            return true;
+        }
+        return false;
+    }
+    clear() {
+        this.data = {};
+        this.meta.version++;
+        this.notify();
+    }
+}
+Store.prototype.async = false;

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

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

package/build/data/Store.spec.js

@@ -0,0 +1,19 @@
+import assert from 'assert';
+import { Store } from './Store';
+describe('Store', () => {
+    const getStore = () => {
+        return new Store({
+            data: {
+                a: 3,
+                item: {
+                    firstName: 'Jack'
+                }
+            }
+        });
+    };
+    it('changes version on each update', () => {
+        let store = getStore();
+        store.set('a', 4);
+        assert.equal(store.getMeta().version, 1);
+    });
+});

package/build/data/StoreProxy.d.ts

@@ -0,0 +1,6 @@
+import { View } from "./View";
+export declare class StoreProxy extends View {
+    store: View;
+    constructor(getStore: () => View);
+    getData(): any;
+}

package/build/data/StoreProxy.js

@@ -0,0 +1,14 @@
+import { View } from "./View";
+export class StoreProxy extends View {
+    constructor(getStore) {
+        super({
+            store: getStore(),
+        });
+        Object.defineProperty(this, "store", {
+            get: getStore,
+        });
+    }
+    getData() {
+        return this.store.getData();
+    }
+}

package/build/data/StoreRef.d.ts

@@ -0,0 +1,22 @@
+import { Ref, RefConfig } from "./Ref";
+import { View } from "./View";
+interface StoreRefConfig<T> extends RefConfig<T> {
+    store: View;
+    path: string;
+}
+export declare class StoreRef<T = any> extends Ref<T> {
+    store: View;
+    path: string;
+    constructor(config: StoreRefConfig<T>);
+    get(): any;
+    set(value: T): boolean;
+    init(): void;
+    init(value: T): boolean;
+    toggle(): boolean;
+    delete(): boolean;
+    update(cb: (currentValue: T, ...args: any[]) => T, ...args: any[]): boolean;
+    memoize(): () => any;
+    ref<ST = any>(path: string): StoreRef<ST>;
+    as(config: RefConfig<T>): StoreRef<any>;
+}
+export {};

package/build/data/StoreRef.js

@@ -0,0 +1,47 @@
+import { isAccessorChain } from "./createAccessorModelProxy";
+import { Ref } from "./Ref";
+export class StoreRef extends Ref {
+    constructor(config) {
+        super(config);
+        if (isAccessorChain(this.path))
+            this.path = this.path.toString();
+    }
+    get() {
+        return this.store.get(this.path);
+    }
+    set(value) {
+        return this.store.set(this.path, value);
+    }
+    init(value) {
+        if (value === undefined)
+            return;
+        return this.store.init(this.path, value);
+    }
+    toggle() {
+        return this.store.toggle(this.path);
+    }
+    delete() {
+        return this.store.delete(this.path);
+    }
+    update(cb, ...args) {
+        return this.store.update(this.path, cb, ...args);
+    }
+    //allows the function to be passed as a selector, e.g. to computable or addTrigger
+    memoize() {
+        return this.get;
+    }
+    ref(path) {
+        return new StoreRef({
+            path: `${this.path}.${path}`,
+            store: this.store,
+        });
+    }
+    as(config) {
+        return StoreRef.create(config, {
+            path: this.path,
+            store: this.store,
+            get: this.get,
+            set: this.set,
+        });
+    }
+}

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

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

package/build/data/StoreRef.spec.js

@@ -0,0 +1,22 @@
+//@ts-nocheck
+import assert from "assert";
+import { Store } from "./Store";
+const getStore = () => {
+    return new Store({
+        data: {
+            person: {
+                name: "Jack",
+            },
+        },
+    });
+};
+describe("StoreRef", () => {
+    it("can access child refs", () => {
+        let store = getStore();
+        let person = store.ref("person");
+        let name = person.ref("name");
+        assert.equal(name.get("person"), "Jack");
+        name.set("John");
+        assert.equal(name.get("person"), "John");
+    });
+});

package/build/data/StringTemplate.d.ts

@@ -0,0 +1,9 @@
+import { MemoSelector } from "./Selector";
+export declare function stringTemplate(str: string): MemoSelector<string>;
+export declare const StringTemplate: {
+    get: (str: string) => MemoSelector<string>;
+    compile: (str: string) => import("./Selector").Selector<string>;
+    format: (format: string, ...args: any[]) => string;
+};
+export declare function invalidateStringTemplateCache(): void;
+export declare function setGetStringTemplateCacheCallback(callback: () => Record<string, MemoSelector>): void;