@servicetitan/table 29.0.1 → 29.1.0

package/dist/table-state.js

@@ -7,15 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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';
@@ -24,7 +15,10 @@ export function isGroupItem(item, groups) {
     return !!field && groups.some(g => g.field === field);
 }
 function addAggregatesToGroups(groups, aggregates) {
-    return groups.map(group => (Object.assign(Object.assign({}, group), { aggregates })));
+    return groups.map(group => ({
+        ...group,
+        aggregates,
+    }));
 }
 export class TableState {
     get dataSource() {
@@ -252,11 +246,11 @@ export class TableState {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: () => __awaiter(this, void 0, void 0, function* () {
+            value: async () => {
                 if (!this.dataSource) {
                     return;
                 }
-                const initial = (yield this.dataSource.getData({
+                const initial = (await this.dataSource.getData({
                     skip: this.skip,
                     take: this.pageSize,
                     filter: this.filter,
@@ -271,7 +265,7 @@ export class TableState {
                     this.unselectableCount = this.originalData.filter(this.isRowUnselectable).length;
                     this.addPropertiesToRows(this.data);
                 });
-            })
+            }
         });
         Object.defineProperty(this, "handleFilterChange", {
             enumerable: true,
@@ -360,9 +354,9 @@ export class TableState {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (...args_1) => __awaiter(this, [...args_1], void 0, function* ({ newSkip, newSort, newFilter, newAggregates, newGroup, } = {}) {
+            value: async ({ newSkip, newSort, newFilter, newAggregates, newGroup, } = {}) => {
                 const sort = newSort !== null && newSort !== void 0 ? newSort : [...this.sort];
-                const filter = newFilter === null ? undefined : newFilter !== null && newFilter !== void 0 ? newFilter : this.filter;
+                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
@@ -379,7 +373,7 @@ export class TableState {
                     });
                     return;
                 }
-                const newData = (yield this.dataSource.getData({
+                const newData = (await this.dataSource.getData({
                     skip,
                     sort,
                     filter,
@@ -425,7 +419,7 @@ export class TableState {
                     this.skip = skip;
                     this.addPropertiesToRows(this.data);
                 });
-            })
+            }
         });
         Object.defineProperty(this, "isRowSelectable", {
             enumerable: true,
@@ -452,22 +446,22 @@ export class TableState {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: () => __awaiter(this, void 0, void 0, function* () {
+            value: async () => {
                 if (this.dataSource && this.tablePdfExport) {
-                    const { data } = yield this.dataSource.getData({}); // fetch all data
+                    const { data } = await 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* () {
+            value: async (data, columns) => {
                 if (this.tableExcelExport) {
-                    this.tableExcelExport.save(data !== null && data !== void 0 ? data : (yield this.filteredSortedUnpaginatedData()).data, columns);
+                    this.tableExcelExport.save(data !== null && data !== void 0 ? data : (await this.filteredSortedUnpaginatedData()).data, columns);
                 }
-            })
+            }
         });
         Object.defineProperty(this, "filteredSortedUnpaginatedData", {
             enumerable: true,
@@ -531,149 +525,133 @@ export class TableState {
             this.editAll();
         }
     }
-    addToDataSource(row, select, index) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.dataSource) {
-                return;
+    async addToDataSource(row, select, index) {
+        if (!this.dataSource) {
+            return;
+        }
+        if (!this.dataSource.addData) {
+            throw 'missing addData in the data source';
+        }
+        await 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.dataSource.addData) {
-                throw 'missing addData in the data source';
+            if (this.alwaysEditable) {
+                this.edit(row);
             }
-            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();
         });
+        await this.fetchData();
     }
-    removeFromDataSource(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.dataSource) {
-                return;
+    async removeFromDataSource(id) {
+        if (!this.dataSource) {
+            return;
+        }
+        if (!this.dataSource.removeData) {
+            throw 'missing removeData in the data source';
+        }
+        const row = (await this.dataSource.removeData(id));
+        if (!row) {
+            return;
+        }
+        runInAction(() => {
+            this.totalCount -= 1;
+            // Updating filteredCount here to force Table rerender after this action
+            this.filteredCount -= 1;
+            if (this.selectedIds.has(id)) {
+                this.selectedIds.delete(id);
+                this.selectedCount -= 1;
             }
-            if (!this.dataSource.removeData) {
-                throw 'missing removeData in the data source';
+            if (this.inEdit.has(id)) {
+                this.inEdit.delete(id);
             }
-            const row = (yield this.dataSource.removeData(id));
-            if (!row) {
-                return;
+            if (this.expandedIds.has(id)) {
+                this.expandedIds.delete(id);
+            }
+        });
+        // If the current page has only one row and it's removed, fetch the previous page if it exists
+        if (this.data.length === 1 && this.pageSize && this.skip >= this.pageSize) {
+            await this.fetchData({ newSkip: this.skip - this.pageSize });
+        }
+        else {
+            await this.fetchData();
+        }
+        return row;
+    }
+    async setRowsSelection(rows, value, { ignoreUnselectable = true, recursive = true } = {}) {
+        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(() => {
-                this.totalCount -= 1;
-                // Updating filteredCount here to force Table rerender after this action
-                this.filteredCount -= 1;
-                if (this.selectedIds.has(id)) {
-                    this.selectedIds.delete(id);
-                    this.selectedCount -= 1;
+                if (!value) {
+                    this.selectedIds.delete(this.dataSource.idSelector(row));
                 }
-                if (this.inEdit.has(id)) {
-                    this.inEdit.delete(id);
-                }
-                if (this.expandedIds.has(id)) {
-                    this.expandedIds.delete(id);
+                else if (this.selectedCount < this.selectionLimit) {
+                    this.selectedIds.add(this.dataSource.idSelector(row));
                 }
             });
-            // If the current page has only one row and it's removed, fetch the previous page if it exists
-            if (this.data.length === 1 && this.pageSize && this.skip >= this.pageSize) {
-                yield this.fetchData({ newSkip: this.skip - this.pageSize });
-            }
-            else {
-                yield this.fetchData();
-            }
-            return row;
-        });
-    }
-    setRowsSelection(rows_1, value_1) {
-        return __awaiter(this, arguments, void 0, function* (rows, value, { ignoreUnselectable = true, recursive = true } = {}) {
-            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;
+            // 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
+                    await detail.setAllSelection(value);
                 }
-                runInAction(() => {
-                    if (!value) {
-                        this.selectedIds.delete(this.dataSource.idSelector(row));
-                    }
-                    else if (this.selectedCount < this.selectionLimit) {
-                        this.selectedIds.add(this.dataSource.idSelector(row));
-                    }
+            }
+        }
+        // update parent selection
+        if (this.parent) {
+            if (this.isAllPageRowsSelected) {
+                await this.parent.tableState.setRowsSelection([this.parent.row], true, {
+                    recursive: false,
                 });
-                // 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,
-                    });
-                }
+            else {
+                await this.parent.tableState.setRowsSelection([this.parent.row], false, {
+                    recursive: false,
+                });
             }
-            runInAction(() => {
-                this.selectedCount = this.selectedIds.size;
-                this.data = this.data.slice();
-            });
+        }
+        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);
-        });
+    async selectPage(options) {
+        await this.setRowsSelection(this.originalData, true, options);
     }
-    deselectPage(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.setRowsSelection(this.originalData, false, options);
-        });
+    async deselectPage(options) {
+        await 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);
+    async setAllSelection(value, options) {
+        if (!this.dataSource) {
+            return;
+        }
+        const filteredData = await this.dataSource.getData({
+            filter: this.filter,
         });
+        await 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);
-        });
+    async selectAll(options) {
+        if (this.selectionLimit !== Infinity) {
+            throw "selectAll isn't supported for limited selection";
+        }
+        await this.setAllSelection(true, options);
     }
-    deselectAll(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.setAllSelection(false, options);
-        });
+    async deselectAll(options) {
+        await this.setAllSelection(false, options);
     }
     edit(row, field) {
         if (!this.dataSource) {
@@ -691,35 +669,33 @@ export class TableState {
         });
         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();
-        });
+    async saveEdit(row, beforeSave) {
+        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) {
+            await beforeSave(changed, field);
+        }
+        await this.dataSource.updateData(id, changed);
+        if (!this.alwaysEditable) {
+            runInAction(() => {
+                this.inEdit.delete(id);
+            });
+        }
+        await this.fetchData();
     }
     cancelEdit(row) {
         if (!this.dataSource) {
@@ -734,55 +710,51 @@ export class TableState {
         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();
-            });
+    async editAll() {
+        if (!this.dataSource) {
+            return;
+        }
+        if (!this.dataSource.idSelector) {
+            throw 'missing idSelector in the data source';
+        }
+        if (!this.getFormState) {
+            throw 'missing getFormState';
+        }
+        const rows = (await 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();
-        });
+    async saveEditAll(beforeSave) {
+        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) {
+            await beforeSave(changes.map(change => change.changed));
+        }
+        for (const { id, changed } of changes) {
+            // eslint-disable-next-line no-await-in-loop
+            await this.dataSource.updateData(id, changed);
+        }
+        if (!this.alwaysEditable) {
+            runInAction(() => {
+                this.inEdit = new Map();
+            });
+        }
+        await this.fetchData();
     }
     cancelEditAll() {
         if (!this.dataSource) {
@@ -809,25 +781,23 @@ export class TableState {
         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();
-            }
-        });
+    async setDataSource(dataSource, setDataSourceParams) {
+        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);
+        }
+        await this.fetchInitialData();
+        if (this.alwaysEditable) {
+            await this.editAll();
+        }
     }
     addPropertiesToRows(data) {
         this.traverse(data, item => {
@@ -877,16 +847,14 @@ export class TableState {
             }
         });
     }
-    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);
-        });
+    async toggleRowSelection(row, options) {
+        if (!this.dataSource) {
+            return;
+        }
+        if (!this.dataSource.idSelector) {
+            throw 'missing idSelector in the data source';
+        }
+        await this.setRowsSelection([row], !this.selectedIds.has(this.dataSource.idSelector(row)), options);
     }
     get isAllPageRowsSelected() {
         return (this.originalData.some(row => row.selected) &&