@vuu-ui/vuu-table-extras 0.13.4 → 0.13.5

package/package.json

@@ -1,20 +1,20 @@
 {
-  "version": "0.13.4",
+  "version": "0.13.5",
   "author": "heswell",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@vuu-ui/vuu-filter-types": "0.13.4",
-    "@vuu-ui/vuu-protocol-types": "0.13.4"
+    "@vuu-ui/vuu-filter-types": "0.13.5",
+    "@vuu-ui/vuu-protocol-types": "0.13.5"
   },
   "dependencies": {
-    "@vuu-ui/vuu-codemirror": "0.13.4",
-    "@vuu-ui/vuu-data-react": "0.13.4",
-    "@vuu-ui/vuu-data-types": "0.13.4",
-    "@vuu-ui/vuu-table-types": "0.13.4",
-    "@vuu-ui/vuu-popups": "0.13.4",
-    "@vuu-ui/vuu-table": "0.13.4",
-    "@vuu-ui/vuu-utils": "0.13.4",
-    "@vuu-ui/vuu-ui-controls": "0.13.4",
+    "@vuu-ui/vuu-codemirror": "0.13.5",
+    "@vuu-ui/vuu-data-react": "0.13.5",
+    "@vuu-ui/vuu-data-types": "0.13.5",
+    "@vuu-ui/vuu-table-types": "0.13.5",
+    "@vuu-ui/vuu-popups": "0.13.5",
+    "@vuu-ui/vuu-table": "0.13.5",
+    "@vuu-ui/vuu-utils": "0.13.5",
+    "@vuu-ui/vuu-ui-controls": "0.13.5",
     "@lezer/lr": "1.4.2",
     "@salt-ds/core": "1.43.0",
     "@salt-ds/styles": "0.2.1",
@@ -31,15 +31,18 @@
   "files": [
     "README.md",
     "esm",
-    "cjs"
+    "cjs",
+    "/types"
   ],
   "exports": {
     ".": {
       "require": "./cjs/index.js",
-      "import": "./esm/index.js"
+      "import": "./esm/index.js",
+      "types": "./types/index.d.ts"
     }
   },
   "main": "cjs/index.js",
   "module": "esm/index.js",
-  "name": "@vuu-ui/vuu-table-extras"
+  "name": "@vuu-ui/vuu-table-extras",
+  "types": "types/index.d.ts"
 }

package/types/cell-edit-validators/CaseValidator.d.ts

@@ -0,0 +1,2 @@
+import { EditRuleValidator } from "@vuu-ui/vuu-data-types";
+export declare const CaseValidator: EditRuleValidator;

package/types/cell-edit-validators/PatternValidator.d.ts

@@ -0,0 +1,2 @@
+import { EditRuleValidator } from "@vuu-ui/vuu-data-types";
+export declare const PatternValidator: EditRuleValidator;

package/types/cell-edit-validators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CaseValidator";
+export * from "./PatternValidator";

package/types/cell-renderers/background-cell/BackgroundCell.d.ts

@@ -0,0 +1,2 @@
+import { TableCellRendererProps } from "@vuu-ui/vuu-table-types";
+export declare const BackgroundCell: import("react").NamedExoticComponent<TableCellRendererProps>;

package/types/cell-renderers/background-cell/BackgroundCellConfigurationEditor.d.ts

@@ -0,0 +1,2 @@
+import { ConfigurationEditorProps } from "@vuu-ui/vuu-utils";
+export declare const BackgroundCellConfigurationEditor: ({ column, onChangeRendering, }: ConfigurationEditorProps) => import("react/jsx-runtime").JSX.Element;

package/types/cell-renderers/background-cell/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BackgroundCell";
+export * from "./BackgroundCellConfigurationEditor";

package/types/cell-renderers/background-cell/useDirection.d.ts

@@ -0,0 +1,3 @@
+import { RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { valueChangeDirection } from "@vuu-ui/vuu-utils";
+export declare function useDirection(key: string, value: unknown, column: RuntimeColumnDescriptor): valueChangeDirection;

package/types/cell-renderers/dropdown-cell/DropdownCell.d.ts

@@ -0,0 +1,2 @@
+import { TableCellRendererProps } from "@vuu-ui/vuu-table-types";
+export declare const DropdownCell: import("react").NamedExoticComponent<TableCellRendererProps>;

package/types/cell-renderers/dropdown-cell/index.d.ts

@@ -0,0 +1 @@
+export * from "./DropdownCell";

package/types/cell-renderers/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./background-cell";
+export * from "./dropdown-cell";
+export * from "./lookup-cell";
+export * from "./pct-progress-cell";
+export * from "./progress-cell";

package/types/cell-renderers/lookup-cell/LookupCell.d.ts

@@ -0,0 +1,2 @@
+import { TableCellRendererProps } from "@vuu-ui/vuu-table-types";
+export declare const LookupCell: import("react").NamedExoticComponent<TableCellRendererProps>;

package/types/cell-renderers/lookup-cell/index.d.ts

@@ -0,0 +1 @@
+export * from "./LookupCell";

package/types/cell-renderers/pct-progress-cell/PctProgressCell.d.ts

@@ -0,0 +1,2 @@
+import { TableCellProps } from "@vuu-ui/vuu-table-types";
+export declare const PctProgressCell: ({ column, columnMap, row }: TableCellProps) => import("react/jsx-runtime").JSX.Element;

package/types/cell-renderers/pct-progress-cell/index.d.ts

@@ -0,0 +1 @@
+export * from "./PctProgressCell";

package/types/cell-renderers/progress-cell/ProgressCell.d.ts

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

package/types/cell-renderers/progress-cell/index.d.ts

@@ -0,0 +1 @@
+export * from "./ProgressCell";

package/types/column-expression-input/ColumnExpressionInput.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes } from "react";
+import { ColumnDefinitionExpression } from "./column-language-parser";
+import { ExpressionSuggestionConsumer } from "./useColumnExpressionEditor";
+export type ColumnExpressionSubmitHandler = (source: string, expression: ColumnDefinitionExpression | undefined) => void;
+export interface ColumnExpressionInputProps extends ExpressionSuggestionConsumer, Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    onChange?: (source: string) => void;
+    onSubmitExpression?: ColumnExpressionSubmitHandler;
+    source?: string;
+}
+export declare const ColumnExpressionInput: import("react").MemoExoticComponent<({ onChange, onSubmitExpression, source, suggestionProvider, }: ColumnExpressionInputProps) => import("react/jsx-runtime").JSX.Element>;

package/types/column-expression-input/column-function-descriptors.d.ts

@@ -0,0 +1,15 @@
+export type ColumnFunctionDescriptor = {
+    accepts: "string" | "number" | "boolean" | "any" | Array<"string" | "number" | "boolean">;
+    description: string;
+    example: {
+        expression: string;
+        result: string;
+    };
+    name: string;
+    params: {
+        count?: number;
+        description: string;
+    };
+    type: "string" | "number" | "boolean" | "variable";
+};
+export declare const columnFunctionDescriptors: ColumnFunctionDescriptor[];

package/types/column-expression-input/column-language-parser/ColumnExpressionLanguage.d.ts

@@ -0,0 +1,2 @@
+import { LanguageSupport } from "@vuu-ui/vuu-codemirror";
+export declare const columnExpressionLanguageSupport: () => LanguageSupport;

package/types/column-expression-input/column-language-parser/ColumnExpressionTreeWalker.d.ts

@@ -0,0 +1,58 @@
+import { Tree } from "@vuu-ui/vuu-codemirror";
+import { RelationalExpression } from "./generated/column-parser.terms";
+type expressionType = "arithmeticExpression" | "booleanCondition" | "booleanLiteralExpression" | "callExpression" | "colExpression" | "conditionalExpression" | "numericLiteralExpression" | "relationalExpression" | "stringLiteralExpression" | "unknown";
+type arithmeticOp = "*" | "/" | "+" | "-" | "unknown";
+type booleanOp = "and" | "or";
+type relationalOp = "=" | "!=" | ">" | ">=" | "<" | "<=" | "unknown";
+export interface Expression {
+    type: expressionType;
+    expressions?: Expression[];
+    toJSON?: () => unknown;
+    value?: string | number | boolean;
+}
+interface BooleanLiteralExpression {
+    type: "booleanLiteralExpression";
+    value: boolean;
+}
+interface NumericLiteralExpression {
+    type: "numericLiteralExpression";
+    value: number;
+}
+interface StringLiteralExpression {
+    type: "stringLiteralExpression";
+    value: string;
+}
+interface ArithmeticExpression extends Expression {
+    expressions: [Expression, Expression];
+    op: arithmeticOp;
+    type: "arithmeticExpression";
+}
+interface BooleanCondition extends Expression {
+    expressions: Expression[];
+    op: booleanOp;
+    type: "booleanCondition";
+}
+interface RelationalExpression extends Expression {
+    expressions: Expression[];
+    op: relationalOp;
+    type: "relationalExpression";
+}
+interface ColExpression extends Expression {
+    column?: string;
+    type: "colExpression";
+}
+interface CallExpression extends Expression {
+    arguments: Expression[];
+    functionName?: string;
+    type: "callExpression";
+}
+type ConditionExpression = RelationalExpression | BooleanCondition;
+interface ConditionalExpression extends Expression {
+    type: "conditionalExpression";
+    condition: ConditionExpression;
+    truthyExpression: Expression;
+    falsyExpression: Expression;
+}
+export type ColumnDefinitionExpression = ArithmeticExpression | BooleanLiteralExpression | CallExpression | ColExpression | ConditionalExpression | NumericLiteralExpression | StringLiteralExpression;
+export declare const walkTree: (tree: Tree, source: string) => ColumnDefinitionExpression;
+export {};

package/types/column-expression-input/column-language-parser/column-expression-parse-utils.d.ts

@@ -0,0 +1,5 @@
+import type { SyntaxNode } from "@vuu-ui/vuu-codemirror";
+export declare const ColumnNamedTerms: readonly string[];
+export declare const isCompleteExpression: (src: string) => boolean;
+export declare const lastNamedChild: (node: SyntaxNode) => SyntaxNode | null;
+export declare const isCompleteRelationalExpression: (node?: SyntaxNode) => boolean;

package/types/column-expression-input/column-language-parser/generated/column-parser.d.ts

@@ -0,0 +1,2 @@
+export const parser: LRParser;
+import { LRParser } from "@lezer/lr";

package/types/column-expression-input/column-language-parser/generated/column-parser.terms.d.ts

@@ -0,0 +1,24 @@
+export const ColumnDefinitionExpression: 1;
+export const Column: 2;
+export const Number: 3;
+export const String: 4;
+export const True: 5;
+export const False: 6;
+export const ParenthesizedExpression: 7;
+export const OpenBrace: 8;
+export const CloseBrace: 9;
+export const ArithmeticExpression: 10;
+export const Divide: 11;
+export const Times: 12;
+export const Plus: 13;
+export const Minus: 14;
+export const ConditionalExpression: 15;
+export const If: 16;
+export const RelationalExpression: 17;
+export const RelationalOperator: 18;
+export const AndCondition: 19;
+export const OrCondition: 20;
+export const Comma: 21;
+export const CallExpression: 22;
+export const Function: 23;
+export const ArgList: 24;

package/types/column-expression-input/column-language-parser/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ColumnExpressionLanguage";
+export * from "./ColumnExpressionTreeWalker";
+export * from "./column-expression-parse-utils";

package/types/column-expression-input/column-language-parser/test.d.mts

@@ -0,0 +1 @@
+export function walkTree(tree: any, source: any): void;

package/types/column-expression-input/functionDocInfo.d.ts

@@ -0,0 +1,2 @@
+import { ColumnFunctionDescriptor } from "./column-function-descriptors";
+export declare const functionDocInfo: ({ name, description, example, params, type, }: ColumnFunctionDescriptor) => HTMLElement;

package/types/column-expression-input/highlighting.d.ts

@@ -0,0 +1 @@
+export declare const vuuHighlighting: import("@codemirror/state").Extension;

package/types/column-expression-input/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ColumnExpressionInput";
+export * from "./column-language-parser";
+export * from "./useColumnExpressionEditor";
+export * from "./useColumnExpressionSuggestionProvider";

package/types/column-expression-input/theme.d.ts

@@ -0,0 +1 @@
+export declare const vuuTheme: import("@codemirror/state").Extension;

package/types/column-expression-input/useColumnAutoComplete.d.ts

@@ -0,0 +1,6 @@
+import { CompletionSource } from "@vuu-ui/vuu-codemirror";
+import { MutableRefObject } from "react";
+import { IExpressionSuggestionProvider } from "./useColumnExpressionEditor";
+export type ApplyCompletion = (mode?: "add" | "replace") => void;
+export type Operator = "";
+export declare const useColumnAutoComplete: (suggestionProvider: IExpressionSuggestionProvider, onSubmit: MutableRefObject<ApplyCompletion>) => CompletionSource;

package/types/column-expression-input/useColumnExpressionEditor.d.ts

@@ -0,0 +1,25 @@
+import { Completion } from "@vuu-ui/vuu-codemirror";
+import { FocusEventHandler } from "react";
+import { ColumnExpressionInputProps } from "./ColumnExpressionInput";
+export type ColumnExpressionOperator = "Times" | "Divide" | "Minus" | "Plus";
+export type ColumnExpressionSuggestionType = "column" | "columnValue" | "expression" | "condition-operator" | "operator" | "relational-operator";
+export type ColumnExpressionSuggestionOptions = {
+    columnName?: string;
+    functionName?: string;
+    operator?: ColumnExpressionOperator;
+    prefix?: string;
+    startsWith?: string;
+    selection?: string[];
+};
+export interface IExpressionSuggestionProvider {
+    getSuggestions: (valueType: ColumnExpressionSuggestionType, options?: ColumnExpressionSuggestionOptions) => Promise<Completion[]>;
+    isPartialMatch: (valueType: ColumnExpressionSuggestionType, columnName?: string, text?: string | undefined) => Promise<boolean>;
+}
+export interface ExpressionSuggestionConsumer {
+    suggestionProvider: IExpressionSuggestionProvider;
+}
+export declare const useColumnExpressionEditor: ({ onChange, onSubmitExpression, source, suggestionProvider, }: ColumnExpressionInputProps) => {
+    editorRef: import("react").RefObject<HTMLDivElement | null>;
+    clearInput: () => void;
+    onBlur: FocusEventHandler;
+};

package/types/column-expression-input/useColumnExpressionSuggestionProvider.d.ts

@@ -0,0 +1,8 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { IExpressionSuggestionProvider } from "./useColumnExpressionEditor";
+export interface SuggestionProviderHookProps {
+    columns: ColumnDescriptor[];
+    table: VuuTable;
+}
+export declare const useColumnExpressionSuggestionProvider: ({ columns, table, }: SuggestionProviderHookProps) => IExpressionSuggestionProvider;

package/types/column-expression-panel/ColumnExpressionPanel.d.ts

@@ -0,0 +1,13 @@
+import { VuuColumnDataType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor, ColumnSettingsProps } from "@vuu-ui/vuu-table-types";
+import { HTMLAttributes } from "react";
+export interface ColumnExpressionPanelProps extends HTMLAttributes<HTMLDivElement>, Pick<ColumnSettingsProps, "tableConfig" | "vuuTable"> {
+    column: ColumnDescriptor;
+    /**
+     * Callback prop, invoked on every change to calculated column definition
+     * @param calculatedColumnName the full calculated column name
+     */
+    onChangeName?: (name: string) => void;
+    onChangeServerDataType?: (name: VuuColumnDataType) => void;
+}
+export declare const ColumnExpressionPanel: ({ column: columnProp, onChangeName: onChangeNameProp, onChangeServerDataType: onChangeServerDataTypeProp, tableConfig, vuuTable, }: ColumnExpressionPanelProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-expression-panel/index.d.ts

@@ -0,0 +1 @@
+export * from "./ColumnExpressionPanel";

package/types/column-expression-panel/useColumnExpression.d.ts

@@ -0,0 +1,10 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { FormEventHandler, SyntheticEvent } from "react";
+import { ColumnExpressionPanelProps } from "./ColumnExpressionPanel";
+export type ColumnExpressionHookProps = Pick<ColumnExpressionPanelProps, "column" | "onChangeName" | "onChangeServerDataType">;
+export declare const useColumnExpression: ({ column: columnProp, onChangeName: onChangeNameProp, onChangeServerDataType: onChangeServerDataTypeProp, }: ColumnExpressionHookProps) => {
+    column: ColumnDescriptor;
+    onChangeExpression: (value: string) => void;
+    onChangeName: FormEventHandler;
+    onChangeServerDataType: (_e: SyntheticEvent, [serverDataType]: string[]) => void;
+};

package/types/column-formatting-settings/BaseNumericFormattingSettings.d.ts

@@ -0,0 +1,2 @@
+import { FormattingSettingsProps } from "@vuu-ui/vuu-table-types";
+export declare const BaseNumericFormattingSettings: ({ column, onChangeFormatting: onChange, }: FormattingSettingsProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-formatting-settings/ColumnFormattingPanel.d.ts

@@ -0,0 +1,9 @@
+import { ColumnDescriptor, ColumnTypeRendering, FormattingSettingsProps } from "@vuu-ui/vuu-table-types";
+import { CellRendererDescriptor } from "@vuu-ui/vuu-utils";
+import { HTMLAttributes } from "react";
+export interface ColumnFormattingPanelProps extends HTMLAttributes<HTMLDivElement>, FormattingSettingsProps {
+    availableRenderers: CellRendererDescriptor[];
+    column: ColumnDescriptor;
+    onChangeRendering: (renderProps: ColumnTypeRendering) => void;
+}
+export declare const ColumnFormattingPanel: ({ availableRenderers, className, column, onChangeFormatting, onChangeColumnType, onChangeRendering, ...htmlAttributes }: ColumnFormattingPanelProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-formatting-settings/DateTimeFormattingSettings.d.ts

@@ -0,0 +1,4 @@
+import { DateTimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
+import { FormattingSettingsProps } from "@vuu-ui/vuu-table-types";
+import React from "react";
+export declare const DateTimeFormattingSettings: React.FC<FormattingSettingsProps<DateTimeDataValueDescriptor>>;

package/types/column-formatting-settings/LongTypeFormattingSettings.d.ts

@@ -0,0 +1,2 @@
+import { FormattingSettingsProps } from "@vuu-ui/vuu-table-types";
+export declare const LongTypeFormattingSettings: (props: FormattingSettingsProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-formatting-settings/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ColumnFormattingPanel";
+export * from "./BaseNumericFormattingSettings";
+export * from "./DateTimeFormattingSettings";

package/types/column-list/ColumnList.d.ts

@@ -0,0 +1,12 @@
+import { ColumnDescriptor, ColumnListPermissions } from "@vuu-ui/vuu-table-types";
+import { HTMLAttributes } from "react";
+import { ColumnItem } from "../table-column-settings/useTableSettings";
+export type ColumnChangeHandler = (columnName: string, propertyName: keyof ColumnDescriptor | "subscribed", value: string | number | boolean) => void;
+export interface ColumnListProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    columnItems: ColumnItem[];
+    onChange: ColumnChangeHandler;
+    onNavigateToColumn?: (columnName: string) => void;
+    onReorderColumnItems?: (columnItems: ColumnItem[]) => void;
+    permissions?: ColumnListPermissions;
+}
+export declare const ColumnList: ({ className, columnItems, onChange, onNavigateToColumn, onReorderColumnItems, permissions, ...htmlAttributes }: ColumnListProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-list/index.d.ts

@@ -0,0 +1 @@
+export * from "./ColumnList";

package/types/column-menu/ColumnMenu.d.ts

@@ -0,0 +1,10 @@
+import { ColumnDescriptor, ColumnMenuPermissions } from "@vuu-ui/vuu-table-types";
+import { HTMLAttributes } from "react";
+import { ColumnMenuActionType } from "./column-menu-utils";
+import { MenuActionHandler } from "@vuu-ui/vuu-context-menu";
+export interface ColumnMenuProps extends HTMLAttributes<HTMLSpanElement> {
+    column: ColumnDescriptor;
+    menuActionHandler?: MenuActionHandler<ColumnMenuActionType, ColumnDescriptor>;
+    menuPermissions?: ColumnMenuPermissions;
+}
+export declare const ColumnMenu: ({ className, column, menuActionHandler: menuActionHandlerProp, menuPermissions: { allowSort, allowGroup, allowAggregation, allowHide, allowPin, allowColumnSettings, allowTableSettings, }, }: ColumnMenuProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-menu/column-action-types.d.ts

@@ -0,0 +1,24 @@
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor, PinLocation } from "@vuu-ui/vuu-table-types";
+export interface ColumnPinAction {
+    type: "pinColumn";
+    column: ColumnDescriptor;
+    pin: PinLocation | false;
+}
+export interface ColumnHideAction {
+    type: "hideColumn";
+    column: ColumnDescriptor;
+}
+export type ColumnDisplayAction = ColumnPinAction | ColumnHideAction;
+export type ColumnDisplayActionHandler = (action: ColumnDisplayAction) => void;
+export type DisplayTableSettingsAction = {
+    type: "table-settings";
+};
+export type DisplayColumnSettingsAction = {
+    type: "column-settings";
+    column: ColumnDescriptor;
+    /**  only for calculated columnn */
+    vuuTable?: VuuTable;
+};
+export type DisplaySettingsAction = DisplayTableSettingsAction | DisplayColumnSettingsAction;
+export type TableSettingsActionHandler = (action: DisplaySettingsAction) => void;

package/types/column-menu/column-menu-utils.d.ts

@@ -0,0 +1,21 @@
+import { Menu, MenuItem, MenuItemProps, MenuProps } from "@salt-ds/core";
+import { DataSource } from "@vuu-ui/vuu-data-types";
+import { ColumnDescriptor, TableSettingsPermissions } from "@vuu-ui/vuu-table-types";
+import { MouseEventHandler, ReactElement } from "react";
+type MenuElement = ReactElement<MenuProps, typeof Menu>;
+type MenuItemElement = ReactElement<MenuItemProps, typeof MenuItem>;
+type MenuElements = Array<MenuElement | MenuItemElement>;
+export type MenuItemClickHandler = MouseEventHandler<HTMLDivElement>;
+export type DataSourceColumnMenuActionType = "agg-count" | "agg-distinct" | "agg-sum" | "agg-avg" | "agg-high" | "agg-low" | "sort-asc" | "sort-dsc" | "sort-add-asc" | "sort-add-dsc" | "remove-sort" | "group-column" | "remove-group" | "add-to-group" | "remove-from-group" | "remove-column";
+export type ColumnDisplayColumnMenuActionType = "pin-column-left" | "pin-column-right" | "pin-column-floating" | "unpin-column" | "hide-column";
+export type TableSettingsActionType = "column-settings" | "table-settings";
+export type ColumnMenuActionType = DataSourceColumnMenuActionType | ColumnDisplayColumnMenuActionType | TableSettingsActionType;
+export declare const isColumnMenuActionType: (value?: string) => value is ColumnMenuActionType;
+export declare const getColumnMenuActionType: (target: EventTarget | HTMLElement) => ColumnMenuActionType;
+export declare function buildSortMenu(column: ColumnDescriptor, dataSource: DataSource, menuActionClickHandler: MenuItemClickHandler, isAllowed?: boolean): MenuElement | null;
+export declare function buildGroupMenu(column: ColumnDescriptor, dataSource: DataSource, menuActionClickHandler: MenuItemClickHandler, isAllowed?: boolean): MenuElement | null;
+export declare const buildVisibilityMenuItems: (column: ColumnDescriptor, menuActionClickHandler: MenuItemClickHandler, isAllowed?: boolean) => MenuElements | null;
+export declare const buildPinMenuItems: (column: ColumnDescriptor, menuActionClickHandler: MenuItemClickHandler, isAllowed?: boolean) => MenuElements;
+export declare const buildSettingsMenuItems: (_: ColumnDescriptor, menuActionClickHandler: MenuItemClickHandler, allowColumnSettings?: boolean, allowTableSettings?: boolean | TableSettingsPermissions) => MenuElements | null;
+export declare function buildAggregationMenuItems(column: ColumnDescriptor, dataSource: DataSource, menuActionClickHandler: MenuItemClickHandler, isAllowed?: boolean): MenuElements | null;
+export {};

package/types/column-menu/useColumnActions.d.ts

@@ -0,0 +1,18 @@
+import { MenuActionHandler } from "@vuu-ui/vuu-context-menu";
+import { Filter } from "@vuu-ui/vuu-filter-types";
+import { VuuFilter } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor, RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { ColumnMenuActionType } from "./column-menu-utils";
+import { ColumnDisplayAction, DisplaySettingsAction } from "./column-action-types";
+import { DataSource } from "@vuu-ui/vuu-data-types";
+export interface ContextMenuOptions {
+    column?: RuntimeColumnDescriptor;
+    filter?: Filter;
+    sort?: VuuFilter;
+}
+export interface ContextMenuHookProps {
+    dataSource: DataSource;
+    onColumnDisplayAction?: (action: ColumnDisplayAction) => void;
+    onDisplaySettingsAction?: (action: DisplaySettingsAction) => void;
+}
+export declare const useColumnActions: ({ dataSource, onColumnDisplayAction, onDisplaySettingsAction, }: ContextMenuHookProps) => MenuActionHandler<ColumnMenuActionType, ColumnDescriptor>;

package/types/datasource-stats/DatasourceStats.d.ts

@@ -0,0 +1,7 @@
+import { DataSource } from "@vuu-ui/vuu-data-types";
+import { HTMLAttributes } from "react";
+interface DataSourceStatsProps extends HTMLAttributes<HTMLSpanElement> {
+    dataSource: DataSource;
+}
+export declare const DataSourceStats: ({ className: classNameProp, dataSource, }: DataSourceStatsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types/datasource-stats/index.d.ts

@@ -0,0 +1 @@
+export * from "./DatasourceStats";

package/types/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./cell-edit-validators";
+export * from "./cell-renderers";
+export * from "./column-list";
+export { ColumnMenu } from "./column-menu/ColumnMenu";
+export { useColumnActions } from "./column-menu/useColumnActions";
+export type { ColumnDisplayActionHandler, TableSettingsActionHandler, } from "./column-menu/column-action-types";
+export { ColumnSettingsPanel } from "./table-column-settings/ColumnSettingsPanel";
+export { useColumnSettings } from "./table-column-settings/useColumnSettings";
+export { defaultTableSettingsPermissions, TableSettingsPanel, } from "./table-column-settings/TableSettingsPanel";
+export { type ColumnItem, useTableSettings, } from "./table-column-settings/useTableSettings";
+export { columnSettingsFromColumnMenuPermissions, tableSettingsFromColumnMenuPermissions, useTableAndColumnSettings, } from "./table-column-settings/useTableAndColumnSettings";
+export * from "./column-expression-input";
+export * from "./column-expression-panel";
+export * from "./column-formatting-settings";
+export * from "./datasource-stats";
+export { TableProvider, useTableContext } from "./table-provider/TableProvider";

package/types/table-column-settings/ColumnNameLabel.d.ts

@@ -0,0 +1,7 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { MouseEventHandler } from "react";
+export interface ColumnNameLabelProps {
+    column: ColumnDescriptor;
+    onClick: MouseEventHandler;
+}
+export declare const ColumnNameLabel: ({ column, onClick }: ColumnNameLabelProps) => import("react/jsx-runtime").JSX.Element;

package/types/table-column-settings/ColumnSettingsPanel.d.ts

@@ -0,0 +1,2 @@
+import { ColumnSettingsProps } from "@vuu-ui/vuu-table-types";
+export declare const ColumnSettingsPanel: ({ column: columnProp, onCancelCreateColumn, onConfigChange, onCreateCalculatedColumn, tableConfig, vuuTable, }: ColumnSettingsProps) => import("react/jsx-runtime").JSX.Element;

package/types/table-column-settings/TableSettingsPanel.d.ts

@@ -0,0 +1,8 @@
+import { TableSettingsPermissions, TableSettingsProps } from "@vuu-ui/vuu-table-types";
+export declare const defaultTableSettingsPermissions: Readonly<TableSettingsPermissions>;
+/**
+  The TableSettingsPanel assumes 'ownership' of the tableSettings.
+  It updates the settings in state locally and notifies caller of
+  every change via onChange callback
+ */
+export declare const TableSettingsPanel: ({ availableColumns, onAddCalculatedColumn, onConfigChange, onDataSourceConfigChange, onNavigateToColumn, tableConfig: tableConfigProp, permissions, }: TableSettingsProps) => import("react/jsx-runtime").JSX.Element;

package/types/table-column-settings/useColumnSettings.d.ts

@@ -0,0 +1,23 @@
+import { ColumnDescriptor, ColumnTypeFormatting, ColumnSettingsProps } from "@vuu-ui/vuu-table-types";
+import { CellRendererDescriptor, ColumnRenderPropsChangeHandler } from "@vuu-ui/vuu-utils";
+import { VuuColumnDataType } from "@vuu-ui/vuu-protocol-types";
+import { FormEventHandler } from "react";
+import { DataValueTypeSimple } from "@vuu-ui/vuu-data-types";
+export declare const useColumnSettings: ({ column: columnProp, onCancelCreateColumn, onConfigChange, onCreateCalculatedColumn, tableConfig, }: Omit<ColumnSettingsProps, "vuuTable">) => {
+    availableRenderers: CellRendererDescriptor[];
+    editCalculatedColumn: boolean;
+    column: ColumnDescriptor;
+    navigateNextColumn: () => void;
+    navigatePrevColumn: () => void;
+    onCancel: () => void;
+    onChange: FormEventHandler;
+    onChangeCalculatedColumnName: (name: string) => void;
+    onChangeFormatting: (formatting: ColumnTypeFormatting) => void;
+    onChangeRendering: ColumnRenderPropsChangeHandler;
+    onChangeServerDataType: (serverDataType: VuuColumnDataType) => void;
+    onChangeToggleButton: FormEventHandler;
+    onChangeType: (type: DataValueTypeSimple) => void;
+    onEditCalculatedColumn: () => void;
+    onInputCommit: () => void;
+    onSave: () => void;
+};

package/types/table-column-settings/useTableAndColumnSettings.d.ts

@@ -0,0 +1,18 @@
+import { DataSourceConfig, SchemaColumn } from "@vuu-ui/vuu-data-types";
+import { ColumnDescriptor, ColumnMenuPermissions, SettingsPermissions, TableConfig } from "@vuu-ui/vuu-table-types";
+import { DisplayColumnSettingsAction } from "@vuu-ui/vuu-table-extras/src/column-menu/column-action-types";
+export interface TableAndColumnSettingsHookProps {
+    availableColumns: SchemaColumn[];
+    onAvailableColumnsChange?: (columns: SchemaColumn[]) => void;
+    onConfigChange: (config: TableConfig) => void;
+    onCreateCalculatedColumn: (column: ColumnDescriptor) => void;
+    onDataSourceConfigChange: (dataSourceConfig: DataSourceConfig) => void;
+    settingsPermissions?: SettingsPermissions;
+    tableConfig: TableConfig;
+}
+export declare const columnSettingsFromColumnMenuPermissions: (settings?: boolean | ColumnMenuPermissions) => boolean;
+export declare const tableSettingsFromColumnMenuPermissions: (settings?: boolean | ColumnMenuPermissions) => boolean | Readonly<import("@vuu-ui/vuu-table-types").TableSettingsPermissions>;
+export declare const useTableAndColumnSettings: ({ availableColumns: availableColumnsProps, settingsPermissions, onAvailableColumnsChange, onConfigChange, onCreateCalculatedColumn, onDataSourceConfigChange, tableConfig, }: TableAndColumnSettingsHookProps) => {
+    showColumnSettingsPanel: (action: DisplayColumnSettingsAction) => void;
+    showTableSettingsPanel: () => void;
+};

package/types/table-column-settings/useTableSettings.d.ts

@@ -0,0 +1,21 @@
+import { ColumnDescriptor, TableConfig, TableSettingsProps } from "@vuu-ui/vuu-table-types";
+import { CommitHandler } from "@vuu-ui/vuu-utils";
+import { MouseEvent, SyntheticEvent } from "react";
+import { ColumnChangeHandler } from "../column-list";
+export type ColumnLike = {
+    name: string;
+};
+export type ColumnItem = Pick<ColumnDescriptor, "hidden" | "label" | "name" | "serverDataType"> & {
+    isCalculated: boolean;
+    subscribed: boolean;
+};
+export declare const useTableSettings: ({ availableColumns: availableColumnsProp, onConfigChange, onDataSourceConfigChange, tableConfig: tableConfigProp, }: Omit<TableSettingsProps, "onAddCalculatedColumn">) => {
+    columnItems: ColumnItem[];
+    columnLabelsValue: number;
+    onChangeColumnLabels: (evt: SyntheticEvent) => void;
+    onChangeTableAttribute: (evt: MouseEvent<HTMLButtonElement>) => void;
+    onColumnChange: ColumnChangeHandler;
+    onCommitColumnWidth: CommitHandler;
+    onReorderColumnItems: (columnItems: ColumnItem[]) => void;
+    tableConfig: TableConfig;
+};

package/types/table-provider/TableProvider.d.ts

@@ -0,0 +1,17 @@
+import { MenuActionHandler } from "@vuu-ui/vuu-context-menu";
+import { DataSource } from "@vuu-ui/vuu-data-types";
+import { ReactNode } from "react";
+import { ColumnMenuActionType } from "../column-menu/column-menu-utils";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export interface TableContextProps {
+    dataSource: DataSource;
+    menuActionHandler: MenuActionHandler<ColumnMenuActionType, ColumnDescriptor>;
+}
+export declare const TableContext: import("react").Context<TableContextProps>;
+export declare const TableProvider: ({ children, dataSource, menuActionHandler, }: TableContextProps & {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useTableContext(throwIfNoDataSource?: boolean): {
+    dataSource: DataSource;
+    menuActionHandler: MenuActionHandler<ColumnMenuActionType, ColumnDescriptor>;
+};