cx 26.0.1 → 26.0.3

package/build/data/View.js

@@ -0,0 +1,163 @@
+import { Binding } from "./Binding";
+import { isArray } from "../util/isArray";
+import { isDefined } from "../util/isDefined";
+import { StoreRef } from "./StoreRef";
+import { isFunction } from "../util/isFunction";
+export class View {
+    cache;
+    notificationsSuspended = 0;
+    dirty = false;
+    constructor(config) {
+        Object.assign(this, config);
+        this.cache = {
+            version: -1,
+        };
+        if (this.store)
+            this.setStore(this.store);
+    }
+    getData() {
+        throw new Error("abstract method");
+    }
+    init(path, value) {
+        if (typeof path == "object" && path != null) {
+            let changed = false;
+            for (let key in path)
+                if (path.hasOwnProperty(key) && this.get(key) === undefined && this.setItem(key, path[key]))
+                    changed = true;
+            return changed;
+        }
+        let binding = Binding.get(path);
+        if (this.get(binding.path) === undefined)
+            return this.setItem(binding.path, value);
+        return false;
+    }
+    set(path, value) {
+        if (typeof path == "object" && path != null) {
+            let changed = false;
+            for (let key in path)
+                if (path.hasOwnProperty(key) && this.setItem(key, path[key]))
+                    changed = true;
+            return changed;
+        }
+        let binding = Binding.get(path);
+        return this.setItem(binding.path, value);
+    }
+    copy(from, to) {
+        let value = this.get(from);
+        return this.set(to, value);
+    }
+    move(from, to) {
+        return this.batch(() => {
+            this.copy(from, to);
+            this.delete(from);
+        });
+    }
+    //protected
+    setItem(path, value) {
+        if (this.store)
+            return this.store.setItem(path, value);
+        throw new Error("abstract method");
+    }
+    delete(path) {
+        if (arguments.length > 1)
+            path = Array.from(arguments);
+        if (isArray(path))
+            return path.map((arg) => this.delete(arg)).some(Boolean);
+        let binding = Binding.get(path);
+        return this.deleteItem(binding.path);
+    }
+    //protected
+    deleteItem(path) {
+        if (this.store)
+            return this.store.deleteItem(path);
+        throw new Error("abstract method");
+    }
+    clear() {
+        if (this.store)
+            return this.store.clear();
+        throw new Error("abstract method");
+    }
+    get(path, ...args) {
+        let storeData = this.getData();
+        if (arguments.length > 1)
+            path = Array.from(arguments);
+        if (isArray(path))
+            return path.map((arg) => Binding.get(arg).value(storeData));
+        return Binding.get(path).value(storeData);
+    }
+    toggle(path) {
+        return this.set(path, !this.get(path));
+    }
+    update(path, updateFn, ...args) {
+        if (arguments.length == 1 && isFunction(path))
+            return this.load(path.apply(null, [this.getData(), updateFn, ...args]));
+        return this.set(path, updateFn.apply(null, [this.get(path), ...args]));
+    }
+    mutate(path, updateFn, ...args) {
+        throw new Error("Mutate requires Immer. Please install 'immer' and 'cx-immer' packages and enable store mutation by calling enableImmerMutate().");
+    }
+    batch(callback) {
+        let dirty = this.silently(callback);
+        if (dirty)
+            this.notify();
+        return dirty;
+    }
+    silently(callback) {
+        if (this.store)
+            return this.store.silently(callback);
+        throw new Error("abstract method");
+    }
+    notify(path) {
+        if (this.notificationsSuspended)
+            this.dirty = true;
+        else
+            this.doNotify(path);
+    }
+    doNotify(path) {
+        if (this.store)
+            return this.store.notify(path);
+        throw new Error("abstract method");
+    }
+    subscribe(callback) {
+        if (this.store)
+            return this.store.subscribe(callback);
+        throw new Error("abstract method");
+    }
+    load(data) {
+        return this.set(data);
+    }
+    dispatch(action) {
+        if (this.store)
+            return this.store.dispatch(action);
+        throw new Error("The underlying store doesn't support dispatch.");
+    }
+    getMeta() {
+        return this.meta;
+    }
+    setStore(store) {
+        this.store = store;
+        this.meta = store.getMeta();
+    }
+    ref(path, defaultValue) {
+        if (isDefined(defaultValue))
+            this.init(path, defaultValue);
+        return StoreRef.create({
+            store: this,
+            path,
+        });
+    }
+    getMethods() {
+        return {
+            getData: this.getData.bind(this),
+            set: this.set.bind(this),
+            get: this.get.bind(this),
+            update: this.update.bind(this),
+            delete: this.delete.bind(this),
+            toggle: this.toggle.bind(this),
+            init: this.init.bind(this),
+            ref: this.ref.bind(this),
+            mutate: this.mutate.bind(this),
+        };
+    }
+}
+View.prototype.sealed = false; //indicate that data should be copied before virtual items are added

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

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

package/build/data/View.spec.js

@@ -0,0 +1,44 @@
+//@ts-nocheck
+import assert from 'assert';
+import { Store } from './Store';
+describe('View', () => {
+    const getStore = () => {
+        return new Store({
+            data: {
+                a: 3,
+                item: {
+                    firstName: 'Jack'
+                }
+            }
+        });
+    };
+    describe('.get', () => {
+        it('retrieves a value pointed by a selector path', () => {
+            let store = getStore();
+            assert.equal(store.get('item.firstName'), 'Jack');
+        });
+        it('will return an array if multiple arguments are passed', () => {
+            let store = getStore();
+            assert.deepEqual(store.get('a', 'item.firstName'), [3, 'Jack']);
+        });
+        it('will return an array if array is passed', () => {
+            let store = getStore();
+            assert.deepEqual(store.get(['a', 'item.firstName']), [3, 'Jack']);
+        });
+    });
+    describe('.set', () => {
+        it('supports deep selectors', () => {
+            let store = getStore();
+            store.set('item.firstName', 'Jill');
+            assert.equal(store.get('item.firstName'), 'Jill');
+        });
+        it('supports setting multiple items through an object', () => {
+            let store = getStore();
+            store.set({
+                'b': 4,
+                'item.firstName': 'Jill'
+            });
+            assert.deepEqual(store.get(['b', 'item.firstName']), [4, 'Jill']);
+        });
+    });
+});

package/build/data/ZoomIntoPropertyView.d.ts

@@ -0,0 +1,15 @@
+import { Binding } from "./Binding";
+import { NestedDataView, NestedDataViewConfig } from "./NestedDataView";
+export interface ZoomIntoPropertyViewConfig extends NestedDataViewConfig {
+    binding: Binding;
+    rootName?: string;
+}
+export declare class ZoomIntoPropertyView extends NestedDataView {
+    binding: Binding;
+    rootName: string;
+    constructor(config: ZoomIntoPropertyViewConfig);
+    protected getBaseData(parentStoreData: any): any;
+    protected embedAugmentData(result: any, parentStoreData: any): void;
+    setItem(path: string, value: any): boolean;
+    deleteItem(path: string): boolean;
+}

package/build/data/ZoomIntoPropertyView.js

@@ -0,0 +1,34 @@
+import { Binding } from "./Binding";
+import { NestedDataView } from "./NestedDataView";
+export class ZoomIntoPropertyView extends NestedDataView {
+    constructor(config) {
+        super(config);
+    }
+    getBaseData(parentStoreData) {
+        let x = this.binding.value(parentStoreData);
+        if (x != null && typeof x != "object")
+            throw new Error("Zoomed value must be an object.");
+        return {
+            ...x,
+        };
+    }
+    embedAugmentData(result, parentStoreData) {
+        result[this.rootName] = parentStoreData;
+        super.embedAugmentData(result, parentStoreData);
+    }
+    setItem(path, value) {
+        if (path.indexOf(this.rootName + ".") == 0)
+            return this.store.setItem(path.substring(this.rootName.length + 1), value);
+        if (this.isExtraKey(Binding.get(path).parts[0]))
+            return super.setItem(path, value);
+        return super.setItem(this.binding.path + "." + path, value);
+    }
+    deleteItem(path) {
+        if (path.indexOf(this.rootName + ".") == 0)
+            return this.store.deleteItem(path.substring(this.rootName.length + 1));
+        if (this.isExtraKey(Binding.get(path).parts[0]))
+            return super.deleteItem(path);
+        return super.deleteItem(this.binding.path + "." + path);
+    }
+}
+ZoomIntoPropertyView.prototype.rootName = "$root";

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

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

package/build/data/ZoomIntoPropertyView.spec.js

@@ -0,0 +1,54 @@
+import assert from "assert";
+import { Binding } from "./Binding";
+import { Store } from "./Store";
+import { ZoomIntoPropertyView } from "./ZoomIntoPropertyView";
+describe("ZoomIntoPropertyView", () => {
+    const getZoom = () => {
+        let store = new Store({
+            data: {
+                a: 3,
+                item: {
+                    firstName: "Jack",
+                },
+            },
+        });
+        return new ZoomIntoPropertyView({
+            store: store,
+            binding: Binding.get("item"),
+        });
+    };
+    it("allows direct access to properties of zoomed object", () => {
+        let zoom = getZoom();
+        assert.equal(zoom.get("firstName"), "Jack");
+    });
+    it("allows access to outside data through $root", () => {
+        let zoom = getZoom();
+        assert.equal(zoom.get("$root.a"), 3);
+    });
+    it("correctly sets zoomed object", () => {
+        let zoom = getZoom();
+        zoom.set("firstName", "Joe");
+        assert.equal(zoom.get("firstName"), "Joe");
+    });
+    it("correctly sets zoomed values", () => {
+        let zoom = getZoom();
+        zoom.set("firstName", "Joe");
+        assert.equal(zoom.get("firstName"), "Joe");
+        assert.equal(zoom.get("$root.item.firstName"), "Joe");
+    });
+    it("correctly sets outside values", () => {
+        let zoom = getZoom();
+        zoom.set("$root.a", 6);
+        assert.equal(zoom.get("$root.a"), 6);
+    });
+    it("correctly deletes zoomed values", () => {
+        let zoom = getZoom();
+        zoom.delete("firstName");
+        assert.equal(zoom.get("firstName"), undefined);
+    });
+    it("correctly deletes outside values", () => {
+        let zoom = getZoom();
+        zoom.delete("$root.a");
+        assert.equal(zoom.get("$root.a"), undefined);
+    });
+});

package/build/data/comparer.d.ts

@@ -0,0 +1,11 @@
+interface Sorter {
+    value?: any;
+    field?: string;
+    direction?: string;
+    comparer?: (a: any, b: any) => number;
+    compare?: (a: any, b: any) => number;
+}
+export declare function getComparer(sorters: Sorter[], dataAccessor?: (x: any) => any, comparer?: (a: any, b: any) => number): (a: any, b: any) => number;
+export declare function indexSorter(sorters: Sorter[], dataAccessor?: (x: any) => any, compare?: (a: any, b: any) => number): (data: any[]) => number[];
+export declare function sorter(sorters: Sorter[], dataAccessor?: (x: any) => any, compare?: (a: any, b: any) => number): (data: any[]) => any[];
+export {};

package/build/data/comparer.js

@@ -0,0 +1,55 @@
+import { getSelector } from "./getSelector";
+import { isDefined } from "../util/isDefined";
+import { defaultCompare } from "./defaultCompare";
+export function getComparer(sorters, dataAccessor, comparer) {
+    let resolvedSorters = (sorters || []).map((s) => {
+        let selector = isDefined(s.value)
+            ? getSelector(s.value)
+            : s.field
+                ? (x) => x[s.field]
+                : () => null;
+        return {
+            getter: dataAccessor ? (x) => selector(dataAccessor(x)) : selector,
+            factor: s.direction && s.direction[0].toLowerCase() == "d" ? -1 : 1,
+            compare: s.comparer || s.compare || comparer || defaultCompare,
+        };
+    });
+    return function (a, b) {
+        let d, av, bv;
+        for (let i = 0; i < resolvedSorters.length; i++) {
+            d = resolvedSorters[i];
+            av = d.getter(a);
+            bv = d.getter(b);
+            // show nulls always on the bottom
+            if (av == null) {
+                if (bv == null)
+                    continue;
+                else
+                    return 1;
+            }
+            if (bv == null)
+                return -1;
+            let r = d.compare(av, bv);
+            if (r == 0)
+                continue;
+            return d.factor * r;
+        }
+        return 0;
+    };
+}
+export function indexSorter(sorters, dataAccessor, compare) {
+    let cmp = getComparer(sorters, dataAccessor, compare);
+    return function (data) {
+        let result = Array.from({ length: data.length }, (v, k) => k);
+        result.sort((ia, ib) => cmp(data[ia], data[ib]));
+        return result;
+    };
+}
+export function sorter(sorters, dataAccessor, compare) {
+    let cmp = getComparer(sorters, dataAccessor, compare);
+    return function (data) {
+        let result = [...data];
+        result.sort(cmp);
+        return result;
+    };
+}

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

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

package/build/data/comparer.spec.js

@@ -0,0 +1,50 @@
+import { sorter } from "./comparer";
+import assert from "assert";
+describe("comparer", function () {
+    describe("sorter", function () {
+        it("orders by numeric values ASC", function () {
+            let records = [
+                { value: 3, id: 1 },
+                { value: -1, id: 2 },
+                { value: 2, id: 3 },
+                { value: null, id: 4 },
+                { value: null, id: 5 },
+            ];
+            let sort = sorter([{ value: { bind: "value" }, direction: "ASC" }]);
+            let sorted = sort(records);
+            assert.equal(sorted[0].value, -1);
+            assert.equal(sorted[1].value, 2);
+            assert.equal(sorted[2].value, 3);
+            assert.equal(sorted[3].value, null);
+            assert.equal(sorted[4].value, null);
+        });
+        it("orders by numeric values DESC", function () {
+            let records = [
+                { value: 3, id: 1 },
+                { value: 1, id: 2 },
+                { value: -2, id: 3 },
+                { value: null, id: 4 },
+                { value: null, id: 5 },
+            ];
+            let sort = sorter([{ value: { bind: "value" }, direction: "DESC" }]);
+            let sorted = sort(records);
+            assert.equal(sorted[0].value, 3);
+            assert.equal(sorted[1].value, 1);
+            assert.equal(sorted[2].value, -2);
+            assert.equal(sorted[3].value, null);
+            assert.equal(sorted[4].value, null);
+        });
+        it("supports field", function () {
+            let records = [
+                { value: 3, id: 1 },
+                { value: 1, id: 2 },
+                { value: 2, id: 3 },
+            ];
+            let sort = sorter([{ field: "value", direction: "ASC" }]);
+            let sorted = sort(records);
+            assert.equal(sorted[0].value, 1);
+            assert.equal(sorted[1].value, 2);
+            assert.equal(sorted[2].value, 3);
+        });
+    });
+});

package/build/data/computable.d.ts

@@ -0,0 +1,10 @@
+import { AccessorChain } from "./createAccessorModelProxy";
+import { CanMemoize, MemoSelector, Selector } from "./Selector";
+export type ComputableSelector<T = any> = string | Selector<T> | AccessorChain<T> | CanMemoize<T>;
+export type InferSelectorValue<T> = T extends Selector<infer R> ? R : T extends AccessorChain<infer R> ? R : T extends string ? any : never;
+export declare function computable<Selectors extends readonly any[], R>(...args: [
+    ...selectors: ComputableSelector[],
+    compute: (...values: {
+        [K in keyof Selectors]: InferSelectorValue<Selectors[K]>;
+    }) => R
+]): MemoSelector<R>;

package/build/data/computable.js

@@ -0,0 +1,46 @@
+import { Binding } from "./Binding";
+import { isString } from "../util/isString";
+import { isFunction } from "../util/isFunction";
+import { isAccessorChain } from "./createAccessorModelProxy";
+export function computable(...selectorsAndCompute) {
+    if (selectorsAndCompute.length == 0)
+        throw new Error("computable requires at least a compute function to be passed in arguments.");
+    let compute = selectorsAndCompute[selectorsAndCompute.length - 1];
+    if (typeof compute != "function")
+        throw new Error("Last argument to the computable function should be a function.");
+    let inputs = [], a;
+    for (let i = 0; i + 1 < selectorsAndCompute.length; i++) {
+        a = selectorsAndCompute[i];
+        if (isString(a) || isAccessorChain(a))
+            inputs.push(Binding.get(a.toString()).value);
+        else if (a.memoize)
+            inputs.push(a.memoize());
+        else if (isFunction(a))
+            inputs.push(a);
+        else
+            throw new Error(`Invalid selector type '${typeof a}' received.`);
+    }
+    function memoize(warmupData) {
+        let lastValue, lastArgs = warmupData && inputs.map((s) => s(warmupData));
+        return function (data) {
+            let dirty = false;
+            if (!lastArgs) {
+                lastArgs = Array.from({ length: inputs.length });
+                dirty = true;
+            }
+            for (let i = 0; i < inputs.length; i++) {
+                let v = inputs[i](data);
+                if (v === lastArgs[i])
+                    continue;
+                lastArgs[i] = v;
+                dirty = true;
+            }
+            if (dirty)
+                lastValue = compute.apply(null, lastArgs);
+            return lastValue;
+        };
+    }
+    let selector = (data) => compute.apply(null, inputs.map((s) => s(data)));
+    selector.memoize = memoize;
+    return selector;
+}

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

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

package/build/data/computable.spec.js

@@ -0,0 +1,56 @@
+import { computable } from "./computable";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+describe("computable", function () {
+    it("creates a selector", function () {
+        let state = { person: { name: "Joe" } };
+        let nameLength = computable("person.name", (name) => name.length);
+        assert.equal(nameLength(state), 3);
+    });
+    it("fires every time if not memoized", function () {
+        let state = { person: { name: "Joe" } };
+        let fired = 0;
+        let nameLength = computable("person.name", (name) => {
+            fired++;
+            return name.length;
+        });
+        assert.equal(nameLength(state), 3);
+        assert.equal(nameLength(state), 3);
+        assert.equal(fired, 2);
+    });
+    it("fires once if memoized and data has not changed", function () {
+        let state = { person: { name: "Joe" } };
+        let fired = 0;
+        let nameLength = computable("person.name", (name) => {
+            fired++;
+            return name.length;
+        }).memoize();
+        assert.equal(nameLength(state), 3);
+        assert.equal(nameLength(state), 3);
+        assert.equal(fired, 1);
+    });
+    //weird but that's how triggers work and
+    it("memoize with warmup data will not call compute", function () {
+        let state = { person: { name: "Joe" } };
+        let fired = 0;
+        let nameLength = computable("person.name", (name) => {
+            fired++;
+            return name.length;
+        }).memoize(state);
+        assert.equal(nameLength(state), undefined);
+        assert.equal(nameLength(state), undefined);
+        assert.equal(fired, 0);
+    });
+    it("works with accessors", function () {
+        var m = createAccessorModelProxy();
+        let state = { person: { name: "Joe" } };
+        let nameLength = computable(m.person.name, (name) => name.length);
+        assert.equal(nameLength(state), 3);
+    });
+    it("works with array length accessor", function () {
+        var m = createAccessorModelProxy();
+        let state = { items: ["a", "b", "c"] };
+        let itemCount = computable(m.items.length, (length) => length);
+        assert.equal(itemCount(state), 3);
+    });
+});

package/build/data/createAccessorModelProxy.d.ts

@@ -0,0 +1,17 @@
+interface AccessorChainMethods {
+    toString(): string;
+    valueOf(): unknown;
+    nameOf(): string;
+}
+type AccessorChainMap<M extends object> = {
+    [prop in Exclude<keyof M, keyof AccessorChainMethods>]: AccessorChain<M[prop]>;
+};
+export type AccessorChain<M> = {
+    toString(): string;
+    valueOf(): string;
+    nameOf(): string;
+    __accessorChainType?: M;
+} & (M extends object ? AccessorChainMap<M> : {});
+export declare function createAccessorModelProxy<M>(chain?: string): AccessorChain<M>;
+export declare function isAccessorChain<M>(value: unknown): value is AccessorChain<M>;
+export {};

package/build/data/createAccessorModelProxy.js

@@ -0,0 +1,37 @@
+const emptyFn = () => { };
+export function createAccessorModelProxy(chain = "") {
+    let lastOp = null;
+    const proxy = new Proxy(emptyFn, {
+        get: (_, name) => {
+            if (typeof name !== "string")
+                return proxy;
+            switch (name) {
+                case "isAccessorChain":
+                    return true;
+                case "toString":
+                case "valueOf":
+                case "nameOf":
+                    lastOp = name;
+                    return proxy;
+            }
+            let newChain = chain;
+            if (newChain.length > 0)
+                newChain += ".";
+            newChain += name;
+            return createAccessorModelProxy(newChain);
+        },
+        apply() {
+            switch (lastOp) {
+                case "nameOf":
+                    const lastDotIndex = chain.lastIndexOf(".");
+                    return lastDotIndex > 0 ? chain.substring(lastDotIndex + 1) : chain;
+                default:
+                    return chain;
+            }
+        },
+    });
+    return proxy;
+}
+export function isAccessorChain(value) {
+    return value != null && !!value.isAccessorChain;
+}

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

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

package/build/data/createAccessorModelProxy.spec.js

@@ -0,0 +1,30 @@
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+import assert from "assert";
+describe("createAccessorModelProxy", () => {
+    it("generates correct paths", () => {
+        let model = createAccessorModelProxy();
+        assert.strictEqual(model.firstName.toString(), "firstName");
+        assert.strictEqual(model.address.toString(), "address");
+        assert.strictEqual(model.address.city.toString(), "address.city");
+    });
+    it("can be used in string templates", () => {
+        let model = createAccessorModelProxy();
+        assert.strictEqual("address.city", `${model.address.city}`);
+        assert.strictEqual("address.city", "" + model.address.city);
+        assert.strictEqual("address.city.suffix", model.address.city + ".suffix");
+    });
+    it("nameOf returns name of the last prop ", () => {
+        let model = createAccessorModelProxy();
+        assert.strictEqual(model.firstName.nameOf(), "firstName");
+        assert.strictEqual(model.address.nameOf(), "address");
+        assert.strictEqual(model.address.city.nameOf(), "city");
+        assert.strictEqual(model.address.nameOf(), "address");
+        let { streetNumber, city } = model.address;
+        assert.strictEqual(streetNumber.nameOf(), "streetNumber");
+        assert.strictEqual(city.nameOf(), "city");
+    });
+    it("allows non-standard property identifiers ", () => {
+        let model = createAccessorModelProxy();
+        assert.strictEqual(model["@crazy"].nameOf(), "@crazy");
+    });
+});

package/build/data/createStructuredSelector.d.ts

@@ -0,0 +1,9 @@
+import { MemoSelector, Selector } from "./Selector";
+export interface StructuredSelectorConfig {
+    [prop: string]: Selector;
+}
+type InferStructuredSelectorResult<T extends StructuredSelectorConfig, C = {}> = {
+    [K in keyof T]: T[K] extends Selector<infer R> ? R : any;
+} & C;
+export declare function createStructuredSelector<S extends StructuredSelectorConfig, C extends Record<string, any> = {}>(selector: S, constants?: C): MemoSelector<InferStructuredSelectorResult<S, C>>;
+export {};