cx 26.0.1 → 26.0.3

package/build/ui/adapter/GroupAdapter.d.ts

@@ -0,0 +1,57 @@
+import { ArrayAdapter, ArrayAdapterConfig, RecordStoreCache } from "./ArrayAdapter";
+import { DataAdapterRecord } from "./DataAdapter";
+import { Grouper } from "../../data/Grouper";
+import { RenderingContext } from "../RenderingContext";
+import { Instance } from "../Instance";
+import { View } from "../../data/View";
+import { Prop, SortDirection, StructuredProp } from "../Prop";
+export interface GroupKey {
+    [field: string]: Prop<any> | {
+        value: Prop<any>;
+        direction: SortDirection;
+    };
+}
+export interface GroupingConfig {
+    key: GroupKey;
+    aggregates?: StructuredProp;
+    text?: Prop<string>;
+    includeHeader?: boolean;
+    includeFooter?: boolean;
+    comparer?: ((a: any, b: any) => number) | null;
+    header?: any;
+    footer?: any;
+}
+export interface ResolvedGrouping extends GroupingConfig {
+    grouper: Grouper;
+}
+export interface GroupData {
+    $name: string;
+    $level: number;
+    $records: DataAdapterRecord<any>[];
+    $key: string;
+    [key: string]: any;
+}
+export interface GroupAdapterRecord<T = any> extends DataAdapterRecord<T> {
+    group?: GroupData;
+    grouping?: ResolvedGrouping;
+    level?: number;
+}
+export interface GroupAdapterConfig extends ArrayAdapterConfig {
+    aggregates?: StructuredProp;
+    groupRecordsAlias?: string;
+    groupRecordsName?: string;
+    groupings?: GroupingConfig[] | null;
+    groupName?: string;
+}
+export declare class GroupAdapter<T = any> extends ArrayAdapter<T> {
+    aggregates?: StructuredProp;
+    groupRecordsAlias?: string;
+    groupRecordsName?: string;
+    groupings?: ResolvedGrouping[] | null;
+    groupName: string;
+    constructor(config?: GroupAdapterConfig);
+    init(): void;
+    getRecords(context: RenderingContext, instance: Instance & Partial<RecordStoreCache>, records: T[], parentStore: View): DataAdapterRecord<T>[];
+    protected processLevel(keys: any[], records: DataAdapterRecord<T>[], result: DataAdapterRecord<T>[], parentStore: View): void;
+    groupBy(groupings: GroupingConfig[] | null): void;
+}

package/build/ui/adapter/GroupAdapter.js

@@ -0,0 +1,137 @@
+import { ArrayAdapter } from "./ArrayAdapter";
+import { ReadOnlyDataView } from "../../data/ReadOnlyDataView";
+import { Grouper } from "../../data/Grouper";
+import { isArray } from "../../util/isArray";
+import { getComparer } from "../../data/comparer";
+import { Culture } from "../Culture";
+import { isDataRecord } from "../../util";
+export class GroupAdapter extends ArrayAdapter {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        super.init();
+        if (this.groupRecordsAlias) {
+            this.groupRecordsName = this.groupRecordsAlias;
+        }
+        if (this.groupings) {
+            this.groupBy(this.groupings);
+        }
+    }
+    getRecords(context, instance, records, parentStore) {
+        let result = super.getRecords(context, instance, records, parentStore);
+        if (this.groupings) {
+            const groupedResults = [];
+            this.processLevel([], result, groupedResults, parentStore);
+            result = groupedResults;
+        }
+        return result;
+    }
+    processLevel(keys, records, result, parentStore) {
+        const level = keys.length;
+        const inverseLevel = this.groupings.length - level;
+        if (inverseLevel === 0) {
+            if (this.preserveOrder && this.sorter)
+                records = this.sorter(records);
+            for (let i = 0; i < records.length; i++) {
+                records[i].store.setStore(parentStore);
+                result.push(records[i]);
+            }
+            return;
+        }
+        const grouping = this.groupings[level];
+        const { grouper } = grouping;
+        grouper.reset();
+        grouper.processAll(records);
+        let results = grouper.getResults();
+        if (grouping.comparer && !this.preserveOrder) {
+            results.sort(grouping.comparer);
+        }
+        results.forEach((gr) => {
+            keys.push(gr.key);
+            const key = keys.map(serializeKey).join("|");
+            const $group = {
+                ...gr.key,
+                ...gr.aggregates,
+                $name: gr.name,
+                $level: inverseLevel,
+                $records: gr.records || [],
+                $key: key,
+            };
+            const data = {
+                [this.recordName]: gr.records.length > 0 ? gr.records[0].data : null,
+                [this.groupName]: $group,
+            };
+            const groupStore = new ReadOnlyDataView({
+                store: parentStore,
+                data,
+                immutable: this.immutable,
+            });
+            const group = {
+                key,
+                data: data,
+                group: $group,
+                grouping,
+                store: groupStore,
+                level: inverseLevel,
+            };
+            if (grouping.includeHeader !== false) {
+                result.push({
+                    ...group,
+                    type: "group-header",
+                    key: "header:" + group.key,
+                });
+            }
+            this.processLevel(keys, gr.records, result, groupStore);
+            if (grouping.includeFooter !== false) {
+                result.push({
+                    ...group,
+                    type: "group-footer",
+                    key: "footer:" + group.key,
+                });
+            }
+            keys.pop();
+        });
+    }
+    groupBy(groupings) {
+        if (!groupings) {
+            this.groupings = null;
+        }
+        else if (isArray(groupings)) {
+            this.groupings = groupings;
+            this.groupings.forEach((g) => {
+                const groupSorters = [];
+                const key = {};
+                for (const name in g.key) {
+                    const keyConfig = g.key[name];
+                    if (!keyConfig || typeof keyConfig !== "object" || !("value" in keyConfig)) {
+                        g.key[name] = { value: keyConfig, direction: "ASC" };
+                    }
+                    const resolvedKey = g.key[name];
+                    key[name] = resolvedKey.value;
+                    groupSorters.push({
+                        field: name,
+                        direction: resolvedKey.direction,
+                    });
+                }
+                g.grouper = new Grouper(key, { ...this.aggregates, ...g.aggregates }, (r) => r.store.getData(), g.text);
+                if (g.comparer == null && groupSorters.length > 0) {
+                    g.comparer = getComparer(groupSorters, (x) => x.key, this.sortOptions ? Culture.getComparer(this.sortOptions) : undefined);
+                }
+            });
+        }
+        else {
+            throw new Error("Invalid grouping provided.");
+        }
+    }
+}
+GroupAdapter.prototype.groupName = "$group";
+GroupAdapter.prototype.preserveOrder = false;
+function serializeKey(data) {
+    if (isDataRecord(data)) {
+        return Object.keys(data)
+            .map((k) => serializeKey(data[k]))
+            .join(":");
+    }
+    return data?.toString() ?? "";
+}

package/build/ui/adapter/TreeAdapter.d.ts

@@ -0,0 +1,51 @@
+import { Accessor } from "../../data/getAccessor";
+import { ArrayAdapter, ArrayAdapterConfig, RecordStoreCache } from "./ArrayAdapter";
+import { DataAdapterRecord } from "./DataAdapter";
+import { RenderingContext } from "../RenderingContext";
+import { Instance } from "../Instance";
+import { View } from "../../data/View";
+import { Sorter } from "../Prop";
+export interface TreeNode {
+    $level?: number;
+    $expanded?: boolean;
+    $leaf?: boolean;
+    $loading?: boolean;
+    $loaded?: boolean;
+    [key: string]: any;
+}
+export interface ExpandedState {
+    current?: Set<string | number>;
+    next: Set<string | number>;
+}
+export interface TreeAdapterConfig extends ArrayAdapterConfig {
+    childrenField?: string;
+    expandedField?: string;
+    leafField?: string;
+    loadingField?: string;
+    loadedField?: string;
+    onLoadError?: (response: any) => void;
+    foldersFirst?: boolean;
+    hideRootNodes?: boolean;
+    restoreExpandedNodesOnLoad?: boolean;
+    load?: (context: RenderingContext, instance: Instance, data: TreeNode) => Promise<any[]> | any[];
+}
+export declare class TreeAdapter<T extends TreeNode = TreeNode> extends ArrayAdapter<T> {
+    childrenField: string;
+    expandedField: string;
+    leafField: string;
+    loadingField: string;
+    loadedField: string;
+    onLoadError?: (response: any) => void;
+    foldersFirst: boolean;
+    hideRootNodes: boolean;
+    restoreExpandedNodesOnLoad?: boolean;
+    load?: (context: RenderingContext, instance: Instance, data: T) => Promise<any[]> | any[];
+    protected childrenAccessor?: Accessor;
+    protected expandedState?: ExpandedState;
+    constructor(config?: TreeAdapterConfig);
+    init(): void;
+    mapRecords(context: RenderingContext, instance: Instance & Partial<RecordStoreCache>, data: T[], parentStore: View, recordsAccessor?: Accessor): DataAdapterRecord<T>[];
+    protected processList(context: RenderingContext, instance: Instance & Partial<RecordStoreCache>, level: number, parentKey: string, nodes: DataAdapterRecord<T>[], result: DataAdapterRecord<T>[]): void;
+    protected processNode(context: RenderingContext, instance: Instance & Partial<RecordStoreCache>, level: number, result: DataAdapterRecord<T>[], record: DataAdapterRecord<T>): void;
+    sort(sorters?: Sorter[]): void;
+}

package/build/ui/adapter/TreeAdapter.js

@@ -0,0 +1,98 @@
+import { getAccessor } from "../../data/getAccessor";
+import { isArray } from "../../util/isArray";
+import { ArrayAdapter } from "./ArrayAdapter";
+export class TreeAdapter extends ArrayAdapter {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        super.init();
+        this.childrenAccessor = getAccessor({ bind: `${this.recordName}.${this.childrenField}` });
+        if (this.restoreExpandedNodesOnLoad) {
+            if (!this.keyField) {
+                throw new Error("Stateful tree adapter requires keyField property to be specified on either Grid or data adapter.");
+            }
+            this.expandedState = {
+                next: new Set(),
+            };
+        }
+    }
+    mapRecords(context, instance, data, parentStore, recordsAccessor) {
+        const nodes = super.mapRecords(context, instance, data, parentStore, recordsAccessor);
+        const result = [];
+        if (this.restoreExpandedNodesOnLoad) {
+            this.expandedState = {
+                current: this.expandedState.next,
+                next: new Set(),
+            };
+        }
+        this.processList(context, instance, 0, "", nodes, result);
+        return result;
+    }
+    processList(context, instance, level, parentKey, nodes, result) {
+        nodes.forEach((record) => {
+            record.key = parentKey + record.key;
+            this.processNode(context, instance, level, result, record);
+        });
+    }
+    processNode(context, instance, level, result, record) {
+        const isHiddenRootNode = level === 0 && this.hideRootNodes;
+        if (!isHiddenRootNode) {
+            result.push(record);
+        }
+        const { data, store } = record;
+        const dataRecord = data;
+        dataRecord.$level = this.hideRootNodes ? level - 1 : level;
+        if (!dataRecord[this.leafField]) {
+            if (this.restoreExpandedNodesOnLoad && dataRecord[this.expandedField] == null) {
+                dataRecord[this.expandedField] = this.expandedState.current.has(dataRecord[this.keyField]);
+            }
+            if (dataRecord[this.expandedField] || isHiddenRootNode) {
+                if (this.restoreExpandedNodesOnLoad) {
+                    this.expandedState.next.add(dataRecord[this.keyField]);
+                }
+                if (dataRecord[this.childrenField]) {
+                    const childNodes = super.mapRecords(context, instance, dataRecord[this.childrenField], store, this.childrenAccessor);
+                    this.processList(context, instance, level + 1, record.key + ":", childNodes, result);
+                }
+                else if (this.load && !dataRecord[this.loadedField] && !dataRecord[this.loadingField]) {
+                    store.set(`${this.recordName}.${this.loadingField}`, true);
+                    const response = this.load(context, instance, data);
+                    Promise.resolve(response)
+                        .then((children) => {
+                        store.set(`${this.recordName}.${this.childrenField}`, children);
+                        store.set(`${this.recordName}.${this.loadedField}`, true);
+                        store.set(`${this.recordName}.${this.loadingField}`, false);
+                    })
+                        .catch((response) => {
+                        store.set(`${this.recordName}.${this.loadingField}`, false);
+                        if (this.onLoadError) {
+                            this.onLoadError(response);
+                        }
+                    });
+                }
+            }
+            else {
+                dataRecord[this.expandedField] = false;
+            }
+        }
+    }
+    sort(sorters) {
+        if (this.foldersFirst) {
+            if (!sorters || !isArray(sorters)) {
+                sorters = [];
+            }
+            sorters = [{ field: this.leafField, direction: "ASC" }, ...sorters];
+        }
+        super.sort(sorters);
+    }
+}
+TreeAdapter.prototype.childrenField = "$children";
+TreeAdapter.prototype.expandedField = "$expanded";
+TreeAdapter.prototype.leafField = "$leaf";
+TreeAdapter.prototype.loadingField = "$loading";
+TreeAdapter.prototype.loadedField = "$loaded";
+TreeAdapter.prototype.foldersFirst = true;
+TreeAdapter.prototype.isTreeAdapter = true;
+TreeAdapter.prototype.hideRootNodes = false;
+TreeAdapter.prototype.cacheByKeyField = false;

package/build/ui/adapter/TreeAdapter.spec.d.ts

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

package/build/ui/adapter/TreeAdapter.spec.js

@@ -0,0 +1,71 @@
+import { RenderingContext } from "../RenderingContext";
+import { Instance } from "../Instance";
+import { TreeAdapter } from "./TreeAdapter";
+import assert from "assert";
+import { Store } from "../../data";
+describe("TreeAdapter", () => {
+    it("properly expands records", () => {
+        let tree = new TreeAdapter({
+            childrenField: "children",
+            expandedField: "expanded",
+        });
+        let data = [
+            {
+                id: 1,
+                text: "1",
+                expanded: false,
+                children: [
+                    {
+                        id: 4,
+                        text: "4",
+                    },
+                ],
+            },
+            {
+                id: 2,
+                text: "2",
+                expanded: true,
+                children: [
+                    {
+                        id: 3,
+                        text: "3",
+                        expanded: true,
+                        children: [
+                            {
+                                id: 5,
+                                text: "5",
+                                expanded: true,
+                                children: [
+                                    {
+                                        id: 6,
+                                        text: "6",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: 7,
+                text: "7",
+                expanded: false,
+            },
+        ];
+        let store = new Store();
+        let records = tree.mapRecords(new RenderingContext(), new Instance(null, "1", null, store), data, store);
+        assert.equal(records.length, 6);
+        assert.equal(records[0].data.id, 1);
+        assert.equal(records[1].data.id, 2);
+        assert.equal(records[2].data.id, 3);
+        assert.equal(records[3].data.id, 5);
+        assert.equal(records[4].data.id, 6);
+        assert.equal(records[5].data.id, 7);
+        assert.equal(records[5].store.get("$record.id"), 7);
+        assert.equal(records[2].store.get("$record.id"), 3);
+        assert.equal(records[3].store.get("$record.id"), 5);
+        assert.equal(records[2].store.get("$record.id"), 3);
+        assert.equal(records[0].store.get("$record.id"), 1);
+        assert.equal(records[1].store.get("$record.id"), 2);
+    });
+});

package/build/ui/adapter/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DataAdapter';
+export * from './ArrayAdapter';
+export * from './GroupAdapter';
+export * from './TreeAdapter';

package/build/ui/adapter/index.js

@@ -0,0 +1,4 @@
+export * from './DataAdapter';
+export * from './ArrayAdapter';
+export * from './GroupAdapter';
+export * from './TreeAdapter';

package/build/ui/app/History.d.ts

@@ -0,0 +1,18 @@
+import { View } from "../../data/View";
+type NavigateConfirmationCallback = (state: any) => boolean | Promise<boolean>;
+export declare class History {
+    static store: View;
+    static urlBinding: string;
+    static hashBinding?: string;
+    static connect(store: View, urlBinding: string, hashBinding?: string): void;
+    static pushState(state: any, title: string | null, url: string): boolean;
+    static replaceState(state: any, title: string | null, url: string): boolean;
+    static reloadOnNextChange(): void;
+    static addNavigateConfirmation(callback: NavigateConfirmationCallback, permanent?: boolean): void;
+    static confirm(continueCallback: () => boolean, state: any): boolean;
+    static confirmAndNavigate(state: any, title: string | null, url: string, replace?: boolean): boolean;
+    static navigate(state: any, title: string | null, url: string, replace?: boolean): boolean;
+    static updateStore(href?: string): boolean;
+    static subscribe(callback: (url: string, op: string) => void): () => void;
+}
+export {};

package/build/ui/app/History.js

@@ -0,0 +1,109 @@
+import { Url } from "./Url";
+import { batchUpdatesAndNotify } from "../batchUpdates";
+import { SubscriberList } from "../../util/SubscriberList";
+let last = 0;
+let next = 1;
+let transitions = {};
+let subscribers = null;
+let reload = false;
+let navigateConfirmationCallback = null;
+let permanentNavigateConfirmation = false;
+export class History {
+    static store;
+    static urlBinding;
+    static hashBinding;
+    static connect(store, urlBinding, hashBinding) {
+        this.store = store;
+        this.urlBinding = urlBinding;
+        this.hashBinding = hashBinding;
+        this.updateStore();
+        window.onpopstate = () => {
+            this.updateStore();
+        };
+    }
+    static pushState(state, title, url) {
+        return this.confirmAndNavigate(state, title, url);
+    }
+    static replaceState(state, title, url) {
+        return this.navigate(state, title, url, true);
+    }
+    static reloadOnNextChange() {
+        reload = true;
+    }
+    static addNavigateConfirmation(callback, permanent = false) {
+        navigateConfirmationCallback = callback;
+        permanentNavigateConfirmation = permanent;
+    }
+    static confirm(continueCallback, state) {
+        if (!navigateConfirmationCallback)
+            return continueCallback();
+        let result = navigateConfirmationCallback(state);
+        Promise.resolve(result).then((value) => {
+            if (value) {
+                if (!permanentNavigateConfirmation)
+                    navigateConfirmationCallback = null;
+                continueCallback();
+            }
+        });
+        return false;
+    }
+    static confirmAndNavigate(state, title, url, replace) {
+        return this.confirm(() => this.navigate(state, title, url, replace), url);
+    }
+    static navigate(state, title, url, replace = false) {
+        url = Url.resolve(url);
+        if (!window.history.pushState || reload) {
+            window.location[replace ? "replace" : "assign"](url);
+            return true;
+        }
+        let transition;
+        let changed = false;
+        batchUpdatesAndNotify(() => {
+            changed = this.updateStore(url);
+            if (changed)
+                transitions[++last] = transition = {
+                    url,
+                    state,
+                    title,
+                    replace,
+                };
+        }, () => {
+            if (transition)
+                transition.completed = true;
+            //update history once the page is rendered and the title is set
+            while (transitions[next] && transitions[next].completed) {
+                let tr = transitions[next];
+                delete transitions[next];
+                next++;
+                if (tr.replace) {
+                    window.history.replaceState(tr.state, tr.title ?? "", tr.url);
+                    if (subscribers)
+                        subscribers.notify(tr.url, "replaceState");
+                }
+                else {
+                    window.history.pushState(tr.state, tr.title ?? "", tr.url);
+                    if (subscribers)
+                        subscribers.notify(tr.url, "pushState");
+                }
+            }
+        });
+        return changed;
+    }
+    static updateStore(href) {
+        let url = Url.unresolve(href || document.location.href);
+        let hash = null;
+        let hashIndex = url.indexOf("#");
+        if (hashIndex !== -1) {
+            hash = url.substring(hashIndex);
+            url = url.substring(0, hashIndex);
+        }
+        if (this.hashBinding)
+            this.store.set(this.hashBinding, hash);
+        return this.store.set(this.urlBinding, url);
+    }
+    static subscribe(callback) {
+        if (!subscribers)
+            subscribers = new SubscriberList();
+        return subscribers.subscribe(callback);
+    }
+}

package/build/ui/app/Url.d.ts

@@ -0,0 +1,13 @@
+export declare class Url {
+    static base: string;
+    static absoluteBase: string;
+    static resolve(path: string): string;
+    static absolute(path: string): string;
+    static unresolve(path: string): string;
+    static getAbsoluteBase(): string;
+    static isLocal(url: string): boolean;
+    static setBase(base: string): void;
+    static getOrigin(): string;
+    static getBaseFromScriptSrc(src: string, scriptPath: string | RegExp): string | false;
+    static setBaseFromScript(scriptPath: string | RegExp): void;
+}

package/build/ui/app/Url.js

@@ -0,0 +1,86 @@
+export class Url {
+    static base;
+    static absoluteBase;
+    static resolve(path) {
+        return path.replace("~/", this.base);
+    }
+    static absolute(path) {
+        return path.replace("~/", this.absoluteBase);
+    }
+    static unresolve(path) {
+        if (path.indexOf("~/") == 0)
+            return path;
+        const absBase = this.absoluteBase || "";
+        //handle paths like /app and /app/
+        if (path.length == absBase.length - 1 && absBase == path + "/")
+            return "~/";
+        if (path.indexOf(absBase) == 0)
+            return "~/" + path.substring(absBase.length);
+        return "~/" + path.substring(this.base.length);
+    }
+    static getAbsoluteBase() {
+        return this.absoluteBase;
+    }
+    static isLocal(url) {
+        const absBase = this.getAbsoluteBase();
+        return url.indexOf("~/") == 0 || url.indexOf(absBase) == 0 || url.indexOf(this.base) == 0;
+    }
+    static setBase(base) {
+        if (!base || base[base.length - 1] != "/")
+            base += "/";
+        this.base = base;
+        if (typeof window != "undefined")
+            this.absoluteBase = window.location.protocol + "//" + window.location.host + this.base;
+    }
+    static getOrigin() {
+        if (typeof window == "undefined")
+            return "";
+        return (window.location.protocol +
+            "//" +
+            window.location.hostname +
+            (window.location.port ? ":" + window.location.port : ""));
+    }
+    static getBaseFromScriptSrc(src, scriptPath) {
+        if (!(scriptPath instanceof RegExp))
+            scriptPath = getBasePathRegex(scriptPath);
+        let index = src.search(scriptPath);
+        if (index == -1)
+            return false;
+        let origin = this.getOrigin();
+        return src.substring(src.indexOf(origin) == 0 ? origin.length : 0, index);
+    }
+    static setBaseFromScript(scriptPath) {
+        const scripts = document.getElementsByTagName("script");
+        let base;
+        if (!(scriptPath instanceof RegExp))
+            scriptPath = getBasePathRegex(scriptPath);
+        for (let i = 0; i < scripts.length; i++) {
+            base = this.getBaseFromScriptSrc(scripts[i].src, scriptPath);
+            if (base) {
+                this.setBase(base);
+                return;
+            }
+        }
+        throw new Error(`Could not resolve url base from script matching '${scriptPath}'.`);
+    }
+}
+Url.setBase('/');
+function getBasePathRegex(str) {
+    let regex = "";
+    let start = 0;
+    if (str.indexOf("~/") == 0)
+        start = 2;
+    for (let i = start; i < str.length; i++) {
+        switch (str[i]) {
+            case ".":
+                regex += "\\.";
+                break;
+            case "*":
+                regex += ".*";
+                break;
+            default:
+                regex += str[i];
+        }
+    }
+    return new RegExp(regex + "(\\?.*)?$", "i");
+}

package/build/ui/app/Url.spec.d.ts

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