slick-table 0.0.1

package/dist/shared/lib/slickgrid/model/SlickTable/printer/DefaultPrinter.js

@@ -0,0 +1,161 @@
+import moment from "moment";
+import { removeHtml } from "shared/lib/strings";
+// import { injectedStore } from "shared/model/store";
+import { getDisplayedRows } from "../../../lib";
+import { cssStyles } from "./model";
+export class DefaultPrinter {
+    constructor() {
+        this.cssStyles = cssStyles;
+    }
+    // protected get store() {
+    // 	return injectedStore;
+    // }
+    clientName() {
+        const result = document.createElement("tr");
+        // const { clientId, name: clientName } = this.store.getState().clientReducer;
+        // if (clientName) {
+        // 	const name = document.createElement("th");
+        // 	name.classList.add("align_left");
+        // 	name.setAttribute("colspan", "100%");
+        // 	name.innerText = `${clientName} [${clientId}]`;
+        // 	result.append(name);
+        // }
+        return result;
+    }
+    columnNames(table) {
+        const result = document.createElement("tr");
+        const grid = table.grid;
+        const columns = grid?.getColumns() || [];
+        const columnsFiltered = columns.filter((el) => el.forPrint);
+        columnsFiltered.forEach(({ name }) => {
+            const th = document.createElement("th");
+            th.classList.add("column_name");
+            if (typeof name === "string") {
+                th.innerText = name;
+            }
+            else {
+                th.innerText = " ";
+            }
+            result.append(th);
+        });
+        return result;
+    }
+    tableNameAndTime(table) {
+        const result = document.createElement("tr");
+        result.classList.add("heading");
+        const tableName = document.createElement("th");
+        tableName.setAttribute("colspan", "2");
+        tableName.classList.add("table_name");
+        tableName.innerText = table.name || table.id;
+        result.append(tableName);
+        const dateStamp = document.createElement("th");
+        dateStamp.setAttribute("colspan", "100%");
+        dateStamp.classList.add("date_stamp");
+        dateStamp.innerText = moment().format("MM/DD/YYYY h:mm A");
+        result.append(dateStamp);
+        return result;
+    }
+    createStyleElement() {
+        const result = document.createElement("style");
+        result.innerHTML = this.cssStyles;
+        return result;
+    }
+    createTableElement(table) {
+        const result = document.createElement("table");
+        result.append(this.createThead(table));
+        result.append(this.createTbody(table));
+        return result;
+    }
+    createTbody(table) {
+        const result = document.createElement("tbody");
+        const grid = table.grid;
+        if (!grid)
+            return result;
+        const columns = grid.getColumns();
+        const columnsFiltered = columns.filter((el) => el.forPrint);
+        const dataView = grid.getData();
+        const displayedRows = getDisplayedRows(dataView);
+        displayedRows.forEach((_row, rowIndex) => {
+            const tr = this.createTr(columnsFiltered, rowIndex, grid);
+            result.append(tr);
+        });
+        result.append(...this.totals(table));
+        return result;
+    }
+    filters(table) {
+        const result = [];
+        if (table.filter) {
+            const appliedFilters = table.filter.print(table);
+            if (appliedFilters.length) {
+                const tr = document.createElement("tr");
+                const th = document.createElement("th");
+                th.setAttribute("colspan", "100%");
+                th.classList.add("align_left");
+                th.innerText = "Applied filters";
+                tr.append(th);
+                result.push(tr);
+            }
+            appliedFilters.forEach((filter) => {
+                result.push(filter);
+            });
+        }
+        return result;
+    }
+    /** for tables with total calculations */
+    totals(_table) {
+        return [];
+    }
+    createThead(table) {
+        const result = document.createElement("thead");
+        result.append(this.clientName());
+        result.append(this.tableNameAndTime(table));
+        result.append(...this.filters(table));
+        result.append(this.columnNames(table));
+        return result;
+    }
+    createTr(columns, rowIndex, grid) {
+        const result = document.createElement("tr");
+        const dataView = grid.getData();
+        const row = dataView.getItem(rowIndex);
+        const isGroupTitle = row.__group;
+        const isGroupTotal = row.__groupTotals;
+        if (isGroupTitle) {
+            const td = document.createElement("td");
+            td.setAttribute("colspan", "100%");
+            td.innerText = removeHtml(row.title);
+            result.append(td);
+        }
+        else {
+            columns.forEach((column) => {
+                const td = document.createElement("td");
+                column.cssClass && td.classList.add(column.cssClass);
+                const field = column.field;
+                const metaData = dataView.getItemMetadata(rowIndex);
+                const formatterSpecific = metaData?.columns?.[field]?.formatter;
+                const formatter = column.printer || formatterSpecific || column.formatter;
+                let value = row[field];
+                if (isGroupTotal) {
+                    const totalsFormatter = column.groupTotalsFormatter;
+                    value = totalsFormatter ? totalsFormatter(row, column, grid) : "";
+                }
+                else if (formatter) {
+                    value = formatter(0, 0, value, column, row, grid);
+                }
+                td.innerText = value || "";
+                result.append(td);
+            });
+        }
+        return result;
+    }
+    print(table) {
+        const newTab = window.open();
+        const title = document.createElement("title");
+        title.innerText = table.name || table.id;
+        const head = newTab.document.querySelector("head");
+        head.append(title);
+        head.append(this.createStyleElement());
+        const body = newTab.document.querySelector("body");
+        body.append(this.createTableElement(table));
+        newTab.print();
+    }
+}

package/dist/shared/lib/slickgrid/model/SlickTable/printer/index.js

@@ -0,0 +1 @@
+export { DefaultPrinter } from "./DefaultPrinter";

package/dist/shared/lib/slickgrid/model/SlickTable/printer/model/Printer.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/model/SlickTable/printer/model/consts/cssStyles.js

@@ -0,0 +1,46 @@
+export const cssStyles = `
+		html body {
+			font-family: "Courier", "sans-serif";
+			font-size: 12px;
+		}
+		body table {
+			margin: 0 auto;
+			border-collapse: collapse;
+			font-size: 12px;
+		}
+		table thead {
+			border-bottom: 2px solid gray;
+		}
+		table th,
+		table td {
+			padding: 0 10px;
+			font-weight: normal;
+		}
+		table td.text-center {
+			text-align: center;
+		}
+		table td.text-right {
+			text-align: right;
+		}
+		.heading {
+			height: 30px;
+		}
+		.heading .table_name {
+			text-align: left;
+			padding-bottom: 20px;
+		}
+		.heading .date_stamp {
+			text-align: right;
+			padding-bottom: 20px;
+		}
+		.column_name {
+			padding-top: 1em;
+			font-weight: bold;
+		}
+		.align_right {
+			text-align: right;
+		}
+		.align_left {
+			text-align: left;
+		}
+	`;

package/dist/shared/lib/slickgrid/model/SlickTable/printer/model/consts/index.js

@@ -0,0 +1 @@
+export { cssStyles } from "./cssStyles";

package/dist/shared/lib/slickgrid/model/SlickTable/printer/model/index.js

@@ -0,0 +1 @@
+export { cssStyles } from "./consts";

package/dist/shared/lib/slickgrid/model/SlickTable/table/SlickTable.js

@@ -0,0 +1,109 @@
+import { SlickGrid, } from "slickgrid";
+import { elementNotVisible } from "shared/lib/dom";
+import { getOnKeyDownCallback } from "../../../lib";
+import { DownloadManager } from "../csvDownloadManager";
+import { WithoutFilter } from "../filters";
+import { WithoutHotKeys } from "../hotKeys";
+import { DefaultPrinter } from "../printer";
+export class SlickTable {
+    constructor(args) {
+        this.hotKeysBehavior = new WithoutHotKeys();
+        this.printer = new DefaultPrinter();
+        this.filter = new WithoutFilter();
+        this.downloadManager = new DownloadManager();
+        this._grid = null;
+        this._grouping = {};
+        this._isActive = false;
+        this._isEdited = false;
+        this._observers = [];
+        const { downloadManager, filter, hotKeys, id, name, printer } = args;
+        this.id = id;
+        this.name = name || "";
+        if (hotKeys)
+            this.hotKeysBehavior = hotKeys;
+        if (printer)
+            this.printer = printer;
+        if (filter)
+            this.filter = filter;
+        if (downloadManager)
+            this.downloadManager = downloadManager;
+    }
+    createGrid(dataView, columns, options) {
+        this.reset();
+        const grid = new SlickGrid(`#${this.id}`, dataView, columns, options);
+        this.grid = grid;
+        grid.onKeyDown.subscribe(getOnKeyDownCallback(grid));
+        this.filter.register(grid, this.id);
+        return this.grid;
+    }
+    handleKeyboardEvent(event) {
+        if (elementNotVisible(`#${this.id}`))
+            return;
+        this.hotKeysBehavior.handleKeyboardEvent(event, this);
+    }
+    get grid() {
+        return this._grid;
+    }
+    get grouping() {
+        return this._grouping;
+    }
+    get isEdited() {
+        return this._isEdited;
+    }
+    set grid(grid) {
+        this._grid = grid;
+    }
+    set grouping(grouping) {
+        this._grouping = { ...this._grouping, ...grouping };
+        if (!this.grid)
+            return;
+        const dataView = this.grid.getData();
+        if (this.grouping.isGrouped) {
+            dataView.setGrouping(this.grouping.groups || []);
+        }
+        else {
+            dataView.setGrouping([]);
+        }
+    }
+    set isEdited(isEdited) {
+        this._isEdited = isEdited;
+        this.notifyObservers();
+    }
+    setPrinter(printer) {
+        this.printer = printer;
+    }
+    get isActive() {
+        return this._isActive;
+    }
+    set isActive(isActive) {
+        this._isActive = isActive;
+    }
+    resizeCanvas() {
+        console.log(""); // doesn't resize without this code line O_o
+        this.grid?.resizeCanvas();
+    }
+    registerObservers(observer) {
+        if (!~this._observers.indexOf(observer)) {
+            this._observers.push(observer);
+        }
+    }
+    notifyObservers() {
+        for (const observer of this._observers) {
+            observer(this);
+        }
+    }
+    deleteObserver(observer) {
+        const index = this._observers.indexOf(observer);
+        this._observers.splice(index, 1);
+    }
+    reset() {
+        this.grid?.onKeyDown.unsubscribe(getOnKeyDownCallback(this.grid));
+        if (this.grid?.getSelectionModel()) {
+            this.grid.setSelectedRows([]);
+        }
+        this.hotKeysBehavior.resetQueue();
+        this.isEdited = false;
+        this.isActive = false;
+        this.grid = null;
+    }
+}

package/dist/shared/lib/slickgrid/model/SlickTable/table/index.js

@@ -0,0 +1 @@
+export { SlickTable } from "./SlickTable";

package/dist/shared/lib/slickgrid/model/events/eventContextMenu.js

@@ -0,0 +1,9 @@
+import { AnEvent } from "shared/lib/an-event";
+class EventContextMenu extends AnEvent {
+    constructor() {
+        super(...arguments);
+        this.x = 0;
+        this.y = 0;
+    }
+}
+export const eventContextMenu = new EventContextMenu();

package/dist/shared/lib/slickgrid/model/events/index.js

@@ -0,0 +1 @@
+export { eventContextMenu } from "./eventContextMenu";

package/dist/shared/lib/slickgrid/model/index.js

@@ -0,0 +1,2 @@
+export { DownloadManager, DecoratorEndingDate, DecoratorFilter, DecoratorColumnFilter, DecoratorPeriod, DefaultHotKeys, DefaultPrinter, DeletedRowsFilter, Filter, PreventCopying, RedoUndoOnly, SlickTable, WithConfirmationOfDeletion, WithoutHotKeys, } from "./SlickTable";
+export { eventContextMenu } from "./events";

package/dist/shared/lib/slickgrid/model/types/IColumn.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/model/types/IColumnFilterValue.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/model/types/IGrouping.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/model/types/ISlickRow.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/model/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/ui/HeaderButtons/index.js

@@ -0,0 +1,2 @@
+export { handleHeaderButtons, headerButtons } from "./lib";
+export { eventOpenColumnFilters, openColumnFilter } from "./model";

package/dist/shared/lib/slickgrid/ui/HeaderButtons/lib/handleClick/handleHeaderButtons.js

@@ -0,0 +1,16 @@
+import { eventOpenColumnFilters } from "../../model";
+import { headerButtons } from "../highlighting";
+export function handleHeaderButtons(table) {
+    headerButtons.highlightAllColumns(table.filter.args, table.id);
+    return function (event, args) {
+        event.preventDefault();
+        eventOpenColumnFilters.columnId = args.column.id || "";
+        eventOpenColumnFilters.group =
+            args.command;
+        eventOpenColumnFilters.table = table;
+        eventOpenColumnFilters.target = event.target;
+        eventOpenColumnFilters.x = event.x || 0;
+        eventOpenColumnFilters.y = event.y || 0;
+        eventOpenColumnFilters.notify();
+    };
+}

package/dist/shared/lib/slickgrid/ui/HeaderButtons/lib/handleClick/index.js

@@ -0,0 +1 @@
+export { handleHeaderButtons } from "./handleHeaderButtons";

package/dist/shared/lib/slickgrid/ui/HeaderButtons/lib/highlighting/headerButtons.js

@@ -0,0 +1,47 @@
+class HeaderButtons {
+    highlightAllColumns(args, tableId) {
+        const slickTable = document.getElementById(tableId);
+        if (!slickTable)
+            return;
+        const columnIds = Object.keys(args.columnFilters || {});
+        if (!columnIds.length) {
+            const columns = slickTable.querySelectorAll(".slick-header-column");
+            for (const column of columns) {
+                column.classList.remove("filter-active");
+            }
+        }
+        else {
+            for (const columnId of columnIds) {
+                const column = slickTable.querySelector(`[data-id="${columnId}"]`);
+                if (!column)
+                    return;
+                if (args.columnFilters[columnId].value[1] ||
+                    args.columnFilters[columnId].value[2]) {
+                    column.classList.add("filter-active");
+                }
+                else {
+                    column.classList.remove("filter-active");
+                }
+            }
+        }
+    }
+    highlightColumn(table, dataId) {
+        const slickTable = document.getElementById(table.id);
+        if (!slickTable)
+            return;
+        const column = slickTable.querySelector(`[data-id="${dataId}"]`);
+        if (!column)
+            return;
+        column.classList.add("filter-active");
+    }
+    resetColumn(table, dataId) {
+        const slickTable = document.getElementById(table.id);
+        if (!slickTable)
+            return;
+        const column = slickTable.querySelector(`[data-id="${dataId}"]`);
+        if (!column)
+            return;
+        column.classList.remove("filter-active");
+    }
+}
+export const headerButtons = new HeaderButtons();

package/dist/shared/lib/slickgrid/ui/HeaderButtons/lib/highlighting/index.js

@@ -0,0 +1 @@
+export { headerButtons } from "./headerButtons";

package/dist/shared/lib/slickgrid/ui/HeaderButtons/lib/index.js

@@ -0,0 +1,2 @@
+export { handleHeaderButtons } from "./handleClick";
+export { headerButtons } from "./highlighting";

package/dist/shared/lib/slickgrid/ui/HeaderButtons/model/buttons/index.js

@@ -0,0 +1 @@
+export { openColumnFilter } from "./openColumnFilter";

package/dist/shared/lib/slickgrid/ui/HeaderButtons/model/buttons/openColumnFilter.js

@@ -0,0 +1,6 @@
+export function openColumnFilter(group) {
+    return {
+        tooltip: "Apply column filter",
+        command: group,
+    };
+}

package/dist/shared/lib/slickgrid/ui/HeaderButtons/model/event/eventOpenColumnFilters.js

@@ -0,0 +1,13 @@
+import { AnEvent } from "shared/lib/an-event";
+import { EColumnFiltersGroup } from "shared/model/enums";
+class OpenColumnFilters extends AnEvent {
+    constructor() {
+        super(...arguments);
+        this.columnId = "";
+        this.group = EColumnFiltersGroup.Text;
+        this.target = null;
+        this.x = 0;
+        this.y = 0;
+    }
+}
+export const eventOpenColumnFilters = new OpenColumnFilters();

package/dist/shared/lib/slickgrid/ui/HeaderButtons/model/event/index.js

@@ -0,0 +1 @@
+export { eventOpenColumnFilters } from "./eventOpenColumnFilters";

package/dist/shared/lib/slickgrid/ui/HeaderButtons/model/index.js

@@ -0,0 +1,2 @@
+export { openColumnFilter } from "./buttons";
+export { eventOpenColumnFilters } from "./event";

package/dist/shared/lib/slickgrid/ui/SlickgridTable/index.js

@@ -0,0 +1 @@
+export { SlickgridTable } from "./ui";

package/dist/shared/lib/slickgrid/ui/SlickgridTable/lib/callbacks/index.js

@@ -0,0 +1 @@
+export { onAddNewRow } from "./onAddNewRow";

package/dist/shared/lib/slickgrid/ui/SlickgridTable/lib/callbacks/onAddNewRow.js

@@ -0,0 +1,21 @@
+import { getLastRow, getMaxId } from "../../../../lib";
+export const onAddNewRow = (table) => (_e, { grid, item }) => {
+    addNewRow(grid, item);
+    grid.updateRowCount();
+    grid.invalidate();
+    table.isEdited = true;
+    table.hotKeysBehavior.pushToCommandQueue(grid);
+};
+const addNewRow = (grid, item) => {
+    const dataView = grid.getData();
+    const lastRow = getLastRow(dataView);
+    const maxId = getMaxId(grid);
+    const newRow = {
+        ...lastRow,
+        ...item,
+        id: maxId + 1,
+        isEdited: true,
+        isNew: true,
+    };
+    dataView.addItem(newRow);
+};

package/dist/shared/lib/slickgrid/ui/SlickgridTable/lib/hooks/index.js

@@ -0,0 +1 @@
+export { useGrid } from "./useGrid";

package/dist/shared/lib/slickgrid/ui/SlickgridTable/lib/hooks/useGrid.js

@@ -0,0 +1,95 @@
+import { useEffect } from "react";
+import { SlickCheckboxSelectColumn, SlickGroupItemMetadataProvider, SlickHeaderButtons, SlickHeaderMenu, SlickResizer, SlickRowSelectionModel, SlickDataView as SlickgridDataView, } from "slickgrid";
+import { CHECKBOX_SELECTOR } from "shared/model/consts";
+import { onRowsChanged, columnSorter as sorter, onRowCountChanged as updateRowCount, updateTotals, } from "../../../../lib";
+import { openContextMenu } from "../../../../lib/contextMenu";
+import { handleHeaderButtons, headerButtons } from "../../../HeaderButtons";
+import { defaultOptions } from "../../model";
+export function useGrid({ SlickDataView = SlickgridDataView, applyCellCssStyles, columnSorter = sorter, columns, getItemMetadata, groups, items, onAddNewRow, onBeforeEditCell, onCellChange, onClick, onDblClick, onHeaderMenuCommand, onRowCountChanged = updateRowCount, options = {}, table, }) {
+    useEffect(() => {
+        const groupItemMetadataProvider = new SlickGroupItemMetadataProvider();
+        const headerButtonsPlugin = new SlickHeaderButtons({});
+        const headerMenuPlugin = new SlickHeaderMenu({});
+        const dataView = new SlickDataView({
+            groupItemMetadataProvider: groups ? groupItemMetadataProvider : undefined,
+        });
+        const grid = table.createGrid(dataView, [], options);
+        const resizer = new SlickResizer({
+            container: table.id,
+        });
+        grid.setSelectionModel(new SlickRowSelectionModel({ selectActiveRow: false }));
+        grid.registerPlugin(resizer);
+        grid.registerPlugin(headerButtonsPlugin);
+        grid.registerPlugin(groupItemMetadataProvider);
+        if (getItemMetadata)
+            dataView.getItemMetadata = getItemMetadata(dataView);
+        dataView.setItems(items.map((item) => ({ ...item })));
+        grid.invalidate();
+        dataView.onRowCountChanged.subscribe(onRowCountChanged(table));
+        dataView.onRowsChanged.subscribe(onRowsChanged(grid));
+        grid.onAddNewRow.subscribe(onAddNewRow);
+        grid.onCellChange.subscribe(onCellChange);
+        onBeforeEditCell && grid.onBeforeEditCell.subscribe(onBeforeEditCell);
+        onClick && grid.onClick.subscribe(onClick);
+        onDblClick && grid.onDblClick.subscribe(onDblClick);
+        grid.onSort.subscribe(columnSorter.onSort());
+        grid.onContextMenu.subscribe(openContextMenu(table));
+        const onHeaderButtonCommand = handleHeaderButtons(table);
+        headerButtonsPlugin.onCommand.subscribe(onHeaderButtonCommand);
+        if (onHeaderMenuCommand) {
+            headerMenuPlugin.onCommand.subscribe(onHeaderMenuCommand);
+            grid.registerPlugin(headerMenuPlugin);
+        }
+        if (groups) {
+            table.grouping = {
+                groups,
+                isGrouped: table.grouping.isGrouped ?? true,
+            };
+        }
+        applyCellCssStyles?.(grid);
+        table.hotKeysBehavior.pushToCommandQueue(grid);
+        // table.notifyObservers();
+        return () => {
+            headerButtonsPlugin.onCommand.unsubscribe(onHeaderButtonCommand);
+            onHeaderMenuCommand &&
+                headerMenuPlugin.onCommand.unsubscribe(onHeaderMenuCommand);
+            grid.onAddNewRow.unsubscribe(onAddNewRow);
+            grid.onCellChange.unsubscribe(onCellChange);
+            onBeforeEditCell && grid.onBeforeEditCell.unsubscribe(onBeforeEditCell);
+            onClick && grid.onClick.unsubscribe(onClick);
+            onDblClick && grid.onDblClick.unsubscribe(onDblClick);
+            table.reset();
+        };
+    }, [items]);
+    useEffect(() => {
+        const grid = table.grid;
+        if (!grid || !options)
+            return;
+        grid.setOptions({ ...defaultOptions, ...options });
+        grid.render();
+    }, [options, items]);
+    useEffect(() => {
+        const grid = table.grid;
+        if (!grid)
+            return;
+        if (!columns.length)
+            return;
+        if (columns[0].id === CHECKBOX_SELECTOR) {
+            const checkboxSelector = new SlickCheckboxSelectColumn();
+            grid.setColumns([
+                // @ts-ignore
+                { ...checkboxSelector.getColumnDefinition(), focusable: false },
+                ...columns.slice(1),
+            ]);
+            grid.registerPlugin(checkboxSelector);
+        }
+        else {
+            grid.setColumns(columns);
+        }
+        headerButtons.highlightAllColumns(table.filter.args, table.id);
+        table.filter.register(grid, table.id);
+        grid.invalidate();
+        updateTotals(grid);
+        table.notifyObservers();
+    }, [columns, items]);
+}

package/dist/shared/lib/slickgrid/ui/SlickgridTable/lib/index.js

@@ -0,0 +1,2 @@
+export { useGrid } from "./hooks";
+export { onAddNewRow } from "./callbacks";

package/dist/shared/lib/slickgrid/ui/SlickgridTable/model/defaultOptions.js

@@ -0,0 +1,7 @@
+import { GridAutosizeColsMode } from "slickgrid";
+export const defaultOptions = {
+    asyncEditorLoading: false, // increases keyboard navigation speed
+    autosizeColsMode: GridAutosizeColsMode.LegacyForceFit,
+    enableAutoSizeColumns: true,
+    enableColumnReorder: false,
+};

package/dist/shared/lib/slickgrid/ui/SlickgridTable/model/index.js

@@ -0,0 +1 @@
+export { defaultOptions } from "./defaultOptions";

package/dist/shared/lib/slickgrid/ui/SlickgridTable/model/types/Props.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/ui/SlickgridTable/model/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/lib/slickgrid/ui/SlickgridTable/ui/SlickgridTable.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { onCellChange as cellChange, useHotKeys, useUpdateTotal, } from "../../../lib";
+import { onAddNewRow as addNewRow, useGrid } from "../lib";
+export const SlickgridTable = ({ SlickDataView, applyCellCssStyles, columnSorter, columns, getItemMetadata, groups, items, onAddNewRow, onBeforeEditCell, onCellChange, onClick, onDblClick, onHeaderMenuCommand, onRowCountChanged, options, table, }) => {
+    useGrid({
+        SlickDataView,
+        applyCellCssStyles,
+        columnSorter,
+        columns,
+        getItemMetadata,
+        groups,
+        items,
+        onAddNewRow: onAddNewRow || addNewRow(table),
+        onBeforeEditCell,
+        onCellChange: onCellChange || cellChange(table),
+        onClick,
+        onDblClick,
+        onHeaderMenuCommand,
+        onRowCountChanged,
+        options,
+        table,
+    });
+    useHotKeys(table);
+    useUpdateTotal(table);
+    return _jsx("div", { id: table.id, className: "slick-container" });
+};

package/dist/shared/lib/slickgrid/ui/SlickgridTable/ui/index.js

@@ -0,0 +1 @@
+export { SlickgridTable } from "./SlickgridTable";