@genesislcap/grid-tabulator 14.262.1 → 14.263.0

package/dist/esm/column/column.js

@@ -0,0 +1,51 @@
+import { __decorate } from "tslib";
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { css, customElement, html, observable } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+/**
+ * The GridTabulator Column element.
+ * @remarks Used inside the GridTabulator element to specify column definitions for a given column.
+ * @public
+ */
+let GridTabulatorColumn = class GridTabulatorColumn extends LifecycleMixin(FoundationElement) {
+    constructor() {
+        super(...arguments);
+        this.definition = {};
+    }
+    slottedCellChanged() { }
+    deepClone() {
+        const copy = super.deepClone();
+        copy.definition = {};
+        if (this.definition) {
+            Object.keys(this.definition).forEach((key) => {
+                if (typeof this.definition[key] === 'function') {
+                    copy.definition[key] = this.definition[key].bind(copy);
+                }
+                else {
+                    copy.definition[key] = structuredClone(this.definition[key]);
+                }
+            });
+        }
+        return copy;
+    }
+};
+__decorate([
+    observable
+], GridTabulatorColumn.prototype, "slottedCell", void 0);
+__decorate([
+    observable
+], GridTabulatorColumn.prototype, "definition", void 0);
+GridTabulatorColumn = __decorate([
+    customElement({
+        name: 'grid-tabulator-column',
+        template: html `
+    <slot></slot>
+  `,
+        styles: css `
+    :host {
+      display: none;
+    }
+  `,
+    })
+], GridTabulatorColumn);
+export { GridTabulatorColumn };

package/dist/esm/column/index.js

@@ -1 +1 @@
-export {};
+export * from './column';

package/dist/esm/datasource/client-side.datasource.js

@@ -1,15 +1,26 @@
 import { __awaiter, __decorate } from "tslib";
-import { Auth, Connect, dataServerResultFilter, Datasource, DatasourceEventHandler, DatasourceDefaults, MessageType, normaliseCriteria, ResourceType, } from '@genesislcap/foundation-comms';
+import { Auth, Connect, dataServerResultFilter, Datasource, DatasourceEventHandler, DatasourceDefaults, FieldTypeEnum, MessageType, normaliseCriteria, ResourceType, } from '@genesislcap/foundation-comms';
 import { LifecycleMixin } from '@genesislcap/foundation-utils';
 import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
 import { FoundationElement } from '@microsoft/fast-foundation';
 import { BehaviorSubject } from 'rxjs';
 import { debounceTime, skip, tap } from 'rxjs/operators';
-import { logger } from '../utils/logger';
-const criteriaDelimiter = ';';
-const criteriaJoin = ' && ';
+import { dateTimeValueFormatter, dateValueFormatter } from '../grid-tabulator.definitions';
+import { gridTabulatorEventNames } from '../grid-tabulator.definitions';
+import { logger, mergeAndDedupColDefWithColumnState } from '../utils';
+/**
+ * Delimiter for criteria in the datasource
+ * @alpha
+ */
+export const criteriaDelimiter = ';';
+/**
+ * Join operator for criteria in the datasource
+ * @alpha
+ */
+export const criteriaJoin = ' && ';
 const withoutFullInit = null;
 const withoutColumnDefs = null;
+const DEBOUNCE_INTERVAL_MS = 1000;
 /**
  * The Genesis Datasource element, for client-side data fetching and used exclusively by the GridTabulator element.
  * @alpha
@@ -17,6 +28,10 @@ const withoutColumnDefs = null;
 let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource extends LifecycleMixin(DatasourceEventHandler(FoundationElement)) {
     constructor() {
         super(...arguments);
+        /**
+         * Allows storing column layouts between datasource initializations
+         */
+        this.deferredColumnStates = [];
         this.isSnapshot = false;
         this.maxRows = DatasourceDefaults.MAX_ROWS_250;
         this.maxView = DatasourceDefaults.MAX_VIEW_1000;
@@ -24,6 +39,10 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
         this.movingView = false;
         this.reverse = false;
         this.restartOnReconnection = true;
+        /**
+         * Whether to keep column definitions when clearing row data
+         */
+        this.keepColDefsOnClearRowData = false;
         this.isRequestServer = false;
         this.requiresFullRowDataAndColDefs = true;
         this.dataSubWasLoggedOff = false;
@@ -42,9 +61,6 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
             return;
         this.restart();
     }
-    datasourceStatusChanged(prev, next) {
-        this.isRequestServer = next.type === ResourceType.REQUEST_SERVER;
-    }
     connectedCallback() {
         super.connectedCallback();
         const shouldRunConnect = this.shouldRunConnect;
@@ -77,6 +93,8 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
     }
     deepClone() {
         const copy = super.deepClone();
+        copy.deferredGridOptions = structuredClone(this.deferredGridOptions);
+        copy.deferredColumnStates = structuredClone(this.deferredColumnStates);
         copy.request = structuredClone(this.request);
         return copy;
     }
@@ -105,6 +123,10 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
             this.rowIdAttr === DatasourceDefaults.REQUEST_SERVER_ROW_ID ||
             this.rowIdAttr === DatasourceDefaults.DATASERVER_ROW_ID);
     }
+    /**
+     * Returns the default row ID based on the resource type
+     * @internal
+     */
     get defaultRowIdByResourceType() {
         return this.isRequestServer
             ? DatasourceDefaults.REQUEST_SERVER_ROW_ID
@@ -118,17 +140,7 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.gridTabulator) {
-                this.gridTabulator.gridOptions = Object.assign({ index: this.rowId, 
-                    // getRowId: (params) => params.data[this.rowId],
-                    layout: 'fitDataFill', 
-                    // responsiveLayout: 'hide', // hide columns that dont fit on the table
-                    addRowPos: 'top', 
-                    // history: true, // allow undo and redo actions on the table
-                    movableColumns: true, height: '100%', renderHorizontal: 'virtual', 
-                    // columnDefaults: {
-                    //   tooltip: true, // show tool tips on cells
-                    // },
-                    autoColumns: true, rowContextMenu: [
+                const gridOptions = Object.assign({ index: this.rowId, layout: 'fitDataFill', movableColumns: true, height: '100%', renderHorizontal: 'virtual', autoColumns: false, rowContextMenu: [
                         {
                             label: 'Download CSV',
                             action: (e, column) => {
@@ -136,6 +148,7 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
                             },
                         },
                     ], popupContainer: false }, this.deferredGridOptions);
+                this.gridTabulator.gridOptions = gridOptions;
                 const filterDebounceTime = 600;
                 this.updateSub = this.update
                     .pipe(skip(1), debounceTime(filterDebounceTime), tap((f) => logger.debug('filters (debounced): ', f)))
@@ -145,6 +158,7 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
                 return;
             }
             logger.warn(`Application not connected, datasource will not work. Falling back to local columnDefs/rowData.`);
+            this.handleErrors('Application not connected or datasource not initialized');
         });
     }
     /**
@@ -152,7 +166,7 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
      * @public
      */
     destroy() {
-        var _a;
+        var _a, _b, _c;
         if (this.dataSub) {
             this.dataSub.unsubscribe();
             this.dataSub = undefined;
@@ -173,8 +187,12 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
         this.criteriaFromFilters = new Map();
         (_a = this.update) === null || _a === void 0 ? void 0 : _a.unsubscribe();
         this.update = new BehaviorSubject(new Map());
+        // IMPORTANT: Save column states before destroying the datasource
+        if ((_b = this.gridTabulator) === null || _b === void 0 ? void 0 : _b.grid) {
+            this.deferredColumnStates = this.gridTabulator.grid.getColumnLayout();
+        }
         // TODO: There may need to be a full destroy path. Datasources need some love!
-        this.datasource.destroy();
+        (_c = this.datasource) === null || _c === void 0 ? void 0 : _c.destroy();
     }
     /**
      * Restarts the datasource, uses `deinit` and `init` in sequence.
@@ -199,24 +217,96 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
     clearRowData(withColumnDefs = true) {
         var _a, _b, _c, _d;
         this.rows = new Map();
-        if (withColumnDefs) {
+        if (withColumnDefs && !this.keepColDefsOnClearRowData) {
             (_b = (_a = this.gridTabulator) === null || _a === void 0 ? void 0 : _a.grid) === null || _b === void 0 ? void 0 : _b.setColumns([]);
         }
         (_d = (_c = this.gridTabulator) === null || _c === void 0 ? void 0 : _c.grid) === null || _d === void 0 ? void 0 : _d.clearData();
     }
+    /**
+     * Handles errors by emitting an error event
+     */
+    handleErrors(errors) {
+        let message;
+        if (Array.isArray(errors)) {
+            const stringArray = errors.map((item) => {
+                if (typeof item === 'string') {
+                    return item;
+                }
+                else if (typeof item === 'object' && item !== null && 'TEXT' in item) {
+                    return item.TEXT;
+                }
+                else {
+                    throw new Error('Array contains invalid elements');
+                }
+            });
+            message = stringArray.join(', ');
+        }
+        else {
+            message = errors;
+        }
+        if (this.gridTabulator) {
+            this.gridTabulator.setAttribute('ds-disconnected', 'ds-disconnected');
+        }
+        if (message) {
+            logger.error(message);
+            this.$emit(gridTabulatorEventNames.error, { message });
+        }
+    }
     /**
      * Sets the columnDefs and rowData for the grid.
      * @remarks This should only happen once, when the grid is first initialized. Follow up updates will use the agTransaction.
      * @internal
      */
     setRowData(rowData) {
-        const agColumnDefs = null; // this.getAgColumnDefs(this.datasource.fieldMetadata);
-        if (agColumnDefs) {
-            this.gridTabulator.grid.setColumns(agColumnDefs);
-        }
-        const data = this.rowDataMapper ? this.rowDataMapper(rowData) : rowData;
-        this.gridTabulator.grid.setData(data);
-        this.requiresFullRowDataAndColDefs = false;
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const preExistingColumns = (_a = this.gridTabulator.grid) === null || _a === void 0 ? void 0 : _a.getColumns();
+            if (!preExistingColumns || preExistingColumns.length === 0) {
+                const columnDefs = yield this.getColumnDefs(this.datasource.fieldMetadata);
+                if (columnDefs) {
+                    this.gridTabulator.grid.setColumns(columnDefs);
+                }
+            }
+            const data = this.rowDataMapper ? this.rowDataMapper(rowData) : rowData;
+            this.gridTabulator.grid.setData(data);
+            this.requiresFullRowDataAndColDefs = false;
+        });
+    }
+    /**
+     * Generate column definitions from the field metadata
+     * @param fieldsMetadata - The field metadata to generate column definitions from
+     */
+    getColumnDefs(fieldsMetadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columnDefsFromMetadata = fieldsMetadata === null || fieldsMetadata === void 0 ? void 0 : fieldsMetadata.map((field) => {
+                const columnDef = {
+                    field: field.name,
+                    title: field.name, // Default title is the field name
+                };
+                // Apply field-specific configurations
+                switch (field.type) {
+                    case FieldTypeEnum.BOOLEAN:
+                        if (this.gridTabulator.autoCellRendererByType) {
+                            columnDef.formatter = 'boolean';
+                        }
+                        break;
+                    case FieldTypeEnum.DATE:
+                        columnDef.formatter = (cell) => dateValueFormatter({ value: cell.getValue() });
+                        break;
+                    case FieldTypeEnum.DATETIME:
+                        columnDef.formatter = (cell) => dateTimeValueFormatter({ value: cell.getValue() });
+                        break;
+                    default:
+                        break;
+                }
+                return columnDef;
+            });
+            // Merge with any saved column state
+            if (this.deferredColumnStates && this.deferredColumnStates.length > 0) {
+                return mergeAndDedupColDefWithColumnState(columnDefsFromMetadata, this.deferredColumnStates);
+            }
+            return columnDefsFromMetadata;
+        });
     }
     /**
      * Resets the grid data while keeping columnDefs and sends a DATA_LOGOFF message if it's a stream.
@@ -244,37 +334,56 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
     loadResourceData(withFullInit = true) {
         return __awaiter(this, void 0, void 0, function* () {
             const requiresMetadataFetch = withFullInit || !this.datasource.initialized;
-            const initOK = yield this.datasource.init(this.datasourceOptions(), requiresMetadataFetch);
-            if (!initOK) {
-                logger.debug(`Genesis Datasource init failed for ${this.resourceName}`);
-                this.clearRowData();
-                return;
-            }
-            if (this.isSnapshot) {
-                const result = yield this.datasource.snapshot();
-                if (result) {
-                    const rowData = this.handleSnapshot(result);
-                    this.setRowData(rowData);
-                }
-                return;
-            }
-            logger.debug(`requesting stream for ${this.resourceName}`);
-            this.dataSub = this.datasource.stream.subscribe((result) => {
-                this.sourceRef = result.SOURCE_REF;
-                const messageType = result.MESSAGE_TYPE;
-                if (messageType && messageType === MessageType.LOGOFF_ACK) {
-                    this.dataSubWasLoggedOff = true;
+            try {
+                const initOK = yield this.datasource.init(this.datasourceOptions(), requiresMetadataFetch);
+                if (!initOK) {
+                    logger.debug(`Genesis Datasource init failed for ${this.resourceName}`);
+                    this.clearRowData();
+                    this.handleErrors(`Genesis Datasource init failed for ${this.resourceName}`);
                     return;
                 }
-                this.dataSubWasLoggedOff = false;
-                if (result.ROW) {
-                    const nextMessage = dataServerResultFilter(result);
-                    this.handleStreamResult(nextMessage);
+                this.$emit('dataInit');
+                if (this.isSnapshot) {
+                    const result = yield this.datasource.snapshot();
+                    if (result) {
+                        const rowData = this.handleSnapshot(result);
+                        this.setRowData(rowData);
+                    }
+                    return;
                 }
-                else {
-                    this.handleStreamResult(result);
+                logger.debug(`requesting stream for ${this.resourceName}`);
+                this.dataSub = this.datasource.stream.subscribe((result) => {
+                    if (result === null || result === void 0 ? void 0 : result.ERROR) {
+                        this.handleErrors(result.ERROR);
+                        return;
+                    }
+                    this.sourceRef = result.SOURCE_REF;
+                    const messageType = result.MESSAGE_TYPE;
+                    if (messageType && messageType === MessageType.LOGOFF_ACK) {
+                        this.dataSubWasLoggedOff = true;
+                        return;
+                    }
+                    this.dataSubWasLoggedOff = false;
+                    if (result.ROW) {
+                        const nextMessage = dataServerResultFilter(result);
+                        this.handleStreamResult(nextMessage);
+                    }
+                    else {
+                        this.handleStreamResult(result);
+                    }
+                }, (error) => {
+                    logger.error('Stream error:', error);
+                    this.handleErrors((error === null || error === void 0 ? void 0 : error.message) || 'Stream error occurred');
+                });
+            }
+            catch (error) {
+                let errorMessage = (error === null || error === void 0 ? void 0 : error.message) || 'Unknown error occurred';
+                if (error.receivedMessage) {
+                    errorMessage = error.receivedMessage.ERROR;
                 }
-            });
+                logger.error(errorMessage);
+                this.handleErrors(errorMessage);
+            }
         });
     }
     handleSnapshot(result) {
@@ -315,6 +424,7 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
     }
     applyRequestServerData(requestServerResult) {
         var _a;
+        const previousSize = this.rows.size;
         const requestServerData = requestServerResult.REPLY;
         if (!Array.isArray(requestServerData) ||
             !((_a = requestServerResult.MESSAGE_TYPE) === null || _a === void 0 ? void 0 : _a.startsWith('REP_'))) {
@@ -322,10 +432,26 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
             return;
         }
         if (this.requiresFullRowDataAndColDefs) {
+            let noRowIdError = false;
             requestServerData === null || requestServerData === void 0 ? void 0 : requestServerData.forEach((insertData) => {
-                this.rows.set(insertData[this.rowId], insertData);
+                const insertDataRowId = insertData[this.rowId];
+                if (!insertDataRowId) {
+                    if (!noRowIdError) {
+                        const noRowIdMessage = `The specified rowId (${this.rowId}) is not present in the data. Since this is not a snapshot (isSnapshot=false), the data will not be loaded. Please provide a valid 'row-id' attribute.`;
+                        logger.error(noRowIdMessage);
+                        this.handleErrors(noRowIdMessage);
+                        noRowIdError = true;
+                    }
+                    return;
+                }
+                this.rows.set(insertDataRowId, insertData);
             });
+            if (noRowIdError) {
+                this.destroy();
+                return;
+            }
             const rowData = this.rows.size > 0 ? Array.from(this.rows.values()) : requestServerData;
+            this.handleSizeChanged(previousSize, this.rows.size);
             this.setRowData(rowData);
             return;
         }
@@ -344,15 +470,18 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
         this.handleStreamDeletes(rowsToDelete);
         this.handleStreamUpdates(rowsToUpdate);
         this.applyTransaction();
+        this.handleSizeChanged(previousSize, this.rows.size);
     }
     applyDataserverData(dataServerResult) {
         var _a;
+        const previousSize = this.rows.size;
         if (this.requiresFullRowDataAndColDefs) {
             (_a = dataServerResult.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
                 this.rows.set(insertData[this.rowId], insertData);
             });
             const rowData = Array.from(this.rows.values());
             this.setRowData(rowData);
+            this.handleSizeChanged(previousSize, this.rows.size);
             return;
         }
         this.gridTransaction = { add: [], remove: [], update: [] };
@@ -360,6 +489,7 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
         this.handleStreamDeletes(dataServerResult.deletes);
         this.handleStreamUpdates(dataServerResult.updates);
         this.applyTransaction();
+        this.handleSizeChanged(previousSize, this.rows.size);
     }
     applyTransaction() {
         var _a, _b;
@@ -369,6 +499,19 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
         }
         if (((_b = transaction.update) === null || _b === void 0 ? void 0 : _b.length) > 0) {
             this.gridTabulator.grid.updateData(transaction.update);
+            // Apply row flashing if enabled
+            if (this.gridTabulator.enableRowFlashing) {
+                transaction.update.forEach((row) => {
+                    const rowElement = this.gridTabulator.grid.getRow(row[this.rowId]);
+                    if (rowElement) {
+                        // Apply flash effect by adding a CSS class and then removing it
+                        rowElement.getElement().classList.add('tabulator-row-flash');
+                        setTimeout(() => {
+                            rowElement.getElement().classList.remove('tabulator-row-flash');
+                        }, DEBOUNCE_INTERVAL_MS);
+                    }
+                });
+            }
         }
         transaction.remove.forEach((toRemove) => {
             this.gridTabulator.grid.deleteRow(toRemove[this.rowId]);
@@ -422,41 +565,17 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
             this.rows.set(updateData[this.rowId], updatedRow);
         });
     }
-    // FUTURE: Work with the field types vs ag grid column def types!
-    // private getAgColumnDefs(fieldsMetadata: FieldMetadata[]) {
-    //   const colDefsFromGenesisData: ColDef[] = fieldsMetadata?.flatMap((field: FieldMetadata) => {
-    //     const cellConfigs: ColDef = {};
-    //     cellConfigs.filterParams = getFilterParamsByFieldType(field.type);
-    //     switch (field.type) {
-    //       case FieldTypeEnum.BOOLEAN:
-    //         if (this.gridTabulator.autoCellRendererByType) {
-    //           cellConfigs.cellRenderer = GridTabulatorCellRendererTypes.boolean;
-    //         }
-    //         break;
-    //       case FieldTypeEnum.DATE:
-    //         cellConfigs.valueFormatter = dateValueFormatter;
-    //         break;
-    //       case FieldTypeEnum.DATETIME:
-    //         cellConfigs.valueFormatter = dateTimeValueFormatter;
-    //         break;
-    //       default:
-    //         break;
-    //     }
-    //     const templateColDef = this.gridTabulator.gridApi?.getColumnDef(field.name);
-    //     if (this.gridTabulator.onlyTemplateColDefs && !templateColDef) {
-    //       return [];
-    //     }
-    //     if (this.fields && !this.fields.includes(field.name)) {
-    //       return [];
-    //     }
-    //     return { field: field.name, ...cellConfigs, ...templateColDef };
-    //   });
-    //   const colDefsMergedWithTemplateDefs = this.gridTabulator.mergeAllColumnDefsAndStates(
-    //     colDefsFromGenesisData,
-    //     true,
-    //   );
-    //   return colDefsMergedWithTemplateDefs;
-    // }
+    /**
+     * Emit event when the number of rows changes
+     */
+    handleSizeChanged(oldSize, newSize) {
+        if (oldSize === newSize)
+            return;
+        this.$emit('sizeChanged', {
+            value: newSize,
+            oldValue: oldSize,
+        });
+    }
     buildCriteria() {
         var _a;
         const initialCriteria = ((_a = this.criteria) === null || _a === void 0 ? void 0 : _a.split(criteriaDelimiter)) || [];
@@ -471,6 +590,9 @@ let GridTabulatorClientSideDatasource = class GridTabulatorClientSideDatasource
         this.criteriaFromFilters.delete(fieldName);
         this.update.next(this.criteriaFromFilters);
     }
+    datasourceStatusChanged(prev, next) {
+        this.isRequestServer = next.type === ResourceType.REQUEST_SERVER;
+    }
 };
 __decorate([
     Auth
@@ -484,6 +606,9 @@ __decorate([
 __decorate([
     observable
 ], GridTabulatorClientSideDatasource.prototype, "deferredGridOptions", void 0);
+__decorate([
+    observable
+], GridTabulatorClientSideDatasource.prototype, "deferredColumnStates", void 0);
 __decorate([
     attr
 ], GridTabulatorClientSideDatasource.prototype, "criteria", void 0);
@@ -523,6 +648,9 @@ __decorate([
 __decorate([
     attr({ mode: 'boolean', attribute: 'restart-on-reconnection' })
 ], GridTabulatorClientSideDatasource.prototype, "restartOnReconnection", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'keep-col-defs-on-clear-row-data' })
+], GridTabulatorClientSideDatasource.prototype, "keepColDefsOnClearRowData", void 0);
 __decorate([
     observable
 ], GridTabulatorClientSideDatasource.prototype, "rowDataMapper", void 0);

package/dist/esm/grid-tabulator.components.js

@@ -1,20 +1,33 @@
-import { foundationGridTabulatorActionRenderer,
-// foundationGridProActionsMenuRenderer,
-// foundationAgBooleanRenderer,
-// foundationAgSelectRenderer,
-// foundationAgTextRenderer,
- } from './cell-renderers';
+import { GridTabulatorCell } from './cell/cell';
+import { foundationDateEditor } from './cell-editors/date.editor';
+import { foundationMultiselectEditor } from './cell-editors/multiselect.editor';
+import { foundationNumberEditor } from './cell-editors/number.editor';
+import { foundationSelectEditor } from './cell-editors/select.editor';
+import { foundationStringEditor } from './cell-editors/string.editor';
+import { GridTabulatorColumn } from './column/column';
 import { foundationGridTabulator } from './grid-tabulator';
+// Create component registration functions
+const foundationGridTabulatorColumn = GridTabulatorColumn.compose({
+    baseName: 'grid-tabulator-column',
+});
+const foundationGridTabulatorCell = GridTabulatorCell.compose({
+    baseName: 'grid-tabulator-cell',
+});
 /**
  * All `grid-tabulator` components.
  * @public
  */
 export const foundationGridTabulatorComponents = {
-    foundationGridTabulatorActionRenderer,
-    // foundationGridProActionsMenuRenderer,
-    // foundationAgBooleanRenderer,
-    // foundationAgTextRenderer,
-    // foundationAgSelectRenderer,
+    // Cell editors
+    foundationDateEditor,
+    foundationNumberEditor,
+    foundationSelectEditor,
+    foundationStringEditor,
+    foundationMultiselectEditor,
+    // Column components
+    foundationGridTabulatorColumn,
+    foundationGridTabulatorCell,
+    // Grid component
     foundationGridTabulator,
     register(container, ...rest) {
         if (!container) {

package/dist/esm/grid-tabulator.definitions.js

@@ -1,4 +1,34 @@
 import { formatDateTimestamp, formatDateTimeTimestamp } from '@genesislcap/foundation-utils';
+/**
+ * Event names for grid-tabulator
+ * @alpha
+ */
+export const gridTabulatorEventNames = {
+    error: 'gridTabulator:error',
+    datasourceErrorClose: 'gridTabulator:datasourceErrorClose',
+};
+/**
+ * Error types for grid-tabulator
+ * @alpha
+ */
+export const gridTabulatorErrorNames = {
+    datasource: 'datasource',
+};
+/**
+ * The special column field name for marking a cell as edited
+ * @alpha
+ */
+export const EDITED_COLUMN_FIELD = '__EDITED_FIELD__';
+/**
+ * The special column field name for marking a cell as having an error
+ * @alpha
+ */
+export const ERROR_COLUMN_FIELD = '__ERROR_FIELD__';
+/**
+ * Time in milliseconds to debounce resize events
+ * @alpha
+ */
+export const DEBOUNCED_RESIZE_TIME = 400;
 /**
  * Get the filter type based on the field type.
  * @param type - The field type.