@tylertech/forge 2.0.0

package/esm/table/multi-sort-manager.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { SortDirection } from './types';
+export class MultiSortManager {
+    constructor() {
+        this._sortedColumns = [];
+    }
+    get sortedColumns() {
+        return [...this._sortedColumns.map(c => (Object.assign({}, c)))];
+    }
+    addSortColumn(column) {
+        this._sortedColumns.push(Object.assign({}, column));
+        this._updateSortNumbers();
+    }
+    updateSortColumn(column) {
+        const col = this._sortedColumns.find(c => c.columnIndex === column.columnIndex);
+        if (col) {
+            switch (col.direction) {
+                case SortDirection.Ascending:
+                    this.removeSortColumn(column);
+                    break;
+                case SortDirection.Descending:
+                    col.direction = SortDirection.Ascending;
+                    break;
+                case SortDirection.Unset:
+                    col.direction = SortDirection.Descending;
+                    break;
+            }
+        }
+    }
+    setSortColumns(columns) {
+        this._sortedColumns = [...columns.map(c => (Object.assign({}, c)))];
+    }
+    removeSortColumn(columnOrIndex) {
+        if (typeof columnOrIndex === 'number') {
+            this._sortedColumns.splice(columnOrIndex, 1);
+        }
+        else {
+            this._sortedColumns.splice(this._sortedColumns.indexOf(columnOrIndex), 1);
+        }
+        this._updateSortNumbers();
+    }
+    isSortColumn(columnOrIndex) {
+        if (typeof columnOrIndex === 'number') {
+            return this._sortedColumns.some(c => c.columnIndex === columnOrIndex);
+        }
+        else {
+            return this._sortedColumns.includes(columnOrIndex);
+        }
+    }
+    clearMultiSort() {
+        this._sortedColumns = [];
+    }
+    getSortColumn(columnIndex) {
+        return this._sortedColumns.find(c => c.columnIndex === columnIndex);
+    }
+    _updateSortNumbers() {
+        // only do a real sort if every sortNumber is actually a number
+        if (this._sortedColumns.every(c => typeof c.sortOrder === 'number')) {
+            this._sortedColumns.sort((col1, col2) => col1.sortOrder - col2.sortOrder);
+        }
+        this._sortedColumns.forEach((column, index) => column.sortOrder = index + 1);
+    }
+}

package/esm/table/table-adapter.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { BaseAdapter, IBaseAdapter } from '../core/base/base-adapter';
+import { ITableComponent } from './table';
+import { CellAlign, ITableConfiguration, SortDirection, TableHeaderSelectAllTemplate, TableViewTemplate, TableSelectTooltipCallback } from './types';
+import { TableRow } from './table-row';
+export interface ITableAdapter extends IBaseAdapter {
+    initialize: () => void;
+    getTableElement: () => HTMLTableElement;
+    createTable: (configuration: ITableConfiguration) => void;
+    recreateTableBody: (configuration: ITableConfiguration) => void;
+    setSelectedRows: (tableElement: HTMLTableElement, key: string[], data: any[], selectedRows: any[], preserveExisting?: boolean) => void;
+    clearSelectedRows: (tableElement: HTMLTableElement) => void;
+    updateSelectedState: (rowElement: HTMLTableRowElement, isSelected: boolean) => void;
+    updateSelectAllState: (tableElement: HTMLTableElement, isAllSelected: boolean, isIndeterminate?: boolean) => void;
+    setSortedColumn: (tableElement: HTMLTableElement, columnIndex: number, sortDirection: SortDirection) => void;
+    removeColumnSort: (tableElement: HTMLTableElement, columnIndex: number) => void;
+    setSortDirection: (tableElement: HTMLTableElement, columnIndex: number, sortDirection: SortDirection) => void;
+    setSelectColumnVisibility: (tableElement: HTMLTableElement, isVisible: boolean, selectListener: (evt: Event) => void, selectAllListener?: (evt: Event) => void, selectAllTemplate?: TableHeaderSelectAllTemplate | null, selectCheckboxAlignment?: CellAlign, data?: TableRow[], tooltipSelect?: string | TableSelectTooltipCallback, tooltipSelectAll?: string) => void;
+    setDense: (tableElement: HTMLTableElement, isDense: boolean) => void;
+    setRoomy(tableElement: HTMLTableElement, isRoomy: boolean): void;
+    setResizable: (configuration: ITableConfiguration) => void;
+    setSelectAllVisibility: (tableElement: HTMLTableElement, isVisible: boolean, listener: ((evt: Event) => void) | null, selectAllTemplate: TableHeaderSelectAllTemplate | null, selectCheckboxAlignment?: CellAlign, tooltipSelectAll?: string) => void;
+    setFilterRow: (configuration: ITableConfiguration) => void;
+    expandRow(configuration: ITableConfiguration, rowIndex: number, template: TableViewTemplate): Promise<void>;
+    collapseRow(configuration: ITableConfiguration, rowIndex: number): Promise<void>;
+    isRowExpanded(configuration: ITableConfiguration, rowIndex: number): boolean;
+    setFixedHeaders(configuration: ITableConfiguration): void;
+    setTableLayoutType(configuration: ITableConfiguration): void;
+    setWrapContentState(configuration: ITableConfiguration): void;
+    addDocumentListener(type: string, listener: (evt: MouseEvent) => void): void;
+    removeDocumentListener(type: string, listener: (evt: MouseEvent) => void): void;
+    normalizeColumnWidths(configuration: ITableConfiguration): void;
+    setResizeColumnVisibility(configuration: ITableConfiguration, columnIndex: number, isVisible: boolean): void;
+    addTableClass(classes: string | string[]): void;
+    removeTableClass(classes: string | string[]): void;
+    setRowClickListeners(tableElement: HTMLTableElement, allowClick: boolean, clickListener: (evt: Event) => void, doubleClickListener: (evt: Event) => void): void;
+    setRowClickAttributes(tableElement: HTMLTableElement, allowClick: boolean): void;
+}
+/**
+ * Provides facilities for interacting with the internal DOM of `TableComponent`.
+ */
+export declare class TableAdapter extends BaseAdapter<ITableComponent> implements ITableAdapter {
+    private _tableElement;
+    constructor(component: ITableComponent);
+    initialize(): void;
+    getTableElement(): HTMLTableElement;
+    createTable(configuration: ITableConfiguration): void;
+    recreateTableBody(configuration: ITableConfiguration): void;
+    setSelectedRows(tableElement: HTMLTableElement, key: string[], data: any[], selectedRows: any[], preserveExisting?: boolean): void;
+    clearSelectedRows(tableElement: HTMLTableElement): void;
+    updateSelectedState(rowElement: HTMLTableRowElement, isSelected: boolean): void;
+    updateSelectAllState(tableElement: HTMLTableElement, isAllSelected: boolean, isIndeterminate?: boolean): void;
+    setSortedColumn(tableElement: HTMLTableElement, columnIndex: number, sortDirection: SortDirection): void;
+    removeColumnSort(tableElement: HTMLTableElement, columnIndex: number): void;
+    setSortDirection(tableElement: HTMLTableElement, columnIndex: number, sortDirection: SortDirection): void;
+    setSelectColumnVisibility(tableElement: HTMLTableElement, isVisible: boolean, selectListener: (evt: Event) => void, selectAllListener?: (evt: Event) => void, selectAllTemplate?: TableHeaderSelectAllTemplate | null, selectCheckboxAlignment?: CellAlign, data?: TableRow[], tooltipSelect?: string | TableSelectTooltipCallback, tooltipSelectAll?: string): void;
+    setDense(tableElement: HTMLTableElement, isDense: boolean): void;
+    setRoomy(tableElement: HTMLTableElement, isRoomy: boolean): void;
+    setResizable(configuration: ITableConfiguration): void;
+    setSelectAllVisibility(tableElement: HTMLTableElement, isVisible: boolean, listener: ((evt: Event) => void) | null, selectAllTemplate: TableHeaderSelectAllTemplate | null, selectCheckboxAlignment?: CellAlign, tooltipSelectAll?: string | null): void;
+    setFilterRow(configuration: ITableConfiguration): void;
+    expandRow(configuration: ITableConfiguration, rowIndex: number, template: TableViewTemplate): Promise<void>;
+    collapseRow(configuration: ITableConfiguration, rowIndex: number): Promise<void>;
+    isRowExpanded(configuration: ITableConfiguration, rowIndex: number): boolean;
+    setFixedHeaders(configuration: ITableConfiguration): void;
+    setTableLayoutType(configuration: ITableConfiguration): void;
+    setWrapContentState(configuration: ITableConfiguration): void;
+    addDocumentListener(type: string, listener: (evt: MouseEvent) => void): void;
+    removeDocumentListener(type: string, listener: (evt: MouseEvent) => void): void;
+    normalizeColumnWidths(configuration: ITableConfiguration): void;
+    setResizeColumnVisibility(configuration: ITableConfiguration, columnIndex: number, isVisible: boolean): void;
+    addTableClass(classes: string | string[]): void;
+    removeTableClass(classes: string | string[]): void;
+    setRowClickListeners(tableElement: HTMLTableElement, allowClick: boolean, clickListener: (evt: Event) => void, doubleClickListener: (evt: Event) => void): void;
+    setRowClickAttributes(tableElement: HTMLTableElement, allowClick: boolean): void;
+}

package/esm/table/table-adapter.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { addClass, removeAllChildren, removeClass } from '@tylertech/forge-core';
+import { BaseAdapter } from '../core/base/base-adapter';
+import { TABLE_CONSTANTS } from './table-constants';
+import { TableUtils } from './table-utils';
+/**
+ * Provides facilities for interacting with the internal DOM of `TableComponent`.
+ */
+export class TableAdapter extends BaseAdapter {
+    constructor(component) {
+        super(component);
+    }
+    initialize() {
+        if (!this._tableElement) {
+            this._tableElement = document.createElement('table');
+            this._tableElement.classList.add(TABLE_CONSTANTS.classes.TABLE);
+            if (this._component.children.length) {
+                removeAllChildren(this._component);
+            }
+            this._component.appendChild(this._tableElement);
+        }
+    }
+    getTableElement() {
+        if (!this._tableElement) {
+            this.initialize();
+        }
+        return this._tableElement;
+    }
+    createTable(configuration) {
+        return TableUtils.createTable(configuration);
+    }
+    recreateTableBody(configuration) {
+        TableUtils.recreateTableBody(configuration);
+    }
+    setSelectedRows(tableElement, key, data, selectedRows, preserveExisting = false) {
+        TableUtils.setSelectedRows(tableElement, key, data, selectedRows, preserveExisting);
+    }
+    clearSelectedRows(tableElement) {
+        TableUtils.clearSelectedRows(tableElement);
+    }
+    updateSelectedState(rowElement, isSelected) {
+        TableUtils.updateSelectedState(rowElement, isSelected);
+    }
+    updateSelectAllState(tableElement, isAllSelected, isIndeterminate) {
+        TableUtils.updateSelectAllState(tableElement, isAllSelected, isIndeterminate);
+    }
+    setSortedColumn(tableElement, columnIndex, sortDirection) {
+        TableUtils.setSortedColumn(tableElement, columnIndex, sortDirection);
+    }
+    removeColumnSort(tableElement, columnIndex) {
+        TableUtils.removeColumnSort(tableElement, columnIndex);
+    }
+    setSortDirection(tableElement, columnIndex, sortDirection) {
+        TableUtils.setSortDirection(tableElement, columnIndex, sortDirection);
+    }
+    setSelectColumnVisibility(tableElement, isVisible, selectListener, selectAllListener, selectAllTemplate, selectCheckboxAlignment, data, tooltipSelect, tooltipSelectAll) {
+        TableUtils.setSelectColumnVisibility(tableElement, isVisible, selectListener, selectAllListener || null, selectAllTemplate || null, selectCheckboxAlignment || null, data || [], tooltipSelect || null, tooltipSelectAll || null);
+    }
+    setDense(tableElement, isDense) {
+        TableUtils.setDenseState(tableElement, isDense);
+    }
+    setRoomy(tableElement, isRoomy) {
+        TableUtils.setRoomyState(tableElement, isRoomy);
+    }
+    setResizable(configuration) {
+        TableUtils.setResizable(configuration);
+    }
+    setSelectAllVisibility(tableElement, isVisible, listener, selectAllTemplate, selectCheckboxAlignment, tooltipSelectAll = null) {
+        TableUtils.setSelectAllVisibility(tableElement, isVisible, listener, selectAllTemplate, selectCheckboxAlignment || null, tooltipSelectAll || null);
+    }
+    setFilterRow(configuration) {
+        TableUtils.setFilterRow(configuration);
+    }
+    expandRow(configuration, rowIndex, template) {
+        return TableUtils.expandRow(configuration, rowIndex, template);
+    }
+    collapseRow(configuration, rowIndex) {
+        return TableUtils.collapseRow(configuration, rowIndex);
+    }
+    isRowExpanded(configuration, rowIndex) {
+        return TableUtils.isRowExpanded(configuration, rowIndex);
+    }
+    setFixedHeaders(configuration) {
+        TableUtils.setFixedHeaders(configuration);
+    }
+    setTableLayoutType(configuration) {
+        TableUtils.setLayoutType(configuration);
+    }
+    setWrapContentState(configuration) {
+        TableUtils.setWrapContentState(configuration.tableElement, configuration.wrapContent);
+    }
+    addDocumentListener(type, listener) {
+        TableUtils.getOwnerDocument(this._component).addEventListener(type, listener);
+    }
+    removeDocumentListener(type, listener) {
+        TableUtils.getOwnerDocument(this._component).removeEventListener(type, listener);
+    }
+    normalizeColumnWidths(configuration) {
+        TableUtils.normalizeColumnWidths(configuration);
+    }
+    setResizeColumnVisibility(configuration, columnIndex, isVisible) {
+        TableUtils.setColumnResizeIndicatorVisibility(configuration, columnIndex, isVisible);
+    }
+    addTableClass(classes) {
+        addClass(classes, this._tableElement);
+    }
+    removeTableClass(classes) {
+        removeClass(classes, this._tableElement);
+    }
+    setRowClickListeners(tableElement, allowClick, clickListener, doubleClickListener) {
+        TableUtils.setRowClickListeners(tableElement, allowClick, clickListener, doubleClickListener);
+    }
+    setRowClickAttributes(tableElement, allowClick) {
+        TableUtils.setRowClickAttributes(tableElement, allowClick);
+    }
+}

package/esm/table/table-constants.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+export declare const TABLE_CONSTANTS: {
+    elementName: "forge-table";
+    classes: {
+        TABLE: string;
+        TABLE_DENSE: string;
+        TABLE_ROOMY: string;
+        TABLE_RESIZABLE: string;
+        TABLE_RESIZING: string;
+        TABLE_RESIZE_HANDLE: string;
+        TABLE_NO_WRAP_CONTENT: string;
+        TABLE_LAYOUT_FIXED: string;
+        TABLE_FILTER_VISIBLE: string;
+        TABLE_FIXED: string;
+        TABLE_HEAD: string;
+        TABLE_HEAD_ROW: string;
+        TABLE_HEAD_ROW_FILTER: string;
+        TABLE_HEAD_CELL: string;
+        TABLE_HEAD_CELL_CONTAINER: string;
+        TABLE_HEAD_CELL_SORTABLE: string;
+        TABLE_HEAD_CELL_SORT_ICON: string;
+        TABLE_HEAD_CELL_TEXT: string;
+        TABLE_HEAD_CELL_SORT_ICON_ACTIVE: string;
+        TABLE_HEAD_CELL_SORTED_ASCENDING: string;
+        TABLE_HEAD_CELL_SORTED_DESCENDING: string;
+        TABLE_HEAD_CELL_SORT_ORDER: string;
+        TABLE_HEAD_CELL_SORT_ORDER_HIDDEN: string;
+        TABLE_BODY: string;
+        TABLE_BODY_ROW: string;
+        TABLE_BODY_ROW_SELECTED: string;
+        TABLE_BODY_ROW_CLICKABLE: string;
+        TABLE_BODY_CELL: string;
+        TABLE_ROW: string;
+        TABLE_ROW_EXPANDED: string;
+        TABLE_ROW_EXPANDABLE_CONTENT: string;
+        TABLE_ROW_EXPANDABLE_CONTENT_CELL: string;
+        TABLE_CELL: string;
+        TABLE_CELL_SELECT: string;
+        TABLE_CELL_SELECT_CHECKBOX: string;
+        TABLE_CELL_SELECT_CHECKBOX_CONTAINER: string;
+        TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_RIGHT: string;
+        TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_LEFT: string;
+        TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_CENTER: string;
+        TABLE_CELL_CONTAINER: string;
+        TABLE_CELL_CONTAINER_TEXT: string;
+        TABLE_CELL_CENTER: string;
+        TABLE_CELL_RIGHT: string;
+        TABLE_CELL_RESIZABLE: string;
+    };
+    selectors: {
+        TABLE: string;
+        CHECKBOX_INPUT: string;
+        SELECT_ALL_TEMPLATE_CHECKBOX_INPUT: string;
+        ROW_SELECTED: string;
+    };
+    attributes: {
+        SELECT: string;
+        MULTISELECT: string;
+        SELECT_KEY: string;
+        DENSE: string;
+        ROOMY: string;
+        FILTER: string;
+        FIXED_HEADERS: string;
+        LAYOUT_TYPE: string;
+        WRAP_CONTENT: string;
+        RESIZABLE: string;
+        MIN_RESIZE_WIDTH: string;
+        ALLOW_ROW_CLICK: string;
+        MULTI_COLUMN_SORT: string;
+        SELECT_CHECKBOX_ALIGNMENT: string;
+        TOOLTIP_SELECT: string;
+        TOOLTIP_SELECT_ALL: string;
+        CHECKBOX_TYPE: string;
+        CUSTOM_CELL_TEMPLATE: string;
+        CUSTOM_CELL_TEMPLATE_STOP_PROPAGATION: string;
+    };
+    events: {
+        ROW_CLICK: string;
+        SELECT: string;
+        SELECT_DOUBLE: string;
+        SELECT_ALL: string;
+        SORT: string;
+        FILTER: string;
+        INITIALIZED: string;
+        COLUMN_RESIZE: string;
+    };
+    strings: {
+        SELECT_ALL: string;
+        SELECT_ROW: string;
+        DEFAULT_LAYOUT_TYPE: string;
+    };
+    icons: {
+        SORT_DOWN: string;
+    };
+    numbers: {
+        DEFAULT_FILTER_DEBOUNCE_TIME: number;
+        MIN_RESIZE_WIDTH: number;
+        RESIZE_HOVER_DURATION: number;
+    };
+};

package/esm/table/table-constants.js

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { COMPONENT_NAME_PREFIX } from '../constants';
+const elementName = `${COMPONENT_NAME_PREFIX}table`;
+const classes = {
+    TABLE: 'forge-table',
+    TABLE_DENSE: 'forge-table--dense',
+    TABLE_ROOMY: 'forge-table--roomy',
+    TABLE_RESIZABLE: 'forge-table--resizable',
+    TABLE_RESIZING: 'forge-table--resizing',
+    TABLE_RESIZE_HANDLE: 'forge-table__resize-handle',
+    TABLE_NO_WRAP_CONTENT: 'forge-table--no-wrap-content',
+    TABLE_LAYOUT_FIXED: 'forge-table--layout-fixed',
+    TABLE_FILTER_VISIBLE: 'forge-table--filter-visible',
+    TABLE_FIXED: 'forge-table--fixed',
+    TABLE_HEAD: 'forge-table-head',
+    TABLE_HEAD_ROW: 'forge-table-head__row',
+    TABLE_HEAD_ROW_FILTER: 'forge-table-head__row__filter',
+    TABLE_HEAD_CELL: 'forge-table-head__cell',
+    TABLE_HEAD_CELL_CONTAINER: 'forge-table-head__cell-container',
+    TABLE_HEAD_CELL_SORTABLE: 'forge-table-head__cell--sortable',
+    TABLE_HEAD_CELL_SORT_ICON: 'forge-table-head__cell-sort-icon',
+    TABLE_HEAD_CELL_TEXT: 'forge-table-head__cell-text',
+    TABLE_HEAD_CELL_SORT_ICON_ACTIVE: 'forge-table-head__cell-sort-icon--active',
+    TABLE_HEAD_CELL_SORTED_ASCENDING: 'forge-table-head__cell--sorted-ascending',
+    TABLE_HEAD_CELL_SORTED_DESCENDING: 'forge-table-head__cell--sorted-descending',
+    TABLE_HEAD_CELL_SORT_ORDER: 'forge-table-head__cell__sort-order',
+    TABLE_HEAD_CELL_SORT_ORDER_HIDDEN: 'forge-table-head__cell__sort-order--hidden',
+    TABLE_BODY: 'forge-table-body',
+    TABLE_BODY_ROW: 'forge-table-body__row',
+    TABLE_BODY_ROW_SELECTED: 'forge-table-body__row--selected',
+    TABLE_BODY_ROW_CLICKABLE: 'forge-table-body__row--clickable',
+    TABLE_BODY_CELL: 'forge-table-body__cell',
+    TABLE_ROW: 'forge-table-row',
+    TABLE_ROW_EXPANDED: 'forge-table-row--expanded',
+    TABLE_ROW_EXPANDABLE_CONTENT: 'forge-table-row__expandable-content',
+    TABLE_ROW_EXPANDABLE_CONTENT_CELL: 'forge-table-row__expandable-content-cell',
+    TABLE_CELL: 'forge-table-cell',
+    TABLE_CELL_SELECT: 'forge-table-cell__select',
+    TABLE_CELL_SELECT_CHECKBOX: 'forge-table-cell__select-checkbox',
+    TABLE_CELL_SELECT_CHECKBOX_CONTAINER: 'forge-table-cell__select-checkbox-container',
+    TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_RIGHT: 'forge-table-cell__select-checkbox-container--align-right',
+    TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_LEFT: 'forge-table-cell__select-checkbox-container--align-left',
+    TABLE_CELL_SELECT_CHECKBOX_CONTAINER_ALIGN_CENTER: 'forge-table-cell__select-checkbox-container--align-center',
+    TABLE_CELL_CONTAINER: 'forge-table-cell__container',
+    TABLE_CELL_CONTAINER_TEXT: 'forge-table-cell__container-text',
+    TABLE_CELL_CENTER: 'forge-table-cell--center',
+    TABLE_CELL_RIGHT: 'forge-table-cell--right',
+    TABLE_CELL_RESIZABLE: 'forge-table-cell--resizing'
+};
+const selectors = {
+    TABLE: '.forge-table',
+    CHECKBOX_INPUT: 'forge-checkbox > input[type=checkbox]:not([forge-ignore])',
+    SELECT_ALL_TEMPLATE_CHECKBOX_INPUT: 'input[type=checkbox]:not([forge-ignore])',
+    ROW_SELECTED: `.${classes.TABLE_BODY_ROW_SELECTED}`
+};
+const attributes = {
+    // External
+    SELECT: 'select',
+    MULTISELECT: 'multiselect',
+    SELECT_KEY: 'select-key',
+    DENSE: 'dense',
+    ROOMY: 'roomy',
+    FILTER: 'filter',
+    FIXED_HEADERS: 'fixed-headers',
+    LAYOUT_TYPE: 'layout-type',
+    WRAP_CONTENT: 'wrap-content',
+    RESIZABLE: 'resizable',
+    MIN_RESIZE_WIDTH: 'min-resize-width',
+    ALLOW_ROW_CLICK: 'allow-row-click',
+    MULTI_COLUMN_SORT: 'multi-column-sort',
+    SELECT_CHECKBOX_ALIGNMENT: 'select-checkbox-alignment',
+    TOOLTIP_SELECT: 'tooltip-select',
+    TOOLTIP_SELECT_ALL: 'tooltip-select-all',
+    // Internal
+    CHECKBOX_TYPE: 'forge-checkbox-type',
+    CUSTOM_CELL_TEMPLATE: 'data-cell-template',
+    CUSTOM_CELL_TEMPLATE_STOP_PROPAGATION: 'data-cell-template-stop-propagation'
+};
+const events = {
+    ROW_CLICK: `${elementName}-row-click`,
+    SELECT: `${elementName}-select`,
+    SELECT_DOUBLE: `${elementName}-select-double`,
+    SELECT_ALL: `${elementName}-select-all`,
+    SORT: `${elementName}-sort`,
+    FILTER: `${elementName}-filter`,
+    INITIALIZED: `${elementName}-initialized`,
+    COLUMN_RESIZE: `${elementName}-column-resize`
+};
+const strings = {
+    SELECT_ALL: 'select-all',
+    SELECT_ROW: 'select-row',
+    DEFAULT_LAYOUT_TYPE: 'auto'
+};
+const icons = {
+    SORT_DOWN: 'arrow_downward'
+};
+const numbers = {
+    DEFAULT_FILTER_DEBOUNCE_TIME: 750,
+    MIN_RESIZE_WIDTH: 100,
+    RESIZE_HOVER_DURATION: 150
+};
+export const TABLE_CONSTANTS = {
+    elementName,
+    classes,
+    selectors,
+    attributes,
+    events,
+    strings,
+    icons,
+    numbers
+};