ngx-axis-appforge 0.0.0-watch

package/fesm2022/ngx-axis-appforge-axis-components-table-helper.mjs

@@ -0,0 +1,650 @@
+import * as i0 from '@angular/core';
+import { Optional, Injectable, effect, signal, computed, InjectionToken, untracked } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i1$1 from 'ngx-axis-appforge/core';
+import { Subject, filter, map } from 'rxjs';
+
+class TableFieldDisplayService {
+    datePipe;
+    decimalPipe;
+    percentPipe;
+    scope;
+    constructor(datePipe, decimalPipe, percentPipe, scope) {
+        this.datePipe = datePipe;
+        this.decimalPipe = decimalPipe;
+        this.percentPipe = percentPipe;
+        this.scope = scope;
+    }
+    fieldDisplayCache = new Map();
+    clearCache(field) {
+        if (!field) {
+            this.fieldDisplayCache.clear();
+        }
+        else {
+            this.fieldDisplayCache.delete(field);
+        }
+    }
+    getFieldDisplayText(field, row) {
+        if (["axis-components/text", "axis-components/badge"].includes(field.child()?.component)) {
+            if (!this.fieldDisplayCache.has(field.field())) {
+                this.fieldDisplayCache.set(field.field(), new Map());
+            }
+            if (!this.fieldDisplayCache.get(field.field()).has(row[field.field()])) {
+                const child = this.scope?.snapshotOptions(field.child(), { row });
+                let text;
+                switch (child.component) {
+                    case "axis-components/text":
+                        switch (child.transfer) {
+                            case "date":
+                                if (child.data) {
+                                    text = this.datePipe.transform(new Date(child.data), child.dateFormat);
+                                }
+                                else {
+                                    text = '';
+                                }
+                                break;
+                            case "number":
+                                text = this.decimalPipe.transform(child.data, this.getDigitsInfo(child));
+                                break;
+                            case "percent":
+                                text = this.percentPipe.transform(child.data, this.getDigitsInfo(child));
+                                break;
+                            case "deepObj":
+                                text = this.getDeepObjectValue(child);
+                                break;
+                            default:
+                                text = child.data;
+                                break;
+                        }
+                        break;
+                    case "axis-components/badge":
+                        text = child.text;
+                        break;
+                }
+                this.fieldDisplayCache.get(field.field()).set(row[field.field()], text);
+            }
+            return this.fieldDisplayCache.get(field.field()).get(row[field.field()]);
+        }
+        return row[field.field()];
+    }
+    getDigitsInfo(options) {
+        return `${options.integerMinLength}.${options.decimalRange[0]}-${options.decimalRange[1]}`;
+    }
+    getDeepObjectValue(options) {
+        if (options.objPath) {
+            const patharr = options.objPath.split(".").map(p => p.trim());
+            let outValue = options.data;
+            for (let p of patharr) {
+                if (Array.isArray(outValue)) {
+                    outValue = outValue?.[+p];
+                }
+                else {
+                    outValue = outValue?.[p];
+                }
+            }
+            return outValue;
+        }
+        return options.data;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: TableFieldDisplayService, deps: [{ token: i1.DatePipe }, { token: i1.DecimalPipe }, { token: i1.PercentPipe }, { token: i1$1.ScopeDirective, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: TableFieldDisplayService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: TableFieldDisplayService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.DatePipe }, { type: i1.DecimalPipe }, { type: i1.PercentPipe }, { type: i1$1.ScopeDirective, decorators: [{
+                    type: Optional
+                }] }] });
+
+class TableService {
+    fieldDisplayService;
+    constructor(fieldDisplayService) {
+        this.fieldDisplayService = fieldDisplayService;
+        effect(() => {
+            if (this.ready()) {
+                this.refreshFieldControls();
+            }
+        });
+        effect(() => {
+            if (this.ready() && this.useBackEndPaging() && this.data()) {
+                this.pageIndex.set(this.data().page_index + 1);
+                if (this.data()?.query_total) {
+                    this.hasTotal = true;
+                    this.rowtotal.set(this.data().total);
+                }
+                this.addCursorMark();
+            }
+        });
+    }
+    ready = signal(false, ...(ngDevMode ? [{ debugName: "ready" }] : []));
+    data;
+    options;
+    fields;
+    getRow;
+    cacheFilterItem;
+    useBackEndPaging = computed(() => this.options.showPagination() && this.options.useBackEndPaging(), ...(ngDevMode ? [{ debugName: "useBackEndPaging" }] : []));
+    rows = computed(() => this.useBackEndPaging() ? this.data()?.rows : this.data(), ...(ngDevMode ? [{ debugName: "rows" }] : []));
+    pageIndex = signal(1, ...(ngDevMode ? [{ debugName: "pageIndex" }] : []));
+    hasTotal = false;
+    rowtotal = signal(0, ...(ngDevMode ? [{ debugName: "rowtotal" }] : []));
+    displayFields = computed(() => {
+        if (!this.ready()) {
+            return [];
+        }
+        return this.fields().filter(f => f.inuse());
+    }, ...(ngDevMode ? [{ debugName: "displayFields" }] : []));
+    fieldsControlsMap = signal({}, ...(ngDevMode ? [{ debugName: "fieldsControlsMap" }] : []));
+    filedsFilterItemsCache = new Map();
+    leaderFieldWidth = computed(() => this.buildLeaderFieldWidth(), ...(ngDevMode ? [{ debugName: "leaderFieldWidth" }] : []));
+    pageSizeOptions = computed(() => this.options.pageSizeOptions().split(",").map(size => +size), ...(ngDevMode ? [{ debugName: "pageSizeOptions" }] : []));
+    pageCursorMarks = new Map();
+    pageCursorMarkIndexs = [];
+    init(opts) {
+        this.data = opts.data;
+        this.options = opts.options;
+        this.fields = opts.fields;
+        this.getRow = opts.getRow;
+        this.cacheFilterItem = opts.cacheFilterItem ?? true;
+        this.ready.set(true);
+    }
+    refreshFieldControls(f) {
+        if (!this.cacheFilterItem) {
+            if (!f) {
+                this.filedsFilterItemsCache.clear();
+            }
+            else {
+                this.filedsFilterItemsCache.delete(f);
+            }
+            this.fieldDisplayService.clearCache(f);
+        }
+        const res = {};
+        for (const field of this.displayFields()) {
+            if (f && field.field() != f) {
+                continue;
+            }
+            res[field.field()] = {};
+            if (!this.options.useBackEndPaging() && field.filterAble()) {
+                if (!this.filedsFilterItemsCache.has(field.field())) {
+                    this.filedsFilterItemsCache.set(field.field(), new Map());
+                }
+                const filterItemsCache = this.filedsFilterItemsCache.get(field.field());
+                for (let row of this.rows() ?? []) {
+                    if (this.getRow) {
+                        row = this.getRow(row);
+                    }
+                    const value = row[field.field()];
+                    if (!filterItemsCache.has(value)) {
+                        filterItemsCache.set(value, { value, text: this.fieldDisplayService.getFieldDisplayText(field, row) });
+                    }
+                }
+                res[field.field()].filterItems = Array.from(filterItemsCache.values());
+                res[field.field()].filterFn = (fd, row) => {
+                    if (this.getRow) {
+                        row = this.getRow(row);
+                    }
+                    if (fd instanceof Array) {
+                        return fd.includes(row[field.field()]);
+                    }
+                    else {
+                        return fd == row[field.field()];
+                    }
+                };
+            }
+            if (field.sortAble()) {
+                if (this.useBackEndPaging()) {
+                    res[field.field()].sortFn = true;
+                }
+                else {
+                    if (this.rows()?.map(row => this.getRow ? this.getRow(row) : row).some((row) => row[field.field()] != undefined && typeof (row[field.field()]) == "number")) {
+                        res[field.field()].sortFn = (a, b) => {
+                            if (this.getRow) {
+                                a = this.getRow(a);
+                                b = this.getRow(b);
+                            }
+                            return a[field.field()] - b[field.field()];
+                        };
+                    }
+                    else {
+                        res[field.field()].sortFn = (a, b) => {
+                            if (this.getRow) {
+                                a = this.getRow(a);
+                                b = this.getRow(b);
+                            }
+                            return ((a[field.field()] || "") + "").localeCompare(b[field.field()]);
+                        };
+                    }
+                }
+            }
+        }
+        if (f) {
+            this.fieldsControlsMap.set({
+                ...this.fieldsControlsMap(),
+                ...res
+            });
+        }
+        else {
+            this.fieldsControlsMap.set(res);
+        }
+    }
+    filterChange(field, value) {
+        for (const item of this.filedsFilterItemsCache.get(field).values()) {
+            item.byDefault = value != null && (Array.isArray(value) ? value.includes(item.value) : item.value == value);
+        }
+    }
+    buildLeaderFieldWidth() {
+        if (!this.ready()) {
+            return 0;
+        }
+        switch (this.options.size()) {
+            case "small":
+                return 45;
+            case "middle":
+                return 50;
+            default:
+                return 65;
+        }
+    }
+    addCursorMark() {
+        const { cursor_mark } = this.data();
+        if (cursor_mark) {
+            const { page_index } = cursor_mark;
+            if (!this.pageCursorMarks.has(page_index)) {
+                const i = this.pageCursorMarkIndexs.findIndex(i => i > page_index);
+                if (i == -1) {
+                    this.pageCursorMarkIndexs.push(page_index);
+                }
+                else if (this.pageCursorMarkIndexs[i] > page_index) {
+                    this.pageCursorMarkIndexs.splice(i, 0, page_index);
+                }
+            }
+            this.pageCursorMarks.set(page_index, cursor_mark);
+        }
+    }
+    getNearestCursorMark() {
+        if (this.pageCursorMarkIndexs.length == 0) {
+            return null;
+        }
+        const pageIndex = this.pageIndex() - 1;
+        const index = this.pageCursorMarkIndexs.findIndex(i => i >= pageIndex);
+        let leftIndex, rightIndex;
+        if (index == -1) {
+            leftIndex = this.pageCursorMarkIndexs.length - 1;
+        }
+        else if (this.pageCursorMarkIndexs[index] == pageIndex) {
+            leftIndex = index - 1;
+            rightIndex = index + 1;
+        }
+        else {
+            leftIndex = index - 1;
+            rightIndex = index;
+        }
+        const left = leftIndex != undefined ? this.pageCursorMarkIndexs[leftIndex] : undefined;
+        const right = rightIndex != undefined ? this.pageCursorMarkIndexs[rightIndex] : undefined;
+        let nearstIndex;
+        if (left != undefined && right != undefined) {
+            nearstIndex = pageIndex - left <= right - pageIndex ? left : right;
+        }
+        else if (left != undefined) {
+            nearstIndex = left;
+        }
+        else if (right != undefined) {
+            nearstIndex = right;
+        }
+        else {
+            return null;
+        }
+        return this.pageCursorMarks.get(nearstIndex);
+    }
+    clearCursorMarks() {
+        this.pageCursorMarkIndexs = [];
+        this.pageCursorMarks.clear();
+    }
+    get backEndPageParams() {
+        return {
+            use_page: true,
+            page_index: this.pageIndex() - 1,
+            page_size: this.options.pageSize(),
+            query_total: !this.hasTotal,
+            cursor_mark: this.getNearestCursorMark(),
+            order_by: this.displayFields().filter(f => f.sortAble() && f.sortOrder() != null).map(f => ({
+                column: f.field(),
+                desc_order: f.sortOrder() == "descend"
+            }))
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: TableService, deps: [{ token: TableFieldDisplayService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: TableService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: TableService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: TableFieldDisplayService }] });
+
+const AXIS_TABLE_SELECT_TOKEN = new InjectionToken('axis.tableSelect');
+var ChangeScene;
+(function (ChangeScene) {
+    ChangeScene[ChangeScene["userClick"] = 0] = "userClick";
+    ChangeScene[ChangeScene["linkage"] = 1] = "linkage";
+})(ChangeScene || (ChangeScene = {}));
+class SelectService {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    ready = signal(false, ...(ngDevMode ? [{ debugName: "ready" }] : []));
+    options;
+    keyField;
+    data;
+    changeSubject = new Subject();
+    parent;
+    subSelectKeyFun;
+    registToParent = false;
+    headerChecked = signal("none", ...(ngDevMode ? [{ debugName: "headerChecked" }] : []));
+    setOfCheckedId = signal(new Set(), ...(ngDevMode ? [{ debugName: "setOfCheckedId" }] : []));
+    setOfIndeterminateId = signal(new Set(), ...(ngDevMode ? [{ debugName: "setOfIndeterminateId" }] : []));
+    setOfDisabledId = computed(() => this.buildDisabledId(), ...(ngDevMode ? [{ debugName: "setOfDisabledId" }] : []));
+    subs = [];
+    subSelects = new Map();
+    init(opts) {
+        this.options = opts.options;
+        this.keyField = opts.keyField;
+        this.data = opts.data;
+        this.close();
+        if (opts.onSelectedChange) {
+            this.subs.push(this.changeSubject.subscribe(_ => {
+                opts.onSelectedChange(this.setOfCheckedId());
+            }));
+        }
+        this.parent = opts.parent;
+        if (opts.scope) {
+            this.scope = opts.scope;
+        }
+        this.subSelectKeyFun = opts.subSelectKeyFun;
+        this.initCheckboxLinkageForExpand();
+        this.ready.set(true);
+        this.registToParent = opts.registToParent ?? false;
+    }
+    findSubSelect(key) {
+        return this.subSelects.get(key);
+    }
+    getSubSelectKey(scope) {
+        if (this.subSelectKeyFun) {
+            return this.subSelectKeyFun(scope);
+        }
+        return this.scope.snapshot("row")[this.keyField];
+    }
+    initCheckboxLinkageForExpand() {
+        if (this.options.showCheckbox() && !this.options.singleCheck() && this.options.checkboxLinkageForExpand() && this.parent && this.scope) {
+            const keyInParent = this.parent.getSubSelectKey(this.scope);
+            untracked(() => {
+                if (this.registToParent) {
+                    this.parent.subSelects.set(keyInParent, this);
+                }
+                this.subs.push(this.parent.changeSubject.pipe(filter(s => s != ChangeScene.linkage), map(_ => {
+                    if (this.parent.setOfCheckedId().has(keyInParent)) {
+                        if (this.parent.setOfIndeterminateId().has(keyInParent)) {
+                            return "indeterminate";
+                        }
+                        else {
+                            return "checked";
+                        }
+                    }
+                    else {
+                        return "none";
+                    }
+                })).subscribe(header => {
+                    if (header != 'indeterminate' && this.headerChecked() != header) {
+                        this.onAllChecked(header == "checked", ChangeScene.linkage);
+                    }
+                }));
+                this.subs.push(this.changeSubject.pipe(filter(s => s != ChangeScene.linkage), map(_ => this.headerChecked()))
+                    .subscribe(header => {
+                    const checked = header != "none";
+                    const indeterminate = header == "indeterminate";
+                    if (checked != this.parent.setOfCheckedId().has(keyInParent) || indeterminate != this.parent.setOfIndeterminateId().has(keyInParent)) {
+                        this.parent.updateCheckedSet(keyInParent, checked, indeterminate);
+                        this.parent.refreshCheckedStatus(ChangeScene.linkage);
+                    }
+                }));
+            });
+        }
+    }
+    buildDisabledId() {
+        if (this.options.disableCheckboxFn()) {
+            const args = this.scope?.snapshotAll() ?? {};
+            return new Set(this.data()?.filter(row => this.scope?.runFnWithSnapshot(this.options.disableCheckboxFn(), Object.assign({}, args, { row })))
+                .map(row => row[this.keyField]));
+        }
+        return new Set();
+    }
+    onAllChecked(checked, scene = ChangeScene.userClick) {
+        this.data()?.filter(row => !this.setOfDisabledId().has(row[this.keyField]))?.forEach(row => this.updateCheckedSet(row[this.keyField], checked, false));
+        this.refreshCheckedStatus(scene);
+    }
+    toggleChecked(row, scene = ChangeScene.userClick) {
+        if (this.options.showCheckbox() && !this.setOfDisabledId().has(row[this.keyField])) {
+            this.onItemChecked(row, !this.setOfCheckedId().has(row[this.keyField]), scene);
+        }
+    }
+    onItemChecked(row, checked, scene = ChangeScene.userClick) {
+        this.updateCheckedSet(row[this.keyField], checked);
+        this.refreshCheckedStatus(scene);
+    }
+    onSetItemsChecked(rows, scene = ChangeScene.userClick) {
+        this.setOfCheckedId().clear();
+        this.setOfIndeterminateId().clear();
+        rows.forEach(row => this.updateCheckedSet(row[this.keyField], true));
+        this.refreshCheckedStatus(scene);
+    }
+    updateCheckedSet(key, checked, indeterminate = false) {
+        if (checked && this.options.singleCheck()) {
+            this.setOfCheckedId().clear();
+        }
+        indeterminate = checked && indeterminate && !this.options.singleCheck();
+        if (indeterminate && !this.setOfIndeterminateId().has(key)) {
+            this.setOfIndeterminateId().add(key);
+        }
+        else if (!indeterminate && this.setOfIndeterminateId().has(key)) {
+            this.setOfIndeterminateId().delete(key);
+        }
+        if (checked && !this.setOfCheckedId().has(key)) {
+            this.setOfCheckedId().add(key);
+        }
+        else if (!checked && this.setOfCheckedId().has(key)) {
+            this.setOfCheckedId().delete(key);
+        }
+    }
+    refreshCheckedStatus(scene) {
+        const listOfEnabledData = this.data()?.filter(row => !this.setOfDisabledId().has(row[this.keyField])) ?? [];
+        const checked = listOfEnabledData.length > 0 && listOfEnabledData.every(row => this.setOfCheckedId().has(row[this.keyField]) && !this.setOfIndeterminateId().has(row[this.keyField]));
+        if (checked) {
+            this.headerChecked.set("checked");
+        }
+        else {
+            const indeterminate = listOfEnabledData.some(row => this.setOfCheckedId().has(row[this.keyField]) || this.setOfIndeterminateId().has(row[this.keyField])) && !checked;
+            this.headerChecked.set(indeterminate ? "indeterminate" : "none");
+        }
+        this.setOfCheckedId.set(new Set([...this.setOfCheckedId()]));
+        this.setOfIndeterminateId.set(new Set([...this.setOfIndeterminateId()]));
+        this.changeSubject.next(scene);
+    }
+    getSelectedData() {
+        return this.data()?.filter(row => this.setOfCheckedId().has(row[this.keyField]));
+    }
+    close() {
+        for (const sub of this.subs) {
+            sub.unsubscribe();
+        }
+        for (const sub of this.subSelects.values()) {
+            sub.close();
+        }
+        this.subs = [];
+        this.subSelects.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: SelectService, deps: [{ token: i1$1.ScopeDirective, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: SelectService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: SelectService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.ScopeDirective, decorators: [{
+                    type: Optional
+                }] }] });
+
+class ExpandService {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    options;
+    keyField;
+    data;
+    expandedSet = new Set();
+    nodeMap = computed(() => this.buildNodeMap(), ...(ngDevMode ? [{ debugName: "nodeMap" }] : []));
+    init(opts) {
+        this.options = opts.options;
+        this.keyField = opts.keyField;
+        this.data = opts.data;
+    }
+    buildNodeMap() {
+        const nodeMap = new Map();
+        if (this.options.showExpand() && this.options.expandMode() == "tree") {
+            this.data()?.forEach((row) => {
+                this.buildNodeMapForRow(row, nodeMap);
+            });
+        }
+        return nodeMap;
+    }
+    onExpandChange(key, checked) {
+        if (checked) {
+            this.expandedSet.add(key);
+        }
+        else {
+            this.expandedSet.delete(key);
+        }
+    }
+    buildNodeMapForRow(row, nodeMap, parentLevel = 0) {
+        const node = {
+            level: parentLevel + 1,
+            node: row,
+            children: []
+        };
+        nodeMap.set(row[this.keyField], node);
+        if (this.options.showExpand() && this.options.expandMode() == "tree") {
+            let children;
+            if (this.options.treeChildrenFun()) {
+                children = this.scope?.runFnWithSnapshot(this.options.treeChildrenFun(), { row });
+            }
+            else {
+                children = row.children;
+            }
+            if (children?.length) {
+                node.children = children;
+                children.forEach(child => {
+                    this.buildNodeMapForRow(child, nodeMap, node.level);
+                });
+            }
+        }
+    }
+    getListForExpanded(row) {
+        const key = row[this.keyField];
+        let res = [row];
+        if (this.options.showExpand() && this.options.expandMode() == "tree" && this.nodeMap().get(key)?.children?.length && this.expandedSet.has(key)) {
+            res = res.concat(this.nodeMap().get(key).children);
+        }
+        return res;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: ExpandService, deps: [{ token: i1$1.ScopeDirective, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: ExpandService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: ExpandService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.ScopeDirective, decorators: [{
+                    type: Optional
+                }] }] });
+
+class StatisticService {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    ready = signal(false, ...(ngDevMode ? [{ debugName: "ready" }] : []));
+    options;
+    data;
+    fields;
+    getRow;
+    hasStatistic = false;
+    statisticMap = computed(() => this.buildStatisticMap(), ...(ngDevMode ? [{ debugName: "statisticMap" }] : []));
+    init(opts) {
+        this.options = opts.options;
+        this.data = opts.data;
+        this.fields = opts.fields;
+        this.getRow = opts.getRow;
+        this.ready.set(true);
+    }
+    buildStatisticMap() {
+        if (!this.ready()) {
+            return {};
+        }
+        let res = {};
+        if (this.options.showStatistic() && this.data()) {
+            if (this.options.showPagination() && this.options.useBackEndPaging()) {
+                res = this.data().statistic_result;
+            }
+            else {
+                for (const f of this.fields().filter(r => r.statisticAble())) {
+                    let num;
+                    for (let i = 0; i < (this.data() ?? []).length; i++) {
+                        let row = this.data()[i];
+                        if (this.getRow) {
+                            row = this.getRow(row);
+                        }
+                        if (f.statisticType() == "sum" || f.statisticType() == "average") {
+                            num = (num ?? 0) + row[f.field()];
+                        }
+                        else if (f.statisticType() == "max") {
+                            num = Math.max(num ?? Number.MIN_SAFE_INTEGER, row[f.field()]);
+                        }
+                        else if (f.statisticType() == "min") {
+                            num = Math.min(num ?? Number.MAX_SAFE_INTEGER, row[f.field()]);
+                        }
+                        else if (f.statisticType() == "custom" && f.statisticFn()) {
+                            num = this.scope?.runFnWithSnapshot(f.statisticFn(), { result: num, index: i, row: row, value: row[f.field()] });
+                        }
+                    }
+                    if (f.statisticType() == "average" && this.data().length > 0) {
+                        num = (num ?? 0) / this.data().length;
+                    }
+                    if (f.statisticType() == "sum" && this.data().length == 0) {
+                        num = 0;
+                    }
+                    res[f.field()] = num;
+                }
+            }
+        }
+        return res;
+    }
+    get backEndPageParams() {
+        const res = {
+            query_statistic: !this.hasStatistic && this.options.showStatistic() && this.options.showPagination() && this.options.useBackEndPaging()
+        };
+        if (res.query_statistic) {
+            res.statistic_options = {};
+            for (const f of this.fields().filter(r => r.statisticAble() && r.statisticType() != "custom")) {
+                res.statistic_options[f.field()] = f.statisticType();
+            }
+        }
+        return res;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: StatisticService, deps: [{ token: i1$1.ScopeDirective, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: StatisticService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: StatisticService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.ScopeDirective, decorators: [{
+                    type: Optional
+                }] }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXIS_TABLE_SELECT_TOKEN, ChangeScene, ExpandService, SelectService, StatisticService, TableFieldDisplayService, TableService };
+//# sourceMappingURL=ngx-axis-appforge-axis-components-table-helper.mjs.map