@servicetitan/table 22.1.0 → 22.1.3

package/dist/table-state.js

@@ -0,0 +1,1106 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { action, computed, observable, runInAction, makeObservable } from 'mobx';
+import { fromPromise } from 'mobx-utils';
+import { formStateToJS } from '@servicetitan/form';
+export function isGroupItem(item, groups) {
+    const field = item.field;
+    return !!field && groups.some(g => g.field === field);
+}
+function addAggregatesToGroups(groups, aggregates) {
+    return groups.map(group => (Object.assign(Object.assign({}, group), { aggregates })));
+}
+export class TableState {
+    constructor({ dataSource = null, pageSize, isRowUnselectable = () => false, selectionLimit = Infinity, getFormState, parent, getDetailTableState, initialState, alwaysEditable = false, } = {}) {
+        Object.defineProperty(this, "innerDataSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "getDetailTableState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "selectedIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "inEdit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "expandedIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "collapsedGroups", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "isRowUnselectable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // TODO: think about a better name
+        Object.defineProperty(this, "selectionLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "totalCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "filteredCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "selectedCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "unselectableCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "sort", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "aggregates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "innerGroup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "skip", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "pageSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tablePdfExport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "tableExcelExport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "alwaysEditable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fetchInitialData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => __awaiter(this, void 0, void 0, function* () {
+                if (!this.dataSource) {
+                    return;
+                }
+                const initial = (yield this.dataSource.getData({
+                    skip: this.skip,
+                    take: this.pageSize,
+                    filter: this.filter,
+                    sort: [...this.sort],
+                    group: [...this.group],
+                }));
+                runInAction(() => {
+                    this.totalCount = initial.total;
+                    this.filteredCount = initial.total;
+                    this.data = initial.data;
+                    this.unselectableCount = this.originalData.filter(this.isRowUnselectable).length;
+                    this.addPropertiesToRows(this.data);
+                });
+            })
+        });
+        Object.defineProperty(this, "handleFilterChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (ev) => {
+                this.fetchData({
+                    newFilter: ev.filter,
+                });
+            }
+        });
+        Object.defineProperty(this, "handleGroupChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (ev) => {
+                this.collapsedGroups = new Set();
+                this.fetchData({
+                    newGroup: ev.group,
+                });
+            }
+        });
+        Object.defineProperty(this, "handleExpandChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ({ dataItem, value }) => {
+                if (isGroupItem(dataItem, this.group)) {
+                    const { materializedPath } = dataItem;
+                    if (value) {
+                        this.collapsedGroups.delete(materializedPath);
+                    }
+                    else {
+                        this.collapsedGroups.add(materializedPath);
+                    }
+                }
+                else {
+                    if (!this.dataSource) {
+                        return;
+                    }
+                    if (!this.dataSource.idSelector) {
+                        throw 'missing idSelector in the data source';
+                    }
+                    const id = this.dataSource.idSelector(dataItem);
+                    if (value) {
+                        this.expandedIds.add(id);
+                    }
+                    else {
+                        this.expandedIds.delete(id);
+                    }
+                }
+                this.data = this.data.slice();
+            }
+        });
+        Object.defineProperty(this, "handleSortChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (ev) => {
+                this.fetchData({
+                    newSort: ev.sort,
+                });
+            }
+        });
+        Object.defineProperty(this, "handlePageChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (ev) => {
+                if (this.pageSize !== ev.page.take) {
+                    this.pageSize = ev.page.take;
+                }
+                else if (this.skip === ev.page.skip) {
+                    return;
+                }
+                this.fetchData({
+                    newSkip: ev.page.skip,
+                });
+            }
+        });
+        /** Call without params if unchanged */
+        Object.defineProperty(this, "fetchData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ({ newSkip, newSort, newFilter, newAggregates, newGroup, } = {}) => __awaiter(this, void 0, void 0, function* () {
+                const sort = newSort !== null && newSort !== void 0 ? newSort : [...this.sort];
+                const filter = newFilter === null ? undefined : newFilter !== null && newFilter !== void 0 ? newFilter : this.filter;
+                const aggregates = newAggregates !== null && newAggregates !== void 0 ? newAggregates : this.aggregates;
+                const group = addAggregatesToGroups(newGroup !== null && newGroup !== void 0 ? newGroup : this.group, aggregates);
+                const skip = newSort || newFilter !== undefined || newGroup
+                    ? 0
+                    : newSkip !== undefined
+                        ? newSkip
+                        : this.skip;
+                if (!this.dataSource) {
+                    runInAction(() => {
+                        this.sort = sort;
+                        this.filter = filter;
+                        this.aggregates = aggregates;
+                        this.innerGroup = group;
+                    });
+                    return;
+                }
+                const newData = (yield this.dataSource.getData({
+                    skip,
+                    sort,
+                    filter,
+                    group: [...group],
+                    take: this.pageSize,
+                }));
+                runInAction(() => {
+                    if (!this.dataSource) {
+                        return;
+                    }
+                    if (newFilter !== undefined) {
+                        // When a new filter is applied, deselect items that don't match the filter
+                        if (this.dataSource.getFilteredPersistentItems) {
+                            // For persistent items, deselect everything in the persistent array that's been filtered out
+                            if (newFilter !== null && this.dataSource.idSelector) {
+                                let delta = 0;
+                                const filteredData = this.dataSource.getFilteredPersistentItems(newFilter);
+                                filteredData.forEach(dataItem => {
+                                    const id = this.dataSource.idSelector(dataItem);
+                                    if (this.selectedIds.delete(id)) {
+                                        delta += 1;
+                                    }
+                                    if (!this.alwaysEditable) {
+                                        this.inEdit.delete(id);
+                                    }
+                                    this.expandedIds.delete(id);
+                                });
+                                this.selectedCount -= delta;
+                            }
+                        }
+                        else {
+                            // For non-peristent items, everything is deselected by default
+                            this.selectedCount = 0;
+                        }
+                    }
+                    this.data = newData.data;
+                    this.filteredCount = newData.total;
+                    this.sort = sort;
+                    this.filter = filter;
+                    this.aggregates = aggregates;
+                    this.innerGroup = group;
+                    this.skip = skip;
+                    this.addPropertiesToRows(this.data);
+                });
+            })
+        });
+        Object.defineProperty(this, "isRowSelectable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (row) => !this.isRowUnselectable(row) &&
+                (this.selectionLimit === Infinity ||
+                    row.selected ||
+                    this.selectedCount < this.selectionLimit)
+        });
+        Object.defineProperty(this, "setTablePdfExportRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (el) => (this.tablePdfExport = el)
+        });
+        Object.defineProperty(this, "setTableExcelExportRef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (el) => (this.tableExcelExport = el)
+        });
+        Object.defineProperty(this, "exportPdf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => __awaiter(this, void 0, void 0, function* () {
+                if (this.dataSource && this.tablePdfExport) {
+                    const { data } = yield this.dataSource.getData({}); // fetch all data
+                    this.tablePdfExport.save(data);
+                }
+            })
+        });
+        Object.defineProperty(this, "exportExcel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (data, columns) => __awaiter(this, void 0, void 0, function* () {
+                if (this.tableExcelExport) {
+                    this.tableExcelExport.save(data !== null && data !== void 0 ? data : (yield this.filteredSortedUnpaginatedData()).data, columns);
+                }
+            })
+        });
+        Object.defineProperty(this, "filteredSortedUnpaginatedData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                if (!this.dataSource) {
+                    throw 'missing dataSource';
+                }
+                return this.dataSource.getData({
+                    filter: this.filter,
+                    sort: [...this.sort],
+                    group: [...this.group],
+                });
+            }
+        });
+        Object.defineProperty(this, "getRowsBetween", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (start, end) => {
+                var _a;
+                const idSelector = (_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.idSelector;
+                if (!idSelector) {
+                    return [];
+                }
+                let from, to;
+                const startId = idSelector(start);
+                const endId = idSelector(end);
+                for (const [index, row] of this.originalData.entries()) {
+                    const id = idSelector(row);
+                    if (startId === id) {
+                        from = index;
+                    }
+                    if (endId === id) {
+                        to = index;
+                    }
+                }
+                if (from === undefined || to === undefined) {
+                    return [];
+                }
+                return this.originalData.slice(Math.min(from, to), Math.max(from, to) + 1);
+            }
+        });
+        makeObservable(this);
+        this.innerDataSource = dataSource;
+        this.pageSize = pageSize;
+        this.isRowUnselectable = isRowUnselectable;
+        this.selectionLimit = selectionLimit;
+        this.getFormState = getFormState;
+        this.parent = parent;
+        this.getDetailTableState = getDetailTableState;
+        if (initialState) {
+            this.importState(initialState);
+        }
+        this.alwaysEditable = alwaysEditable;
+        this.fetchInitialData();
+        if (this.alwaysEditable) {
+            this.editAll();
+        }
+    }
+    get dataSource() {
+        return this.innerDataSource;
+    }
+    traverse(items, itemCallback, groupCallback, materializedPath = '') {
+        if (!items) {
+            return;
+        }
+        for (const item of items) {
+            if (isGroupItem(item, this.group)) {
+                const groupMaterializedPath = materializedPath + `/${item.value}`;
+                if (groupCallback) {
+                    groupCallback(item, groupMaterializedPath);
+                }
+                this.traverse(item.items, itemCallback, groupCallback, groupMaterializedPath);
+            }
+            else {
+                itemCallback(item);
+            }
+        }
+    }
+    get originalData() {
+        const result = [];
+        this.traverse(this.data, item => {
+            result.push(item);
+        });
+        return result;
+    }
+    get unselectedCount() {
+        return this.totalCount - this.selectedCount;
+    }
+    get selectableCount() {
+        return this.totalCount - this.unselectableCount;
+    }
+    get filteredUnselectableCount() {
+        return this.originalData.filter(this.isRowUnselectable).length;
+    }
+    get filteredSelectableCount() {
+        return this.originalData.length - this.filteredUnselectableCount;
+    }
+    get totalFilteredSelectableCountPromise() {
+        return fromPromise(new Promise((resolve, reject) => {
+            if (!this.dataSource) {
+                return reject();
+            }
+            this.dataSource
+                .getData({
+                filter: this.filter,
+            })
+                .then(filteredData => {
+                resolve(filteredData.data.filter(row => !this.isRowUnselectable(row))
+                    .length);
+            })
+                .catch(reject);
+        }));
+    }
+    get totalFilteredSelectableCount() {
+        return this.totalFilteredSelectableCountPromise.value || 0;
+    }
+    get group() {
+        return addAggregatesToGroups(this.innerGroup, this.aggregates);
+    }
+    set group(value) {
+        this.innerGroup = value;
+    }
+    addToDataSource(row, select, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.addData) {
+                throw 'missing addData in the data source';
+            }
+            yield this.dataSource.addData(row, index);
+            runInAction(() => {
+                this.totalCount += 1;
+                if (select) {
+                    if (!this.dataSource.idSelector) {
+                        throw 'missing idSelector in the data source';
+                    }
+                    this.selectedIds.add(this.dataSource.idSelector(row));
+                    this.selectedCount += 1;
+                }
+                if (this.alwaysEditable) {
+                    this.edit(row);
+                }
+            });
+            yield this.fetchData();
+        });
+    }
+    removeFromDataSource(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.removeData) {
+                throw 'missing removeData in the data source';
+            }
+            const row = (yield this.dataSource.removeData(id));
+            if (!row) {
+                return;
+            }
+            runInAction(() => {
+                this.totalCount -= 1;
+                if (this.selectedIds.has(id)) {
+                    this.selectedIds.delete(id);
+                    this.selectedCount -= 1;
+                }
+                if (this.inEdit.has(id)) {
+                    this.inEdit.delete(id);
+                }
+                if (this.expandedIds.has(id)) {
+                    this.expandedIds.delete(id);
+                }
+            });
+            yield this.fetchData();
+            return row;
+        });
+    }
+    setRowsSelection(rows, value, { ignoreUnselectable = true, recursive = true } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.idSelector) {
+                throw 'missing idSelector in the data source';
+            }
+            for (const row of rows) {
+                if (ignoreUnselectable && this.isRowUnselectable(row)) {
+                    continue;
+                }
+                runInAction(() => {
+                    if (!value) {
+                        this.selectedIds.delete(this.dataSource.idSelector(row));
+                    }
+                    else if (this.selectedCount < this.selectionLimit) {
+                        this.selectedIds.add(this.dataSource.idSelector(row));
+                    }
+                });
+                // update children selection
+                if (recursive && this.getDetailTableState) {
+                    const detail = this.getDetailTableState(row);
+                    if (detail === null || detail === void 0 ? void 0 : detail.selectableCount) {
+                        // eslint-disable-next-line no-await-in-loop
+                        yield detail.setAllSelection(value);
+                    }
+                }
+            }
+            // update parent selection
+            if (this.parent) {
+                if (this.isAllPageRowsSelected) {
+                    yield this.parent.tableState.setRowsSelection([this.parent.row], true, {
+                        recursive: false,
+                    });
+                }
+                else {
+                    yield this.parent.tableState.setRowsSelection([this.parent.row], false, {
+                        recursive: false,
+                    });
+                }
+            }
+            runInAction(() => {
+                this.selectedCount = this.selectedIds.size;
+                this.data = this.data.slice();
+            });
+        });
+    }
+    selectPage(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setRowsSelection(this.originalData, true, options);
+        });
+    }
+    deselectPage(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setRowsSelection(this.originalData, false, options);
+        });
+    }
+    setAllSelection(value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            const filteredData = yield this.dataSource.getData({
+                filter: this.filter,
+            });
+            yield this.setRowsSelection(filteredData.data, value, options);
+        });
+    }
+    selectAll(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.selectionLimit !== Infinity) {
+                throw "selectAll isn't supported for limited selection";
+            }
+            yield this.setAllSelection(true, options);
+        });
+    }
+    deselectAll(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setAllSelection(false, options);
+        });
+    }
+    edit(row, field) {
+        if (!this.dataSource) {
+            return;
+        }
+        if (!this.dataSource.idSelector) {
+            throw 'missing idSelector in the data source';
+        }
+        if (!this.getFormState) {
+            throw 'missing getFormState';
+        }
+        this.inEdit.set(this.dataSource.idSelector(row), {
+            form: this.getFormState(row),
+            field,
+        });
+        this.data = this.data.slice();
+    }
+    saveEdit(row, beforeSave) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.idSelector) {
+                throw 'missing idSelector in the data source';
+            }
+            if (!this.dataSource.updateData) {
+                throw 'missing updateData in the data source';
+            }
+            const id = this.dataSource.idSelector(row);
+            const editingForm = this.inEdit.get(id);
+            if (!editingForm) {
+                return;
+            }
+            const { form, field } = editingForm;
+            const changed = formStateToJS(form); // FIXME: incompatible types
+            if (beforeSave) {
+                yield beforeSave(changed, field);
+            }
+            yield this.dataSource.updateData(id, changed);
+            if (!this.alwaysEditable) {
+                runInAction(() => {
+                    this.inEdit.delete(id);
+                });
+            }
+            yield this.fetchData();
+        });
+    }
+    cancelEdit(row) {
+        if (!this.dataSource) {
+            return;
+        }
+        if (!this.dataSource.idSelector) {
+            throw 'missing idSelector in the data source';
+        }
+        if (this.alwaysEditable) {
+            return;
+        }
+        this.inEdit.delete(this.dataSource.idSelector(row));
+        this.data = this.data.slice();
+    }
+    editAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.idSelector) {
+                throw 'missing idSelector in the data source';
+            }
+            if (!this.getFormState) {
+                throw 'missing getFormState';
+            }
+            const rows = (yield this.dataSource.getData({
+                filter: this.filter,
+            })).data;
+            runInAction(() => {
+                this.inEdit = new Map(rows.map(row => [
+                    this.dataSource.idSelector(row),
+                    { form: this.getFormState(row) },
+                ]));
+                this.data = this.data.slice();
+            });
+        });
+    }
+    saveEditAll(beforeSave) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.updateData) {
+                throw 'missing updateData in the data source';
+            }
+            const changes = Array.from(this.inEdit).map(([id, { form }]) => ({
+                id,
+                changed: formStateToJS(form), // FIXME: incompatible types
+            }));
+            if (beforeSave) {
+                yield beforeSave(changes.map(change => change.changed));
+            }
+            for (const { id, changed } of changes) {
+                // eslint-disable-next-line no-await-in-loop
+                yield this.dataSource.updateData(id, changed);
+            }
+            if (!this.alwaysEditable) {
+                runInAction(() => {
+                    this.inEdit = new Map();
+                });
+            }
+            yield this.fetchData();
+        });
+    }
+    cancelEditAll() {
+        if (!this.dataSource) {
+            return;
+        }
+        if (this.alwaysEditable) {
+            return;
+        }
+        this.inEdit = new Map();
+        this.data = this.data.slice();
+    }
+    reset() {
+        this.totalCount = 0;
+        this.filteredCount = 0;
+        this.data = [];
+        this.selectedCount = 0;
+        this.selectedIds = new Set();
+        this.inEdit = new Map();
+        this.expandedIds = new Set();
+        this.collapsedGroups = new Set();
+        this.sort = [];
+        this.filter = undefined;
+        this.aggregates = [];
+        this.innerGroup = [];
+    }
+    setDataSource(dataSource, setDataSourceParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.innerDataSource = dataSource;
+            this.skip = 0;
+            const reset = typeof setDataSourceParams === 'boolean'
+                ? setDataSourceParams
+                : setDataSourceParams === null || setDataSourceParams === void 0 ? void 0 : setDataSourceParams.reset;
+            const config = setDataSourceParams;
+            if (reset) {
+                this.reset();
+            }
+            if (config === null || config === void 0 ? void 0 : config.initialState) {
+                this.importState(config.initialState);
+            }
+            yield this.fetchInitialData();
+            if (this.alwaysEditable) {
+                yield this.editAll();
+            }
+        });
+    }
+    addPropertiesToRows(data) {
+        this.traverse(data, item => {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.idSelector) {
+                return;
+            }
+            if (!('selected' in item)) {
+                Object.defineProperty(item, 'selected', {
+                    get: () => this.selectedIds.has(this.dataSource.idSelector(item)),
+                });
+            }
+            if (!('indeterminate' in item)) {
+                Object.defineProperty(item, 'indeterminate', {
+                    get: () => {
+                        var _a;
+                        const detail = (_a = this.getDetailTableState) === null || _a === void 0 ? void 0 : _a.call(this, item);
+                        if (!detail) {
+                            return false;
+                        }
+                        return detail.isSomePageRowsSelected;
+                    },
+                });
+            }
+            if (!('inEdit' in item)) {
+                Object.defineProperty(item, 'inEdit', {
+                    get: () => this.inEdit.has(this.dataSource.idSelector(item)),
+                });
+            }
+            if (!('expanded' in item)) {
+                Object.defineProperty(item, 'expanded', {
+                    get: () => this.expandedIds.has(this.dataSource.idSelector(item)),
+                });
+            }
+        }, (group, materializedPath) => {
+            if (!('materializedPath' in group)) {
+                Object.defineProperty(group, 'materializedPath', {
+                    get: () => materializedPath,
+                });
+            }
+            if (!('expanded' in group)) {
+                Object.defineProperty(group, 'expanded', {
+                    get: () => !this.collapsedGroups.has(group.materializedPath),
+                });
+            }
+        });
+    }
+    toggleRowSelection(row, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dataSource) {
+                return;
+            }
+            if (!this.dataSource.idSelector) {
+                throw 'missing idSelector in the data source';
+            }
+            yield this.setRowsSelection([row], !this.selectedIds.has(this.dataSource.idSelector(row)), options);
+        });
+    }
+    get isAllPageRowsSelected() {
+        return (this.originalData.some(row => row.selected) &&
+            this.originalData.every(row => this.isRowUnselectable(row) || row.selected));
+    }
+    get isSomePageRowsSelected() {
+        return this.originalData.some(row => row.selected) && !this.isAllPageRowsSelected;
+    }
+    get isAllRowsSelected() {
+        if (!this.selectedIds.size) {
+            return false;
+        }
+        return this.selectedIds.size === this.totalFilteredSelectableCount;
+    }
+    get isSomeRowsSelected() {
+        if (!this.selectedIds.size) {
+            return false;
+        }
+        return !this.isAllRowsSelected;
+    }
+    exportState() {
+        return {
+            skip: this.skip,
+            selectedIds: Array.from(this.selectedIds),
+            expandedIds: Array.from(this.expandedIds),
+            collapsedGroups: Array.from(this.collapsedGroups),
+            sort: this.sort,
+            filter: this.filter,
+            aggregates: this.aggregates,
+            group: this.innerGroup,
+        };
+    }
+    importState(data) {
+        this.skip = data.skip;
+        this.selectedIds = new Set(data.selectedIds);
+        this.expandedIds = new Set(data.expandedIds);
+        this.collapsedGroups = new Set(data.collapsedGroups);
+        this.sort = data.sort;
+        this.filter = data.filter;
+        this.aggregates = data.aggregates;
+        this.innerGroup = data.group;
+    }
+}
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "innerDataSource", void 0);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "dataSource", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "originalData", null);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "selectedIds", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "inEdit", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "expandedIds", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "collapsedGroups", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "data", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "totalCount", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "filteredCount", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "selectedCount", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "unselectableCount", void 0);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "unselectedCount", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "selectableCount", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "filteredUnselectableCount", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "filteredSelectableCount", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "totalFilteredSelectableCountPromise", null);
+__decorate([
+    computed,
+    __metadata("design:type", Number),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "totalFilteredSelectableCount", null);
+__decorate([
+    observable,
+    __metadata("design:type", Array)
+], TableState.prototype, "sort", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "filter", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Array)
+], TableState.prototype, "aggregates", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Array)
+], TableState.prototype, "innerGroup", void 0);
+__decorate([
+    computed,
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [Array])
+], TableState.prototype, "group", null);
+__decorate([
+    observable,
+    __metadata("design:type", Object)
+], TableState.prototype, "skip", void 0);
+__decorate([
+    observable,
+    __metadata("design:type", Number)
+], TableState.prototype, "pageSize", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], TableState.prototype, "setRowsSelection", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], TableState.prototype, "edit", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", Promise)
+], TableState.prototype, "saveEdit", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TableState.prototype, "cancelEdit", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TableState.prototype, "cancelEditAll", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TableState.prototype, "reset", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], TableState.prototype, "setDataSource", null);
+__decorate([
+    action,
+    __metadata("design:type", Object)
+], TableState.prototype, "fetchInitialData", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Object)
+], TableState.prototype, "handleFilterChange", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Object)
+], TableState.prototype, "handleGroupChange", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Object)
+], TableState.prototype, "handleExpandChange", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Object)
+], TableState.prototype, "handleSortChange", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Object)
+], TableState.prototype, "handlePageChange", void 0);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], TableState.prototype, "toggleRowSelection", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "isAllPageRowsSelected", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "isSomePageRowsSelected", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "isAllRowsSelected", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], TableState.prototype, "isSomeRowsSelected", null);
+__decorate([
+    action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TableState.prototype, "importState", null);
+//# sourceMappingURL=table-state.js.map