cx 26.0.1 → 26.0.3

package/build/data/ops/insertElement.d.ts

@@ -0,0 +1 @@
+export declare function insertElement<T>(array: T[], index: number, ...elements: T[]): T[];

package/build/data/ops/insertElement.js

@@ -0,0 +1,3 @@
+export function insertElement(array, index, ...elements) {
+    return [...array.slice(0, index), ...elements, ...array.slice(index)];
+}

package/build/data/ops/merge.d.ts

@@ -0,0 +1 @@
+export declare function merge<T extends object>(item: T, data?: Partial<T>): T;

package/build/data/ops/merge.js

@@ -0,0 +1,10 @@
+import { Binding } from "../Binding";
+export function merge(item, data) {
+    let result = item;
+    if (data) {
+        for (const key in data) {
+            result = Binding.get(key).set(result, data[key]);
+        }
+    }
+    return result;
+}

package/build/data/ops/merge.spec.d.ts

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

package/build/data/ops/merge.spec.js

@@ -0,0 +1,23 @@
+import { Store } from "../Store";
+import { merge } from "./merge";
+import assert from "assert";
+describe("merge", function () {
+    it("performs multiple set operations", function () {
+        let store = new Store({
+            data: {
+                person: { firstName: "John", lastName: "Doe" },
+            },
+        });
+        assert(store.update("person", merge, { firstName: "Johny", age: 18 }));
+        assert.deepEqual(store.get("person"), { firstName: "Johny", lastName: "Doe", age: 18 });
+    });
+    it("does not modify data if not necessary", function () {
+        let store = new Store({
+            data: {
+                person: { firstName: "John", lastName: "Doe" },
+            },
+        });
+        assert(store.update("person", merge, { firstName: "John" }) == false);
+        assert.deepEqual(store.get("person"), { firstName: "John", lastName: "Doe" });
+    });
+});

package/build/data/ops/moveElement.d.ts

@@ -0,0 +1 @@
+export declare function moveElement<T>(array: T[], sourceIndex: number, targetIndex: number): T[];

package/build/data/ops/moveElement.js

@@ -0,0 +1,20 @@
+export function moveElement(array, sourceIndex, targetIndex) {
+    if (sourceIndex === targetIndex)
+        return array;
+    const result = [...array];
+    const element = result[sourceIndex];
+    if (sourceIndex < targetIndex) {
+        for (let i = sourceIndex; i < targetIndex - 1; i++) {
+            result[i] = result[i + 1];
+        }
+        result[targetIndex - 1] = result[targetIndex];
+        targetIndex--;
+    }
+    else {
+        for (let i = sourceIndex; i > targetIndex; i--) {
+            result[i] = result[i - 1];
+        }
+    }
+    result[targetIndex] = element;
+    return result;
+}

package/build/data/ops/removeTreeNodes.d.ts

@@ -0,0 +1 @@
+export declare function removeTreeNodes<T extends Record<string, any>>(array: T[] | undefined, criteria: (node: T) => boolean, childrenField?: keyof T): T[] | undefined;

package/build/data/ops/removeTreeNodes.js

@@ -0,0 +1,4 @@
+import { updateTree } from "./updateTree";
+export function removeTreeNodes(array, criteria, childrenField = "$children") {
+    return updateTree(array, (x) => x, () => false, childrenField, criteria);
+}

package/build/data/ops/removeTreeNodes.spec.d.ts

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

package/build/data/ops/removeTreeNodes.spec.js

@@ -0,0 +1,35 @@
+import { Store } from "../Store";
+import { removeTreeNodes } from "./removeTreeNodes";
+import assert from "assert";
+describe("removeTreeNodes", function () {
+    it("removes all nodes that satisfy criteria", function () {
+        let store = new Store({
+            data: {
+                array: [
+                    {
+                        id: "n1",
+                        value: 1,
+                        children: [
+                            {
+                                id: "n11",
+                                value: 2,
+                            },
+                            {
+                                id: "n12",
+                                value: 3,
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        assert(store.update("array", removeTreeNodes, (x) => x.value > 1, "children"));
+        assert.deepEqual(store.get("array"), [
+            {
+                id: "n1",
+                value: 1,
+                children: [],
+            },
+        ]);
+    });
+});

package/build/data/ops/updateArray.d.ts

@@ -0,0 +1 @@
+export declare function updateArray<T = any>(array: T[] | undefined, updateCallback: (item: T, index: number) => T, itemFilter?: null | ((item: T, index: number) => boolean), removeFilter?: (item: T, index: number) => boolean): T[] | undefined;

package/build/data/ops/updateArray.js

@@ -0,0 +1,23 @@
+export function updateArray(array, updateCallback, itemFilter, removeFilter) {
+    if (!array)
+        return array;
+    const newArray = [];
+    let dirty = false;
+    for (let index = 0; index < array.length; index++) {
+        const item = array[index];
+        if (removeFilter && removeFilter(item, index)) {
+            dirty = true;
+            continue;
+        }
+        if (!itemFilter || itemFilter(item, index)) {
+            const newItem = updateCallback(item, index);
+            newArray.push(newItem);
+            if (newItem !== item)
+                dirty = true;
+        }
+        else {
+            newArray.push(item);
+        }
+    }
+    return dirty ? newArray : array;
+}

package/build/data/ops/updateArray.spec.d.ts

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

package/build/data/ops/updateArray.spec.js

@@ -0,0 +1,33 @@
+import { Store } from "../Store";
+import { updateArray } from "./updateArray";
+import assert from "assert";
+describe("updateArray", function () {
+    it("updates all elements that satisfy criteria", function () {
+        let store = new Store({
+            data: { array: [1, 2, 3, 4, 5, 6] },
+        });
+        assert(store.update("array", updateArray, (x) => x + 1, (x) => x > 3));
+        assert.deepEqual(store.get("array"), [1, 2, 3, 5, 6, 7]);
+    });
+    it("does not modify data if not necessary", function () {
+        let array = [1, 2, 3, 4, 5, 6];
+        let store = new Store({
+            data: { array },
+        });
+        assert(false ===
+            store.update("array", updateArray, (x) => x + 1, (x) => x > 10));
+        assert(store.get("array") === array);
+    });
+    it("works with null or undefined", function () {
+        let store = new Store();
+        assert(false ===
+            store.update("array", updateArray, (x) => x + 1, (x) => x > 0));
+    });
+    it("can remove elements given the criteria", function () {
+        let store = new Store({
+            data: { array: [1, 2, 3, 4, 5, 6] },
+        });
+        assert(store.update("array", updateArray, (x) => x + 1, (x) => x > 3, (x) => x <= 3));
+        assert.deepEqual(store.get("array"), [5, 6, 7]);
+    });
+});

package/build/data/ops/updateTree.d.ts

@@ -0,0 +1 @@
+export declare function updateTree<T extends Record<string, any> = any>(array: T[] | undefined, updateCallback: (item: T) => T, itemFilter: ((item: T) => boolean) | null, childrenField: keyof T, removeFilter?: (item: T) => boolean): T[] | undefined;

package/build/data/ops/updateTree.js

@@ -0,0 +1,14 @@
+import { updateArray } from "./updateArray";
+export function updateTree(array, updateCallback, itemFilter, childrenField, removeFilter) {
+    return updateArray(array, (item) => {
+        if (!itemFilter || itemFilter(item))
+            item = updateCallback(item);
+        const children = item[childrenField];
+        if (!Array.isArray(children))
+            return item;
+        const updatedChildren = updateTree(children, updateCallback, itemFilter, childrenField, removeFilter);
+        if (updatedChildren != children)
+            return { ...item, [childrenField]: updatedChildren };
+        return item;
+    }, null, removeFilter);
+}

package/build/data/ops/updateTree.spec.d.ts

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

package/build/data/ops/updateTree.spec.js

@@ -0,0 +1,44 @@
+import { Store } from "../Store";
+import { updateTree } from "./updateTree";
+import assert from "assert";
+describe("updateTree", function () {
+    it("updates all nodes that satisfy criteria", function () {
+        let store = new Store({
+            data: {
+                array: [
+                    {
+                        id: "n1",
+                        value: 1,
+                        children: [
+                            {
+                                id: "n11",
+                                value: 2,
+                            },
+                            {
+                                id: "n12",
+                                value: 3,
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        assert(store.update("array", updateTree, (x) => ({ ...x, value: x.value + 1 }), (x) => x.value > 1, "children"));
+        assert.deepEqual(store.get("array"), [
+            {
+                id: "n1",
+                value: 1,
+                children: [
+                    {
+                        id: "n11",
+                        value: 3,
+                    },
+                    {
+                        id: "n12",
+                        value: 4,
+                    },
+                ],
+            },
+        ]);
+    });
+});

package/build/data/test-types.d.ts

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

package/build/data/test-types.js

@@ -0,0 +1,2 @@
+export {};
+// The issue: does AccessorChain properly map array properties?

package/build/hooks/createLocalStorageRef.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from "../data/Ref";
+export declare function createLocalStorageRef<T = any>(key: string): Ref<T>;

package/build/hooks/createLocalStorageRef.js

@@ -0,0 +1,22 @@
+import { useStore } from "./store";
+import { Ref } from "../data/Ref";
+export function createLocalStorageRef(key) {
+    let store = useStore();
+    return new Ref({
+        get() {
+            let json = localStorage.getItem(key);
+            if (!json)
+                return localStorage.hasOwnProperty(key) ? null : undefined;
+            return JSON.parse(json);
+        },
+        set(value) {
+            if (value === undefined)
+                localStorage.removeItem(key);
+            else
+                localStorage.setItem(key, JSON.stringify(value));
+            store.meta.version++;
+            store.notify();
+            return true;
+        },
+    });
+}

package/build/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./store";
+export * from "./useEffect";
+export * from "./useInterval";
+export * from "./useTrigger";
+export * from "./useState";
+export * from "./createLocalStorageRef";
+export * from "./resolveCallback";
+export * from "./invokeCallback";

package/build/hooks/index.js

@@ -0,0 +1,8 @@
+export * from "./store";
+export * from "./useEffect";
+export * from "./useInterval";
+export * from "./useTrigger";
+export * from "./useState";
+export * from "./createLocalStorageRef";
+export * from "./resolveCallback";
+export * from "./invokeCallback";

package/build/hooks/invokeCallback.d.ts

@@ -0,0 +1,2 @@
+import { Instance } from "../ui/Instance";
+export declare function invokeCallback(instance: Instance, callback: string | ((...args: any[]) => any), ...args: any[]): any;

package/build/hooks/invokeCallback.js

@@ -0,0 +1,8 @@
+import { isFunction } from "../util/isFunction";
+import { isString } from "../util/isString";
+export function invokeCallback(instance, callback, ...args) {
+    if (isString(callback))
+        return instance.invokeControllerMethod(callback, ...args);
+    if (isFunction(callback))
+        return callback(...args);
+}

package/build/hooks/invokeCallback.spec.d.ts

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

package/build/hooks/invokeCallback.spec.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "cx/jsx-runtime";
+import assert from "assert";
+import { Store } from "../data/Store";
+import { createFunctionalComponent } from "../ui/createFunctionalComponent";
+import { createTestRenderer } from "../util/test/createTestRenderer";
+import { invokeCallback } from "./invokeCallback";
+describe("invokeCallback", () => {
+    it("works with functions", () => {
+        const FComp = createFunctionalComponent(({ onTest }) => {
+            invokeCallback(null, onTest, "works");
+            return (_jsx("cx", { children: _jsx("div", {}) }));
+        });
+        let store = new Store();
+        let value;
+        const component = createTestRenderer(store, {
+            type: FComp,
+            onTest: (v) => {
+                value = v;
+            },
+        });
+        component.toJSON();
+        assert.equal(value, "works");
+    });
+    it("works with controller methods", () => {
+        const FComp = createFunctionalComponent(({ onTest }) => {
+            return (_jsx("cx", { children: _jsx("div", { onExplore: (context, instance) => {
+                        invokeCallback(instance, onTest, "works");
+                    } }) }));
+        });
+        let store = new Store();
+        let value;
+        const component = createTestRenderer(store, {
+            type: FComp,
+            onTest: "onTest",
+            controller: {
+                onTest(v) {
+                    value = v;
+                },
+            },
+        });
+        component.toJSON();
+        assert.equal(value, "works");
+    });
+});

package/build/hooks/resolveCallback.d.ts

@@ -0,0 +1,2 @@
+import { Instance } from "../ui/Instance";
+export declare function resolveCallback(callback: string | ((...args: any[]) => any), instance?: Instance): ((...args: any[]) => any) | undefined;

package/build/hooks/resolveCallback.js

@@ -0,0 +1,13 @@
+import { isFunction } from "../util/isFunction";
+import { isString } from "../util/isString";
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+export function resolveCallback(callback, instance) {
+    if (isFunction(callback))
+        return callback;
+    if (isString(callback)) {
+        if (!instance)
+            instance = getCurrentInstance();
+        return (...args) => instance.invokeControllerMethod(callback, ...args);
+    }
+    return undefined;
+}

package/build/hooks/resolveCallback.spec.d.ts

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

package/build/hooks/resolveCallback.spec.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "cx/jsx-runtime";
+import assert from "assert";
+import { Store } from "../data/Store";
+import { createFunctionalComponent } from "../ui/createFunctionalComponent";
+import { createTestRenderer } from "../util/test/createTestRenderer";
+import { resolveCallback } from "./resolveCallback";
+describe("resolveCallback", () => {
+    it("works with functions", () => {
+        const FComp = createFunctionalComponent(({ onTest }) => {
+            let callback = resolveCallback(onTest);
+            assert(typeof callback === 'function');
+            callback("works");
+            return (_jsx("cx", { children: _jsx("div", {}) }));
+        });
+        let store = new Store();
+        let value;
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsx(FComp, { onTest: (v) => { value = v; } }) }));
+        component.toJSON();
+        assert.equal(value, "works");
+    });
+    it("works with controller methods", () => {
+        const FComp = createFunctionalComponent(({ onTest }) => {
+            let callback = resolveCallback(onTest);
+            assert(typeof callback === 'function');
+            return (_jsx("cx", { children: _jsx("div", { onInit: () => { callback("works"); } }) }));
+        });
+        let store = new Store();
+        let value;
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsx(FComp, { onTest: "onTest", controller: {
+                    onTest(v) { value = v; }
+                } }) }));
+        component.toJSON();
+        assert.equal(value, "works");
+    });
+});

package/build/hooks/store.d.ts

@@ -0,0 +1,11 @@
+import { Selector } from "../data/Selector";
+import { BindingObject } from "../data/Binding";
+import { Ref } from "../data/Ref";
+import { View } from "../data/View";
+import { GetSet, Prop } from "../ui/Prop";
+export declare function useStore(): View;
+export declare function useStoreMethods(): ReturnType<View["getMethods"]>;
+export type RefInput<T> = Prop<T> | Ref<T>;
+export declare function ref<T = any>(input: BindingObject): GetSet<T>;
+export declare function ref<T = any>(input: Ref<T>): GetSet<T>;
+export declare function ref<T = any>(input: Prop<T>): Selector<T>;

package/build/hooks/store.js

@@ -0,0 +1,38 @@
+import { isBindingObject } from "../data/Binding";
+import { expression } from "../data/Expression";
+import { getSelector } from "../data/getSelector";
+import { Ref } from "../data/Ref";
+import { stringTemplate } from "../data/StringTemplate";
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+import { hasFunctionAtKey, hasStringAtKey } from "../util/hasKey";
+import { isObject } from "../util/isObject";
+export function useStore() {
+    return getCurrentInstance().store;
+}
+export function useStoreMethods() {
+    return getCurrentInstance().store.getMethods();
+}
+export function ref(info) {
+    if (isObject(info)) {
+        if (isBindingObject(info))
+            return useStore().ref(info.bind, info.defaultValue);
+        if (hasFunctionAtKey(info, "get"))
+            return info;
+        if (hasFunctionAtKey(info, "memoize"))
+            return info;
+        if (hasStringAtKey(info, "expr")) {
+            let store = useStore();
+            let selector = expression(info.expr).memoize();
+            return new Ref({ get: () => selector(store.getData()), set: info.set });
+        }
+        if (hasStringAtKey(info, "tpl")) {
+            let store = useStore();
+            let selector = stringTemplate(info.tpl).memoize();
+            return new Ref({
+                get: () => selector(store.getData()),
+                set: info.set,
+            });
+        }
+    }
+    return getSelector(info);
+}

package/build/hooks/store.spec.d.ts

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

package/build/hooks/store.spec.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx } from "cx/jsx-runtime";
+import assert from "assert";
+import { createTestRenderer } from "src/util/test/createTestRenderer";
+import { computable } from "../data";
+import { Store } from "../data/Store";
+import { createFunctionalComponent } from "../ui/createFunctionalComponent";
+import { ref } from "./store";
+describe("ref", () => {
+    it("allows store references in functional components", () => {
+        const FComp = createFunctionalComponent(({}) => {
+            let testValue = ref({ bind: "x", defaultValue: 10 });
+            return (_jsx("cx", { children: _jsx("div", { text: testValue }) }));
+        });
+        let store = new Store();
+        const component = createTestRenderer(store, FComp);
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            children: ["10"],
+            props: {},
+        });
+    });
+    it("can be used to adapt any prop passed to a functional component", () => {
+        const FComp = createFunctionalComponent(({ value }) => {
+            return (_jsx("cx", { children: _jsx("div", { text: computable(ref(value), (value) => `x${value}`) }) }));
+        });
+        let store = new Store({ data: { value: 100 } });
+        function test(value, expectation) {
+            const component = createTestRenderer(store, _jsx(FComp, { value: value }));
+            let tree = component.toJSON();
+            assert.deepEqual(tree, {
+                type: "div",
+                children: [expectation],
+                props: {},
+            });
+        }
+        test({ bind: "value" }, "x100");
+        test({ expr: "{value}" }, "x100");
+        test({ tpl: "{value:n;2}" }, "x100.00");
+        test(200, "x200");
+        test(() => 500, "x500");
+        test(computable("value", (value) => value + 100), "x200");
+        test(null, "xnull");
+        test(undefined, "xundefined");
+        test(0, "x0");
+        test(false, "xfalse");
+    });
+});

package/build/hooks/useEffect.d.ts

@@ -0,0 +1,2 @@
+export declare function useEffect(callback: () => (() => void) | void): void;
+export declare function useCleanup(cleanupCallback: () => void): () => void;

package/build/hooks/useEffect.js

@@ -0,0 +1,13 @@
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+export function useEffect(callback) {
+    let destroyCallback = callback();
+    if (destroyCallback)
+        getCurrentInstance().subscribeOnDestroy(destroyCallback);
+}
+export function useCleanup(cleanupCallback) {
+    let unsubscribe = getCurrentInstance().subscribeOnDestroy(cleanupCallback);
+    return () => {
+        unsubscribe();
+        cleanupCallback();
+    };
+}

package/build/hooks/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: () => void, timeout: number): () => void;

package/build/hooks/useInterval.js

@@ -0,0 +1,7 @@
+import { useCleanup } from "./useEffect";
+export function useInterval(callback, timeout) {
+    let timer = setInterval(callback, timeout);
+    return useCleanup(() => {
+        clearInterval(timer);
+    });
+}

package/build/hooks/useState.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from "../data/Ref";
+export declare function useState<T = any>(defaultValue?: T): Ref<T>;

package/build/hooks/useState.js

@@ -0,0 +1,17 @@
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+import { Ref } from "../data/Ref";
+let key = 0;
+export function useState(defaultValue) {
+    let instance = getCurrentInstance();
+    let storeKey = "_state" + ++key;
+    instance.setState({
+        [storeKey]: defaultValue,
+    });
+    return new Ref({
+        get: () => instance.state[storeKey],
+        set: (value) => {
+            instance.setState({ [storeKey]: value });
+            return true;
+        },
+    });
+}

package/build/hooks/useTrigger.d.ts

@@ -0,0 +1,3 @@
+import { ComputableSelector } from "../data/computable";
+export declare function addExploreCallback(callback: (...args: any[]) => any): () => void;
+export declare function useTrigger(args: ComputableSelector[], callback: (...args: any[]) => void, autoRun?: boolean): () => void;

package/build/hooks/useTrigger.js

@@ -0,0 +1,22 @@
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+import { isArray } from "../util/isArray";
+import { computable } from "../data/computable";
+import { useStore } from "./store";
+export function addExploreCallback(callback) {
+    let instance = getCurrentInstance();
+    if (!instance.computables)
+        instance.computables = [];
+    instance.computables.push(callback);
+    return () => {
+        if (instance.computables) {
+            instance.computables = instance.computables.filter((cb) => cb !== callback);
+        }
+    };
+}
+export function useTrigger(args, callback, autoRun) {
+    if (!isArray(args))
+        throw new Error("First argument to useTrigger should be an array.");
+    let store = useStore();
+    let selector = computable(...args, callback).memoize(!autoRun && store.getData());
+    return addExploreCallback(selector);
+}

package/build/hooks/useTrigger.spec.d.ts

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