@itwin/components-react 3.4.0-dev.57 → 3.4.0-dev.59

package/lib/esm/components-react/selectable-content/SelectableContent.scss

@@ -1,21 +1,21 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-@import "~@itwin/core-react/lib/cjs/core-react/select/select";
-
-.components-selectable-content {
-  display: flex;
-  flex-direction: column;
-
-  .components-selectable-content-header {
-    .components-selectable-content-selector {
-      width: 100%;
-    }
-  }
-
-  .components-selectable-content-wrapper {
-    flex-grow: 1;
-    overflow: hidden;
-  }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+@import "~@itwin/core-react/lib/cjs/core-react/select/select";
+
+.components-selectable-content {
+  display: flex;
+  flex-direction: column;
+
+  .components-selectable-content-header {
+    .components-selectable-content-selector {
+      width: 100%;
+    }
+  }
+
+  .components-selectable-content-wrapper {
+    flex-grow: 1;
+    overflow: hidden;
+  }
+}

package/lib/esm/components-react/table/SimpleTableDataProvider.d.ts

@@ -1,57 +1,57 @@
-/** @packageDocumentation
- * @module Table
- */
-import { SortDirection } from "@itwin/core-react";
-import { CompositeFilterDescriptorCollection, DistinctValueCollection } from "./columnfiltering/ColumnFiltering";
-import { ColumnDescription, MutableTableDataProvider, RowItem, TableDataChangeEvent } from "./TableDataProvider";
-/**
- * A Table Data Provider using an array of items.
- * @public
- */
-export declare class SimpleTableDataProvider implements MutableTableDataProvider {
-    private _items;
-    private _rowItemIndices;
-    private _columns;
-    private _secondarySortColumnStack?;
-    private _sortDirection;
-    private _sortColumnIndex;
-    private _filterDescriptors?;
-    /** Event emitted by the data provider when column data changes */
-    onColumnsChanged: TableDataChangeEvent;
-    /** Event emitted by the data provider when row data changes */
-    onRowsChanged: TableDataChangeEvent;
-    constructor(columns: ColumnDescription[]);
-    /** Sets the row items based on an array */
-    setItems(items: RowItem[]): void;
-    private resetRowIndices;
-    /** Retrieves the column descriptions */
-    getColumns(): Promise<ColumnDescription[]>;
-    /** Retrieves the row count */
-    getRowsCount(): Promise<number>;
-    /** Retrieves a specific row by index */
-    getRow(rowIndex: number, unfiltered?: boolean): Promise<RowItem>;
-    private getRowIndexFromFilteredRowIndex;
-    /** Sorts the rows based on the value in a specific column */
-    sort(columnIndex: number, sortDirection: SortDirection): Promise<void>;
-    private sortDispatcher;
-    private getPrimitiveValue;
-    private sortRows;
-    /** Gets distinct values in a column
-     * @public
-     */
-    getDistinctValues(columnKey: string, maximumValueCount?: number): Promise<DistinctValueCollection>;
-    /** Apply a filter descriptor collection
-     * @public
-     */
-    applyFilterDescriptors(filterDescriptors: CompositeFilterDescriptorCollection): Promise<void>;
-    /** Adds a row to the end */
-    addRow(rowItem: RowItem): number;
-    /** Inserts a row at a given row index */
-    insertRow(rowItem: RowItem, index: number): number;
-    /** Deletes a row */
-    deleteRow(rowItem: RowItem, raiseRowsChangedEvent?: boolean): void;
-    /** Moves a row to a new row index */
-    moveRow(rowItem: RowItem, newIndex: number): number;
-    private findRowIndex;
-}
+/** @packageDocumentation
+ * @module Table
+ */
+import { SortDirection } from "@itwin/core-react";
+import { CompositeFilterDescriptorCollection, DistinctValueCollection } from "./columnfiltering/ColumnFiltering";
+import { ColumnDescription, MutableTableDataProvider, RowItem, TableDataChangeEvent } from "./TableDataProvider";
+/**
+ * A Table Data Provider using an array of items.
+ * @public
+ */
+export declare class SimpleTableDataProvider implements MutableTableDataProvider {
+    private _items;
+    private _rowItemIndices;
+    private _columns;
+    private _secondarySortColumnStack?;
+    private _sortDirection;
+    private _sortColumnIndex;
+    private _filterDescriptors?;
+    /** Event emitted by the data provider when column data changes */
+    onColumnsChanged: TableDataChangeEvent;
+    /** Event emitted by the data provider when row data changes */
+    onRowsChanged: TableDataChangeEvent;
+    constructor(columns: ColumnDescription[]);
+    /** Sets the row items based on an array */
+    setItems(items: RowItem[]): void;
+    private resetRowIndices;
+    /** Retrieves the column descriptions */
+    getColumns(): Promise<ColumnDescription[]>;
+    /** Retrieves the row count */
+    getRowsCount(): Promise<number>;
+    /** Retrieves a specific row by index */
+    getRow(rowIndex: number, unfiltered?: boolean): Promise<RowItem>;
+    private getRowIndexFromFilteredRowIndex;
+    /** Sorts the rows based on the value in a specific column */
+    sort(columnIndex: number, sortDirection: SortDirection): Promise<void>;
+    private sortDispatcher;
+    private getPrimitiveValue;
+    private sortRows;
+    /** Gets distinct values in a column
+     * @public
+     */
+    getDistinctValues(columnKey: string, maximumValueCount?: number): Promise<DistinctValueCollection>;
+    /** Apply a filter descriptor collection
+     * @public
+     */
+    applyFilterDescriptors(filterDescriptors: CompositeFilterDescriptorCollection): Promise<void>;
+    /** Adds a row to the end */
+    addRow(rowItem: RowItem): number;
+    /** Inserts a row at a given row index */
+    insertRow(rowItem: RowItem, index: number): number;
+    /** Deletes a row */
+    deleteRow(rowItem: RowItem, raiseRowsChangedEvent?: boolean): void;
+    /** Moves a row to a new row index */
+    moveRow(rowItem: RowItem, newIndex: number): number;
+    private findRowIndex;
+}
 //# sourceMappingURL=SimpleTableDataProvider.d.ts.map

package/lib/esm/components-react/table/SimpleTableDataProvider.js

@@ -1,249 +1,249 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Table
- */
-import { PropertyValueFormat, UiError } from "@itwin/appui-abstract";
-import { SortDirection } from "@itwin/core-react";
-import { TypeConverterManager } from "../converters/TypeConverterManager";
-import { UiComponents } from "../UiComponents";
-import { DistinctValueCollection } from "./columnfiltering/ColumnFiltering";
-import { TableDataChangeEvent } from "./TableDataProvider";
-// cSpell:ignore columnfiltering
-/**
- * A Table Data Provider using an array of items.
- * @public
- */
-export class SimpleTableDataProvider {
-    constructor(columns) {
-        this._sortDirection = SortDirection.NoSort;
-        this._sortColumnIndex = -1;
-        /** Event emitted by the data provider when column data changes */
-        this.onColumnsChanged = new TableDataChangeEvent();
-        /** Event emitted by the data provider when row data changes */
-        this.onRowsChanged = new TableDataChangeEvent();
-        this._columns = columns;
-        this._items = [];
-        this._rowItemIndices = [];
-        this._secondarySortColumnStack = [];
-    }
-    /** Sets the row items based on an array */
-    setItems(items) {
-        this._items = items;
-        this._rowItemIndices = [];
-        this.resetRowIndices();
-        this.onRowsChanged.raiseEvent();
-    }
-    resetRowIndices() {
-        this._rowItemIndices.splice(0);
-        for (let rowIndex = 0; rowIndex < this._items.length; rowIndex++) {
-            this._rowItemIndices.push(rowIndex);
-        }
-    }
-    /** Retrieves the column descriptions */
-    async getColumns() {
-        return this._columns;
-    }
-    /** Retrieves the row count */
-    async getRowsCount() {
-        return this._rowItemIndices.length;
-    }
-    /** Retrieves a specific row by index */
-    async getRow(rowIndex, unfiltered) {
-        let realRowIndex = -1;
-        if (unfiltered) {
-            // istanbul ignore else
-            if (0 <= rowIndex && rowIndex < this._items.length)
-                realRowIndex = rowIndex;
-        }
-        else {
-            if (0 <= rowIndex && rowIndex < this._rowItemIndices.length)
-                realRowIndex = this.getRowIndexFromFilteredRowIndex(rowIndex);
-        }
-        if (0 <= realRowIndex && realRowIndex < this._items.length)
-            return this._items[realRowIndex];
-        throw new UiError(UiComponents.loggerCategory(this), `getRow: Invalid row index - ${rowIndex}`);
-    }
-    getRowIndexFromFilteredRowIndex(filteredRowIndex) {
-        // istanbul ignore next
-        if (filteredRowIndex === undefined)
-            return filteredRowIndex;
-        // istanbul ignore next
-        if (filteredRowIndex < 0 || filteredRowIndex >= this._rowItemIndices.length)
-            return -1;
-        return this._rowItemIndices[filteredRowIndex];
-    }
-    /** Sorts the rows based on the value in a specific column */
-    async sort(columnIndex, sortDirection) {
-        // istanbul ignore next
-        if (columnIndex < 0 || columnIndex >= this._columns.length)
-            return;
-        this._sortColumnIndex = columnIndex;
-        this._sortDirection = sortDirection;
-        if (sortDirection === SortDirection.NoSort) {
-            if (this._filterDescriptors)
-                await this.applyFilterDescriptors(this._filterDescriptors);
-            else
-                this.resetRowIndices();
-            return;
-        }
-        this._secondarySortColumnStack = [];
-        this._secondarySortColumnStack.push(columnIndex);
-        // Sort by the column
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const dataProvider = this;
-        this._rowItemIndices.sort((a, b) => {
-            return dataProvider.sortDispatcher(dataProvider._items[a], dataProvider._items[b], columnIndex, sortDirection);
-        });
-        delete this._secondarySortColumnStack;
-        return;
-    }
-    sortDispatcher(a, b, columnIndex, sortDirection) {
-        let result = this.sortRows(a, b, columnIndex, sortDirection);
-        if (result !== 0)
-            return result;
-        // Secondary sort column support
-        // istanbul ignore else
-        const column = this._columns[columnIndex];
-        if (this._secondarySortColumnStack !== undefined &&
-            column.secondarySortColumn !== undefined &&
-            column.secondarySortColumn !== columnIndex &&
-            this._secondarySortColumnStack.indexOf(column.secondarySortColumn) < 0) {
-            this._secondarySortColumnStack.push(column.secondarySortColumn);
-            result = this.sortDispatcher(a, b, column.secondarySortColumn, sortDirection);
-            this._secondarySortColumnStack.pop();
-        }
-        return result;
-    }
-    getPrimitiveValue(record) {
-        let primitiveValue;
-        const recordValue = record.value;
-        // istanbul ignore else
-        if (recordValue.valueFormat === PropertyValueFormat.Primitive)
-            primitiveValue = recordValue.value;
-        return primitiveValue;
-    }
-    sortRows(a, b, columnIndex, sortDirection) {
-        var _a;
-        const aCell = a.cells[columnIndex];
-        const bCell = b.cells[columnIndex];
-        let result = 0;
-        const column = this._columns[columnIndex];
-        const propertyDescription = column.propertyDescription;
-        const valueA = this.getPrimitiveValue(aCell.record);
-        const valueB = this.getPrimitiveValue(bCell.record);
-        // istanbul ignore else
-        if (valueA !== undefined && valueB !== undefined && propertyDescription)
-            result = TypeConverterManager.getConverter(propertyDescription.typename, (_a = propertyDescription.converter) === null || _a === void 0 ? void 0 : _a.name).sortCompare(valueA, valueB, column.sortIgnoreCase);
-        if (sortDirection === SortDirection.Descending)
-            result *= -1;
-        return result;
-    }
-    /** Gets distinct values in a column
-     * @public
-     */
-    async getDistinctValues(columnKey, maximumValueCount) {
-        var _a;
-        const distinctValues = new DistinctValueCollection();
-        const columnIndex = this._columns.findIndex((description) => description.key === columnKey);
-        if (columnIndex < 0 || columnIndex >= this._columns.length)
-            return distinctValues;
-        const columnDescription = this._columns[columnIndex];
-        const propertyDescription = columnDescription.propertyDescription;
-        const uniqueKeysMap = {};
-        const uniqueValues = [];
-        // istanbul ignore next
-        if (!propertyDescription)
-            return distinctValues;
-        for (const row of this._items) {
-            const cell = row.cells[columnIndex];
-            const record = cell.record;
-            // istanbul ignore next
-            if (record === undefined)
-                continue;
-            const value = this.getPrimitiveValue(record);
-            const displayValue = await TypeConverterManager
-                .getConverter(propertyDescription.typename, (_a = propertyDescription.converter) === null || _a === void 0 ? void 0 : _a.name)
-                .convertPropertyToString(propertyDescription, value);
-            // istanbul ignore next
-            if (value === undefined || typeof displayValue !== "string")
-                continue;
-            const valueKey = value.toString();
-            if (!uniqueKeysMap.hasOwnProperty(valueKey)) {
-                const propertyValue = { value, label: displayValue };
-                uniqueKeysMap[valueKey] = propertyValue;
-                uniqueValues.push(propertyValue);
-            }
-        }
-        distinctValues.values = uniqueValues;
-        distinctValues.values.sort((a, b) => {
-            var _a;
-            if (a.value && b.value)
-                return TypeConverterManager.getConverter(propertyDescription.typename, (_a = propertyDescription.converter) === null || _a === void 0 ? void 0 : _a.name).sortCompare(a.value, b.value);
-            return 0;
-        });
-        if (maximumValueCount !== undefined && distinctValues.values.length > maximumValueCount)
-            distinctValues.values.splice(maximumValueCount);
-        return distinctValues;
-    }
-    /** Apply a filter descriptor collection
-     * @public
-     */
-    async applyFilterDescriptors(filterDescriptors) {
-        this._filterDescriptors = filterDescriptors;
-        this._rowItemIndices.splice(0);
-        this._items.forEach((row, i) => {
-            if (filterDescriptors.evaluateRow(row))
-                this._rowItemIndices.push(i);
-        });
-        if (this._sortDirection !== SortDirection.NoSort) {
-            await this.sort(this._sortColumnIndex, this._sortDirection);
-        }
-    }
-    /** Adds a row to the end */
-    addRow(rowItem) {
-        return this.insertRow(rowItem, -1);
-    }
-    /** Inserts a row at a given row index */
-    insertRow(rowItem, index) {
-        let newIdx = index;
-        if (index < 0 || index >= this._items.length)
-            newIdx = this._items.push(rowItem) - 1;
-        else
-            this._items.splice(newIdx, 0, rowItem);
-        this.resetRowIndices();
-        this.onRowsChanged.raiseEvent();
-        return newIdx;
-    }
-    /** Deletes a row */
-    deleteRow(rowItem, raiseRowsChangedEvent = true) {
-        const rowIndex = this.findRowIndex(rowItem);
-        if (rowIndex >= 0) {
-            this._items.splice(rowIndex, 1);
-            this.resetRowIndices();
-            if (raiseRowsChangedEvent)
-                this.onRowsChanged.raiseEvent();
-        }
-    }
-    /** Moves a row to a new row index */
-    moveRow(rowItem, newIndex) {
-        const oldIndex = this.findRowIndex(rowItem);
-        if (oldIndex >= 0) {
-            this.deleteRow(rowItem, false);
-            if (newIndex > oldIndex)
-                newIndex--; // removing the row will shrink the count by 1
-            return this.insertRow(rowItem, newIndex);
-        }
-        return -1;
-    }
-    findRowIndex(item) {
-        for (let i = 0; i < this._items.length; i++) {
-            if (item === this._items[i])
-                return i;
-        }
-        return -1;
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Table
+ */
+import { PropertyValueFormat, UiError } from "@itwin/appui-abstract";
+import { SortDirection } from "@itwin/core-react";
+import { TypeConverterManager } from "../converters/TypeConverterManager";
+import { UiComponents } from "../UiComponents";
+import { DistinctValueCollection } from "./columnfiltering/ColumnFiltering";
+import { TableDataChangeEvent } from "./TableDataProvider";
+// cSpell:ignore columnfiltering
+/**
+ * A Table Data Provider using an array of items.
+ * @public
+ */
+export class SimpleTableDataProvider {
+    constructor(columns) {
+        this._sortDirection = SortDirection.NoSort;
+        this._sortColumnIndex = -1;
+        /** Event emitted by the data provider when column data changes */
+        this.onColumnsChanged = new TableDataChangeEvent();
+        /** Event emitted by the data provider when row data changes */
+        this.onRowsChanged = new TableDataChangeEvent();
+        this._columns = columns;
+        this._items = [];
+        this._rowItemIndices = [];
+        this._secondarySortColumnStack = [];
+    }
+    /** Sets the row items based on an array */
+    setItems(items) {
+        this._items = items;
+        this._rowItemIndices = [];
+        this.resetRowIndices();
+        this.onRowsChanged.raiseEvent();
+    }
+    resetRowIndices() {
+        this._rowItemIndices.splice(0);
+        for (let rowIndex = 0; rowIndex < this._items.length; rowIndex++) {
+            this._rowItemIndices.push(rowIndex);
+        }
+    }
+    /** Retrieves the column descriptions */
+    async getColumns() {
+        return this._columns;
+    }
+    /** Retrieves the row count */
+    async getRowsCount() {
+        return this._rowItemIndices.length;
+    }
+    /** Retrieves a specific row by index */
+    async getRow(rowIndex, unfiltered) {
+        let realRowIndex = -1;
+        if (unfiltered) {
+            // istanbul ignore else
+            if (0 <= rowIndex && rowIndex < this._items.length)
+                realRowIndex = rowIndex;
+        }
+        else {
+            if (0 <= rowIndex && rowIndex < this._rowItemIndices.length)
+                realRowIndex = this.getRowIndexFromFilteredRowIndex(rowIndex);
+        }
+        if (0 <= realRowIndex && realRowIndex < this._items.length)
+            return this._items[realRowIndex];
+        throw new UiError(UiComponents.loggerCategory(this), `getRow: Invalid row index - ${rowIndex}`);
+    }
+    getRowIndexFromFilteredRowIndex(filteredRowIndex) {
+        // istanbul ignore next
+        if (filteredRowIndex === undefined)
+            return filteredRowIndex;
+        // istanbul ignore next
+        if (filteredRowIndex < 0 || filteredRowIndex >= this._rowItemIndices.length)
+            return -1;
+        return this._rowItemIndices[filteredRowIndex];
+    }
+    /** Sorts the rows based on the value in a specific column */
+    async sort(columnIndex, sortDirection) {
+        // istanbul ignore next
+        if (columnIndex < 0 || columnIndex >= this._columns.length)
+            return;
+        this._sortColumnIndex = columnIndex;
+        this._sortDirection = sortDirection;
+        if (sortDirection === SortDirection.NoSort) {
+            if (this._filterDescriptors)
+                await this.applyFilterDescriptors(this._filterDescriptors);
+            else
+                this.resetRowIndices();
+            return;
+        }
+        this._secondarySortColumnStack = [];
+        this._secondarySortColumnStack.push(columnIndex);
+        // Sort by the column
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const dataProvider = this;
+        this._rowItemIndices.sort((a, b) => {
+            return dataProvider.sortDispatcher(dataProvider._items[a], dataProvider._items[b], columnIndex, sortDirection);
+        });
+        delete this._secondarySortColumnStack;
+        return;
+    }
+    sortDispatcher(a, b, columnIndex, sortDirection) {
+        let result = this.sortRows(a, b, columnIndex, sortDirection);
+        if (result !== 0)
+            return result;
+        // Secondary sort column support
+        // istanbul ignore else
+        const column = this._columns[columnIndex];
+        if (this._secondarySortColumnStack !== undefined &&
+            column.secondarySortColumn !== undefined &&
+            column.secondarySortColumn !== columnIndex &&
+            this._secondarySortColumnStack.indexOf(column.secondarySortColumn) < 0) {
+            this._secondarySortColumnStack.push(column.secondarySortColumn);
+            result = this.sortDispatcher(a, b, column.secondarySortColumn, sortDirection);
+            this._secondarySortColumnStack.pop();
+        }
+        return result;
+    }
+    getPrimitiveValue(record) {
+        let primitiveValue;
+        const recordValue = record.value;
+        // istanbul ignore else
+        if (recordValue.valueFormat === PropertyValueFormat.Primitive)
+            primitiveValue = recordValue.value;
+        return primitiveValue;
+    }
+    sortRows(a, b, columnIndex, sortDirection) {
+        var _a;
+        const aCell = a.cells[columnIndex];
+        const bCell = b.cells[columnIndex];
+        let result = 0;
+        const column = this._columns[columnIndex];
+        const propertyDescription = column.propertyDescription;
+        const valueA = this.getPrimitiveValue(aCell.record);
+        const valueB = this.getPrimitiveValue(bCell.record);
+        // istanbul ignore else
+        if (valueA !== undefined && valueB !== undefined && propertyDescription)
+            result = TypeConverterManager.getConverter(propertyDescription.typename, (_a = propertyDescription.converter) === null || _a === void 0 ? void 0 : _a.name).sortCompare(valueA, valueB, column.sortIgnoreCase);
+        if (sortDirection === SortDirection.Descending)
+            result *= -1;
+        return result;
+    }
+    /** Gets distinct values in a column
+     * @public
+     */
+    async getDistinctValues(columnKey, maximumValueCount) {
+        var _a;
+        const distinctValues = new DistinctValueCollection();
+        const columnIndex = this._columns.findIndex((description) => description.key === columnKey);
+        if (columnIndex < 0 || columnIndex >= this._columns.length)
+            return distinctValues;
+        const columnDescription = this._columns[columnIndex];
+        const propertyDescription = columnDescription.propertyDescription;
+        const uniqueKeysMap = {};
+        const uniqueValues = [];
+        // istanbul ignore next
+        if (!propertyDescription)
+            return distinctValues;
+        for (const row of this._items) {
+            const cell = row.cells[columnIndex];
+            const record = cell.record;
+            // istanbul ignore next
+            if (record === undefined)
+                continue;
+            const value = this.getPrimitiveValue(record);
+            const displayValue = await TypeConverterManager
+                .getConverter(propertyDescription.typename, (_a = propertyDescription.converter) === null || _a === void 0 ? void 0 : _a.name)
+                .convertPropertyToString(propertyDescription, value);
+            // istanbul ignore next
+            if (value === undefined || typeof displayValue !== "string")
+                continue;
+            const valueKey = value.toString();
+            if (!uniqueKeysMap.hasOwnProperty(valueKey)) {
+                const propertyValue = { value, label: displayValue };
+                uniqueKeysMap[valueKey] = propertyValue;
+                uniqueValues.push(propertyValue);
+            }
+        }
+        distinctValues.values = uniqueValues;
+        distinctValues.values.sort((a, b) => {
+            var _a;
+            if (a.value && b.value)
+                return TypeConverterManager.getConverter(propertyDescription.typename, (_a = propertyDescription.converter) === null || _a === void 0 ? void 0 : _a.name).sortCompare(a.value, b.value);
+            return 0;
+        });
+        if (maximumValueCount !== undefined && distinctValues.values.length > maximumValueCount)
+            distinctValues.values.splice(maximumValueCount);
+        return distinctValues;
+    }
+    /** Apply a filter descriptor collection
+     * @public
+     */
+    async applyFilterDescriptors(filterDescriptors) {
+        this._filterDescriptors = filterDescriptors;
+        this._rowItemIndices.splice(0);
+        this._items.forEach((row, i) => {
+            if (filterDescriptors.evaluateRow(row))
+                this._rowItemIndices.push(i);
+        });
+        if (this._sortDirection !== SortDirection.NoSort) {
+            await this.sort(this._sortColumnIndex, this._sortDirection);
+        }
+    }
+    /** Adds a row to the end */
+    addRow(rowItem) {
+        return this.insertRow(rowItem, -1);
+    }
+    /** Inserts a row at a given row index */
+    insertRow(rowItem, index) {
+        let newIdx = index;
+        if (index < 0 || index >= this._items.length)
+            newIdx = this._items.push(rowItem) - 1;
+        else
+            this._items.splice(newIdx, 0, rowItem);
+        this.resetRowIndices();
+        this.onRowsChanged.raiseEvent();
+        return newIdx;
+    }
+    /** Deletes a row */
+    deleteRow(rowItem, raiseRowsChangedEvent = true) {
+        const rowIndex = this.findRowIndex(rowItem);
+        if (rowIndex >= 0) {
+            this._items.splice(rowIndex, 1);
+            this.resetRowIndices();
+            if (raiseRowsChangedEvent)
+                this.onRowsChanged.raiseEvent();
+        }
+    }
+    /** Moves a row to a new row index */
+    moveRow(rowItem, newIndex) {
+        const oldIndex = this.findRowIndex(rowItem);
+        if (oldIndex >= 0) {
+            this.deleteRow(rowItem, false);
+            if (newIndex > oldIndex)
+                newIndex--; // removing the row will shrink the count by 1
+            return this.insertRow(rowItem, newIndex);
+        }
+        return -1;
+    }
+    findRowIndex(item) {
+        for (let i = 0; i < this._items.length; i++) {
+            if (item === this._items[i])
+                return i;
+        }
+        return -1;
+    }
+}
 //# sourceMappingURL=SimpleTableDataProvider.js.map