@vuu-ui/vuu-table-extras 3.0.0-beta.3 → 3.1.0-beta.1

package/src/inline-add-row/useInlineAddRow.js

@@ -0,0 +1,120 @@
+import { EditSession, useEditSession, withDataRowEditErrors } from "@vuu-ui/vuu-data-editing";
+import { getCellRenderer, isDataValueEditable, isNotHidden } from "@vuu-ui/vuu-utils";
+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+const createSyntheticDataRow = (newRowState, columns)=>withDataRowEditErrors({
+        ...newRowState.values,
+        childCount: 0,
+        depth: 1,
+        hasColumn: (name)=>columns.some((column)=>column.name === name),
+        index: -1,
+        isExpanded: false,
+        isLeaf: true,
+        isSelected: false,
+        key: EditSession.newRowKey,
+        renderIndex: -1
+    }, newRowState.errors);
+const useInlineAddRow = ({ columns })=>{
+    const editSession = useEditSession(true);
+    const containerRef = useRef(null);
+    const inlineAddColumns = useMemo(()=>columns.map((column)=>{
+            const editable = isDataValueEditable(column, "insert");
+            const inlineAddColumn = {
+                ...column,
+                editable
+            };
+            return {
+                ...inlineAddColumn,
+                CellRenderer: editable ? getCellRenderer(inlineAddColumn) : void 0
+            };
+        }), [
+        columns
+    ]);
+    const visibleColumns = useMemo(()=>inlineAddColumns.filter(isNotHidden), [
+        inlineAddColumns
+    ]);
+    const visibleInsertColumns = useMemo(()=>visibleColumns.filter((column)=>isDataValueEditable(column, "insert")), [
+        visibleColumns
+    ]);
+    const subscribeToNewRow = useCallback((onStoreChange)=>{
+        editSession.on("newRow", onStoreChange);
+        return ()=>editSession.removeListener("newRow", onStoreChange);
+    }, [
+        editSession
+    ]);
+    const newRowState = useSyncExternalStore(subscribeToNewRow, ()=>editSession.newRowState, ()=>editSession.newRowState);
+    const dataRow = useMemo(()=>createSyntheticDataRow(newRowState, inlineAddColumns), [
+        inlineAddColumns,
+        newRowState
+    ]);
+    const previousValuesRef = useRef(newRowState.values);
+    const focusEditor = useCallback((index)=>{
+        const cell = containerRef.current?.querySelectorAll("[data-field]")[index];
+        cell?.querySelector("input, button, [tabindex]")?.focus();
+    }, []);
+    useEffect(()=>{
+        editSession.configureNewRow(visibleInsertColumns.map(({ name })=>name));
+    }, [
+        editSession,
+        visibleInsertColumns
+    ]);
+    useEffect(()=>{
+        visibleInsertColumns.filter((column)=>"boolean" === column.serverDataType && void 0 === newRowState.values[column.name]).forEach((column)=>{
+            editSession.setNewRowValue(column.name, false);
+        });
+    }, [
+        editSession,
+        newRowState.values,
+        visibleInsertColumns
+    ]);
+    useEffect(()=>{
+        const firstInvalidIndex = visibleColumns.findIndex(({ name })=>void 0 !== newRowState.errors[name]);
+        if (-1 !== firstInvalidIndex) focusEditor(firstInvalidIndex);
+    }, [
+        focusEditor,
+        newRowState.errors,
+        visibleColumns
+    ]);
+    useEffect(()=>{
+        const previousValues = previousValuesRef.current;
+        previousValuesRef.current = newRowState.values;
+        if (Object.keys(previousValues).length > 0 && 0 === Object.keys(newRowState.values).length && 0 === Object.keys(newRowState.errors).length) {
+            const firstEditableIndex = visibleColumns.findIndex((column)=>isDataValueEditable(column, "insert"));
+            if (-1 !== firstEditableIndex) requestAnimationFrame(()=>focusEditor(firstEditableIndex));
+        }
+    }, [
+        focusEditor,
+        newRowState.errors,
+        newRowState.values,
+        visibleColumns
+    ]);
+    useEffect(()=>{
+        const container = containerRef.current;
+        if (!container) return;
+        const handleCommit = (event)=>{
+            const target = event.target;
+            if (!(target instanceof Element)) return;
+            const cell = target.closest("[data-field]");
+            const cells = container.querySelectorAll("[data-field]");
+            const currentIndex = Array.from(cells).indexOf(cell ?? container);
+            const firstInvalidIndex = visibleColumns.findIndex(({ name })=>void 0 !== editSession.newRowState.errors[name]);
+            const firstEditableIndex = visibleColumns.findIndex((column)=>isDataValueEditable(column, "insert"));
+            const nextEditableIndex = visibleColumns.findIndex((column, index)=>index > currentIndex && isDataValueEditable(column, "insert"));
+            if (-1 !== firstInvalidIndex) requestAnimationFrame(()=>focusEditor(firstInvalidIndex));
+            else if (-1 !== nextEditableIndex) focusEditor(nextEditableIndex);
+            else if (-1 !== firstEditableIndex) requestAnimationFrame(()=>focusEditor(firstEditableIndex));
+        };
+        container.addEventListener("vuu-commit", handleCommit);
+        return ()=>container.removeEventListener("vuu-commit", handleCommit);
+    }, [
+        editSession,
+        focusEditor,
+        visibleColumns
+    ]);
+    return {
+        containerRef,
+        dataRow,
+        draftRevision: newRowState.draftRevision,
+        inlineAddColumns
+    };
+};
+export { useInlineAddRow };

package/src/tabbed-table-config-panel/TabbedTableConfigPanel.css.js

@@ -0,0 +1,23 @@
+const css = `
+.vuuTabbedTableConfigPanel {
+  --tabs-height: 25px;
+  position: absolute;
+  inset: 0;
+
+  & .saltTabsNext {
+    height: 100%;
+
+    & .saltTabListNext {
+      border-bottom: solid var(--salt-separable-secondary-borderColor) 1px;
+      height: var(--tabs-height);
+    }
+
+    & .saltTabNextPanel {
+      height: calc(100% - var(--tabs-height));
+    }
+  }
+}
+
+
+`;
+export default css;

package/src/tabbed-table-config-panel/TabbedTableConfigPanel.js

@@ -0,0 +1,99 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { TabListNext, TabNext, TabNextPanel, TabNextTrigger, TabsNext } from "@salt-ds/lab";
+import { useComponentCssInjection } from "@salt-ds/styles";
+import { useWindow } from "@salt-ds/window";
+import clsx from "clsx";
+import { useCallback, useState } from "react";
+import { useEditCalculatedColumn } from "../calculated-column/useEditCalculatedColumn.js";
+import { ColumnPicker } from "../column-picker/ColumnPicker.js";
+import { ColumnSettingsPanel } from "../column-settings-panel/ColumnSettingsPanel.js";
+import { TableSettingsPanel } from "../table-settings-panel/TableSettingsPanel.js";
+import TabbedTableConfigPanel from "./TabbedTableConfigPanel.css";
+const classBase = "vuuTabbedTableConfigPanel";
+const TabbedTableConfigPanel_TabbedTableConfigPanel = ({ allowCreateCalculatedColumn = false, className, columnModel, config, onDisplayAttributeChange, selectedTab = "table-settings", vuuTable, ...htmlAttributes })=>{
+    const targetWindow = useWindow();
+    useComponentCssInjection({
+        testId: "vuu-tabbed-table-config-panel",
+        css: TabbedTableConfigPanel,
+        window: targetWindow
+    });
+    const [columns, setColumns] = useState([]);
+    const [value, setValue] = useState(selectedTab);
+    const handleChange = useCallback((_e, value)=>{
+        setValue(value);
+    }, []);
+    const handleSelectionChange = useCallback((_e, selectedItems)=>{
+        setColumns(selectedItems);
+    }, []);
+    const handleSaveCalculatedColumn = useCallback((column)=>{
+        setColumns([
+            column
+        ]);
+    }, []);
+    const { onCreateCalculatedColumn, onEditCalculatedColumn } = useEditCalculatedColumn({
+        columnModel,
+        calculatedColumn: columns[0],
+        onSaveColumn: handleSaveCalculatedColumn,
+        vuuTable
+    });
+    return /*#__PURE__*/ jsx("div", {
+        ...htmlAttributes,
+        className: clsx(classBase, className),
+        children: /*#__PURE__*/ jsxs(TabsNext, {
+            onChange: handleChange,
+            value: value,
+            children: [
+                /*#__PURE__*/ jsxs(TabListNext, {
+                    appearance: "transparent",
+                    children: [
+                        /*#__PURE__*/ jsx(TabNext, {
+                            value: "table-settings",
+                            children: /*#__PURE__*/ jsx(TabNextTrigger, {
+                                children: "Table settings"
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(TabNext, {
+                            value: "table-columns",
+                            children: /*#__PURE__*/ jsx(TabNextTrigger, {
+                                children: "Table columns"
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(TabNext, {
+                            disabled: 0 === columns.length,
+                            value: "column-settings",
+                            children: /*#__PURE__*/ jsx(TabNextTrigger, {
+                                children: "Column settings"
+                            })
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx(TabNextPanel, {
+                    value: "table-settings",
+                    children: /*#__PURE__*/ jsx(TableSettingsPanel, {
+                        onDisplayAttributeChange: onDisplayAttributeChange,
+                        tableDisplayAttributes: config
+                    })
+                }),
+                /*#__PURE__*/ jsx(TabNextPanel, {
+                    value: "table-columns",
+                    children: /*#__PURE__*/ jsx(ColumnPicker, {
+                        allowCreateCalculatedColumn: allowCreateCalculatedColumn,
+                        columnModel: columnModel,
+                        onClickCreateCalculatedColumn: onCreateCalculatedColumn,
+                        onSelectionChange: handleSelectionChange,
+                        selected: columns
+                    })
+                }),
+                /*#__PURE__*/ jsx(TabNextPanel, {
+                    value: "column-settings",
+                    children: columns.length > 0 ? /*#__PURE__*/ jsx(ColumnSettingsPanel, {
+                        column: columns[0],
+                        columnModel: columnModel,
+                        onClickEditCalculatedColumn: onEditCalculatedColumn
+                    }) : null
+                })
+            ]
+        })
+    });
+};
+export { TabbedTableConfigPanel_TabbedTableConfigPanel as TabbedTableConfigPanel };

package/src/tabbed-table-config-panel/TabbedTableSettingsAction.js

@@ -0,0 +1,28 @@
+import { jsx } from "react/jsx-runtime";
+import { IconButton } from "@vuu-ui/vuu-ui-controls";
+import { useCallback } from "react";
+import { useTabbedTableConfigPanel } from "./useTabbedTableConfigPanel.js";
+const TabbedTableSettingsAction = ({ allowCreateCalculatedColumn, appearance = "transparent", columnModel, config, icon = "settings", onDisplayAttributeChange, sentiment = "neutral", vuuTable, ...IconButtonProps })=>{
+    const { showTabbedTableConfigPanel } = useTabbedTableConfigPanel({
+        allowCreateCalculatedColumn,
+        columnModel,
+        config,
+        onDisplayAttributeChange,
+        vuuTable
+    });
+    const handleClick = useCallback(()=>{
+        showTabbedTableConfigPanel();
+    }, [
+        showTabbedTableConfigPanel
+    ]);
+    return /*#__PURE__*/ jsx(IconButton, {
+        ...IconButtonProps,
+        appearance: appearance,
+        "data-action": "table-settings",
+        icon: icon,
+        onClick: handleClick,
+        sentiment: sentiment,
+        size: 20
+    });
+};
+export { TabbedTableSettingsAction };

package/src/tabbed-table-config-panel/useTabbedTableConfigPanel.js

@@ -0,0 +1,29 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useRef } from "react";
+import { useContextPanel } from "@vuu-ui/vuu-ui-controls";
+import { TabbedTableConfigPanel } from "./TabbedTableConfigPanel.js";
+const useTabbedTableConfigPanel = ({ allowCreateCalculatedColumn, columnModel, config, onDisplayAttributeChange, vuuTable })=>{
+    const showContextPanel = useContextPanel();
+    const contextPanelShowing = useRef(false);
+    const showTabbedTableConfigPanel = useCallback((title = "Table settings")=>{
+        contextPanelShowing.current = true;
+        showContextPanel(/*#__PURE__*/ jsx(TabbedTableConfigPanel, {
+            allowCreateCalculatedColumn: allowCreateCalculatedColumn,
+            columnModel: columnModel,
+            config: config,
+            onDisplayAttributeChange: onDisplayAttributeChange,
+            vuuTable: vuuTable
+        }), title);
+    }, [
+        allowCreateCalculatedColumn,
+        columnModel,
+        config,
+        onDisplayAttributeChange,
+        showContextPanel,
+        vuuTable
+    ]);
+    return {
+        showTabbedTableConfigPanel
+    };
+};
+export { useTabbedTableConfigPanel };

package/src/table-footer/TableFooter.css.js

@@ -0,0 +1,31 @@
+const css = `
+.vuuTableFooter {
+  background-color: var(--salt-container-secondary-background);
+  --table-footer-height: var(--vuuTableFooter-height, 32px);
+  flex: 0 0 var(--table-footer-height);
+  height: var(--table-footer-height);
+  grid-template: "panel-start panel-center panel-end"
+  / 1fr 1fr 1fr;
+  display: grid;
+
+  & .vuuTableFooterTray {
+    align-items: center;
+    gap: var(--salt-spacing-100);
+    margin: 0 var(--salt-spacing-200);
+    display: flex;
+
+    &.vuuTableFooterTray-center {
+      grid-area: panel-center;
+      justify-self: center;
+    }
+
+    &.vuuTableFooterTray-end {
+      grid-area: panel-end;
+      justify-self: end;
+    }
+  }
+}
+
+
+`;
+export default css;

package/src/table-footer/TableFooter.js

@@ -0,0 +1,33 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import clsx from "clsx";
+import { useComponentCssInjection } from "@salt-ds/styles";
+import { useWindow } from "@salt-ds/window";
+import TableFooter from "./TableFooter.css";
+const classBase = "vuuTableFooter";
+const TableFooterTray = ({ children, position = 'end' })=>/*#__PURE__*/ jsx("div", {
+        className: clsx(`${classBase}Tray`, {
+            [`${classBase}Tray-center`]: 'center' === position,
+            [`${classBase}Tray-end`]: 'end' === position
+        }),
+        children: children
+    });
+const TableFooter_TableFooter = ({ children, className, onInvokeAction, tooltrayActions, ...htmlAttributes })=>{
+    const targetWindow = useWindow();
+    useComponentCssInjection({
+        testId: "vuu-table-footer",
+        css: TableFooter,
+        window: targetWindow
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        ...htmlAttributes,
+        className: clsx(classBase, className),
+        children: [
+            children,
+            tooltrayActions ? /*#__PURE__*/ jsx("div", {
+                className: `${classBase}-tooltray`,
+                children: tooltrayActions
+            }) : null
+        ]
+    });
+};
+export { TableFooterTray, TableFooter_TableFooter as TableFooter };

package/src/table-provider/TableProvider.js

@@ -0,0 +1,33 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const NullMenuActionHandler = (menuItemId)=>{
+    console.log(`[TableContext] no menu action handler installed (menuItemHandler invoked with ${menuItemId})`);
+    return false;
+};
+const NullDataSource = {};
+const TableContext = /*#__PURE__*/ createContext({
+    dataSource: NullDataSource,
+    menuActionHandler: NullMenuActionHandler
+});
+const TableProvider = ({ children, dataSource, menuActionHandler, rowActionHandlers })=>/*#__PURE__*/ jsx(TableContext.Provider, {
+        value: {
+            dataSource,
+            menuActionHandler,
+            rowActionHandlers
+        },
+        children: children
+    });
+function useTableContext(throwIfNoDataSource = false) {
+    const { dataSource, menuActionHandler } = useContext(TableContext);
+    if (dataSource !== NullDataSource || menuActionHandler != NullMenuActionHandler || !throwIfNoDataSource) return {
+        dataSource,
+        menuActionHandler
+    };
+    throw Error("[TableProvider] no DataSourceProvider has been declared");
+}
+const useRowAction = (actionId)=>{
+    const { rowActionHandlers } = useContext(TableContext);
+    if (rowActionHandlers?.[actionId]) return rowActionHandlers[actionId];
+    throw Error(`[TableProvider] useRowAction, no action configured #${actionId}`);
+};
+export { TableContext, TableProvider, useRowAction, useTableContext };

package/src/table-settings-panel/TableSettingsPanel.css.js

@@ -0,0 +1,70 @@
+const css = `
+.vuuTableSettingsPanel {
+  --vuuScrollable-size: 6px;
+  --vuu-svg-text-strikethrough: url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 48 24\"><path d=\"M28.3333 9.33334C28.8867 9.33334 29.3333 8.88668 29.3333 8.33334C29.3333 7.78001 28.8867 7.33334 28.3333 7.33334H20.26L22.26 9.33334H23.48L23.1133 10.1867L24.5067 11.58L25.4733 9.33334H28.3333ZM27.6267 16.5867L18.7467 7.70668C18.4867 7.44668 18.0667 7.44668 17.8067 7.70668C17.5467 7.96668 17.5467 8.38668 17.8067 8.64668L21.98 12.82L20.88 15.38C20.62 15.9933 21.0667 16.6667 21.7267 16.6667C22.0933 16.6667 22.4267 16.4467 22.5733 16.1067L23.38 14.22L26.68 17.52C26.94 17.78 27.36 17.78 27.62 17.52C27.8867 17.2667 27.8867 16.8467 27.6267 16.5867Z\"/></svg>");
+  --vuu-svg-text-Tt: url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 48 24\"><path d=\"M17.6667 7.66666C17.6667 8.21999 18.1133 8.66666 18.6667 8.66666H21V15.6667C21 16.22 21.4467 16.6667 22 16.6667C22.5533 16.6667 23 16.22 23 15.6667V8.66666H25.3333C25.8867 8.66666 26.3333 8.21999 26.3333 7.66666C26.3333 7.11332 25.8867 6.66666 25.3333 6.66666H18.6667C18.1133 6.66666 17.6667 7.11332 17.6667 7.66666ZM29.3333 9.99999H25.3333C24.78 9.99999 24.3333 10.4467 24.3333 11C24.3333 11.5533 24.78 12 25.3333 12H26.3333V15.6667C26.3333 16.22 26.78 16.6667 27.3333 16.6667C27.8867 16.6667 28.3333 16.22 28.3333 15.6667V12H29.3333C29.8867 12 30.3333 11.5533 30.3333 11C30.3333 10.4467 29.8867 9.99999 29.3333 9.99999Z\" /></svg>");
+  --vuu-svg-text-T: url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 48 24\"><path d=\"M19.3333 7.66666C19.3333 8.21999 19.78 8.66666 20.3333 8.66666H23V15.6667C23 16.22 23.4467 16.6667 24 16.6667C24.5533 16.6667 25 16.22 25 15.6667V8.66666H27.6667C28.22 8.66666 28.6667 8.21999 28.6667 7.66666C28.6667 7.11332 28.22 6.66666 27.6667 6.66666H20.3333C19.78 6.66666 19.3333 7.11332 19.3333 7.66666Z\"/></svg>");
+  --vuu-svg-stripes: url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\"><rect x=\"2\" y=\"2\" width=\"12\" height=\"2\" rx=\"0.3\"/><rect x=\"2\" y=\"5\" width=\"12\" height=\"2\" rx=\"0.3\"/><rect x=\"2\" y=\"8\" width=\"12\" height=\"2\" rx=\"0.3\"/><rect x=\"2\" y=\"11\" width=\"12\" height=\"2\" rx=\"0.3\"/></svg>");
+  --vuu-svg-row-lines: url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\"><rect x=\"2\" y=\"3\" width=\"12\" height=\"1\" rx=\"0.3\" /><rect x=\"2\" y=\"6\" width=\"12\" height=\"1\" rx=\"0.3\" /><rect x=\"2\" y=\"9\" width=\"12\" height=\"1\" rx=\"0.3\" /><rect x=\"2\" y=\"12\" width=\"12\" height=\"1\" rx=\"0.3\"/></svg>");
+  --vuu-svg-col-lines: url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\"><rect x=\"3\" y=\"14\" width=\"12\" height=\"1\" rx=\"0.3\" transform=\"rotate%28-90 3 14%29\"/><rect x=\"6\" y=\"14\" width=\"12\" height=\"1\" rx=\"0.3\" transform=\"rotate%28-90 6 14%29\"/><rect x=\"9\" y=\"14\" width=\"12\" height=\"1\" rx=\"0.3\" transform=\"rotate%28-90 9 14%29\"/><rect x=\"12\" y=\"14\" width=\"12\" height=\"1\" rx=\"0.3\" transform=\"rotate%28-90 12 14%29\"/></svg>");
+  max-width: 254px;
+  height: 100%;
+  padding: 12px 2px var(--salt-spacing-200) 2px;
+  flex-direction: column;
+  gap: 24px;
+  display: flex;
+}
+
+.vuuTableSettingsPanel [data-icon="text-strikethrough"] {
+  --vuu-icon-svg: var(--vuu-svg-text-strikethrough);
+}
+
+.vuuTableSettingsPanel [data-icon="text-Tt"] {
+  --vuu-icon-svg: var(--vuu-svg-text-Tt);
+}
+
+.vuuTableSettingsPanel [data-icon="text-T"] {
+  --vuu-icon-svg: var(--vuu-svg-text-T);
+}
+
+.vuuTableSettingsPanel [data-icon="col-lines"] {
+  --vuu-icon-svg: var(--vuu-svg-col-lines);
+}
+
+.vuuTableSettingsPanel [data-icon="row-lines"] {
+  --vuu-icon-svg: var(--vuu-svg-row-lines);
+}
+
+.vuuTableSettingsPanel [data-icon="row-striping"] {
+  --vuu-icon-svg: var(--vuu-svg-stripes);
+}
+
+.vuuTableSettingsPanel-header {
+  padding-top: 24px;
+  font-size: 14px;
+  font-weight: 600;
+}
+
+.vuuTableSettingsPanel-columnListContainer {
+  flex: 1 1 0;
+  position: relative;
+  overflow: auto;
+
+  & .vuuColumnList {
+    height: 100%;
+  }
+}
+
+.vuuTableSettingsPanel-calculatedButtonbar {
+  --vuu-icon-size: 16px;
+  --saltButton-height: 24px;
+  --saltButton-width: 24px;
+  flex: 0 0 32px;
+  align-items: center;
+  gap: 12px;
+  display: flex;
+}
+
+
+`;
+export default css;

package/src/table-settings-panel/TableSettingsPanel.js

@@ -0,0 +1,128 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { FormField, FormFieldLabel, ToggleButton, ToggleButtonGroup } from "@salt-ds/core";
+import { useComponentCssInjection } from "@salt-ds/styles";
+import { useWindow } from "@salt-ds/window";
+import { useTableSettings } from "./useTableSettings.js";
+import { Icon, VuuInput } from "@vuu-ui/vuu-ui-controls";
+import TableSettingsPanel from "./TableSettingsPanel.css";
+const classBase = "vuuTableSettingsPanel";
+const defaultTableSettingsPermissions = {
+    allowColumnLabelCase: true,
+    allowColumnDefaultWidth: true,
+    allowGridSeparators: true
+};
+const noTableSettingsPermissions = {
+    allowColumnLabelCase: false,
+    allowColumnDefaultWidth: false,
+    allowGridSeparators: false
+};
+const TableSettingsPanel_TableSettingsPanel = ({ onDisplayAttributeChange, tableDisplayAttributes: tableDisplayAttributesProp, permissions: permissionsProp })=>{
+    const targetWindow = useWindow();
+    useComponentCssInjection({
+        testId: "vuu-table-settings-panel",
+        css: TableSettingsPanel,
+        window: targetWindow
+    });
+    const permissions = void 0 === permissionsProp || true === permissionsProp ? defaultTableSettingsPermissions : false === permissionsProp ? noTableSettingsPermissions : permissionsProp;
+    const { columnLabelsValue, onChangeColumnLabels, onChangeTableAttribute, onCommitColumnWidth, tableDisplayAttributes } = useTableSettings({
+        onDisplayAttributeChange,
+        tableDisplayAttributes: tableDisplayAttributesProp
+    });
+    const { allowColumnLabelCase = true, allowColumnDefaultWidth = true, allowGridSeparators = true } = permissions;
+    return /*#__PURE__*/ jsxs("div", {
+        className: classBase,
+        children: [
+            allowColumnDefaultWidth ? /*#__PURE__*/ jsxs(FormField, {
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Column Width"
+                    }),
+                    /*#__PURE__*/ jsx(VuuInput, {
+                        bordered: true,
+                        className: "vuuInput",
+                        "data-embedded": true,
+                        onCommit: onCommitColumnWidth
+                    })
+                ]
+            }) : null,
+            allowColumnLabelCase ? /*#__PURE__*/ jsxs(FormField, {
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Column Labels"
+                    }),
+                    /*#__PURE__*/ jsxs(ToggleButtonGroup, {
+                        className: "vuuToggleButtonGroup",
+                        onChange: onChangeColumnLabels,
+                        value: columnLabelsValue,
+                        children: [
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                className: "vuuIconToggleButton",
+                                value: 0,
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "text-strikethrough",
+                                    size: 48
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                className: "vuuIconToggleButton",
+                                value: 1,
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "text-Tt",
+                                    size: 48
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                className: "vuuIconToggleButton",
+                                value: 2,
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "text-T",
+                                    size: 48
+                                })
+                            })
+                        ]
+                    })
+                ]
+            }) : null,
+            allowGridSeparators ? /*#__PURE__*/ jsxs(FormField, {
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Grid separators"
+                    }),
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "saltToggleButtonGroup vuuStateButtonGroup saltToggleButtonGroup-horizontal",
+                        children: [
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                selected: tableDisplayAttributes.zebraStripes ?? false,
+                                onChange: onChangeTableAttribute,
+                                value: "zebraStripes",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "row-striping",
+                                    size: 16
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                selected: tableDisplayAttributes.rowSeparators ?? false,
+                                onChange: onChangeTableAttribute,
+                                value: "rowSeparators",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "row-lines",
+                                    size: 16
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                selected: tableDisplayAttributes.columnSeparators ?? false,
+                                onChange: onChangeTableAttribute,
+                                value: "columnSeparators",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "col-lines",
+                                    size: 16
+                                })
+                            })
+                        ]
+                    })
+                ]
+            }) : null
+        ]
+    });
+};
+export { TableSettingsPanel_TableSettingsPanel as TableSettingsPanel, defaultTableSettingsPermissions, noTableSettingsPermissions };

package/src/table-settings-panel/useTableSettings.js

@@ -0,0 +1,50 @@
+import { queryClosest, useLayoutEffectSkipFirst } from "@vuu-ui/vuu-utils";
+import { useCallback, useState } from "react";
+const useTableSettings = ({ onDisplayAttributeChange, tableDisplayAttributes: tableDisplayAttributesProp })=>{
+    const [tableDisplayAttributes, setDisplayTableAttributes] = useState(tableDisplayAttributesProp);
+    const handleChangeColumnLabels = useCallback((evt)=>{
+        const button = queryClosest(evt.target, "button");
+        if (button) {
+            const value = parseInt(button.value);
+            const columnFormatHeader = 0 === value ? void 0 : 1 === value ? "capitalize" : "uppercase";
+            setDisplayTableAttributes((state)=>({
+                    ...state,
+                    columnFormatHeader
+                }));
+        }
+    }, []);
+    const handleChangeTableAttribute = useCallback((evt)=>{
+        const button = queryClosest(evt.target, "button");
+        if (button) {
+            const { ariaPressed, value } = button;
+            setDisplayTableAttributes((state)=>({
+                    ...state,
+                    [value]: "true" !== ariaPressed
+                }));
+        }
+    }, []);
+    const handleCommitColumnWidth = useCallback((_, value)=>{
+        if ("string" == typeof value) {
+            const columnDefaultWidth = parseInt(value);
+            if (!isNaN(columnDefaultWidth)) setDisplayTableAttributes((state)=>({
+                    ...state,
+                    columnDefaultWidth
+                }));
+        }
+    }, []);
+    useLayoutEffectSkipFirst(()=>{
+        onDisplayAttributeChange?.(tableDisplayAttributes);
+    }, [
+        onDisplayAttributeChange,
+        tableDisplayAttributes
+    ]);
+    const columnLabelsValue = void 0 === tableDisplayAttributes.columnFormatHeader ? 0 : "capitalize" === tableDisplayAttributes.columnFormatHeader ? 1 : 2;
+    return {
+        columnLabelsValue,
+        onChangeColumnLabels: handleChangeColumnLabels,
+        onChangeTableAttribute: handleChangeTableAttribute,
+        onCommitColumnWidth: handleCommitColumnWidth,
+        tableDisplayAttributes
+    };
+};
+export { useTableSettings };