@vuu-ui/vuu-table-extras 3.4.0 → 3.4.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.4.0",
+  "version": "3.4.1",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -11,19 +11,19 @@
     "lezer-generate:column": "lezer-generator --output ./src/column-expression-input/column-language-parser/generated/column-parser.js ./src/column-expression-input/column-language-parser/grammar/column.grammar"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-filter-types": "3.4.0",
-    "@vuu-ui/vuu-protocol-types": "3.4.0"
+    "@vuu-ui/vuu-filter-types": "3.4.1",
+    "@vuu-ui/vuu-protocol-types": "3.4.1"
   },
   "dependencies": {
-    "@vuu-ui/vuu-codemirror": "3.4.0",
-    "@vuu-ui/vuu-data-editing": "3.4.0",
-    "@vuu-ui/vuu-data-react": "3.4.0",
-    "@vuu-ui/vuu-data-types": "3.4.0",
-    "@vuu-ui/vuu-table-types": "3.4.0",
-    "@vuu-ui/vuu-popups": "3.4.0",
-    "@vuu-ui/vuu-table": "3.4.0",
-    "@vuu-ui/vuu-utils": "3.4.0",
-    "@vuu-ui/vuu-ui-controls": "3.4.0",
+    "@vuu-ui/vuu-codemirror": "3.4.1",
+    "@vuu-ui/vuu-data-editing": "3.4.1",
+    "@vuu-ui/vuu-data-react": "3.4.1",
+    "@vuu-ui/vuu-data-types": "3.4.1",
+    "@vuu-ui/vuu-table-types": "3.4.1",
+    "@vuu-ui/vuu-popups": "3.4.1",
+    "@vuu-ui/vuu-table": "3.4.1",
+    "@vuu-ui/vuu-utils": "3.4.1",
+    "@vuu-ui/vuu-ui-controls": "3.4.1",
     "@lezer/lr": "1.4.2",
     "@salt-ds/core": "1.54.1",
     "@salt-ds/lab": "1.0.0-alpha.83",

package/src/csv-export/export-utils.js

@@ -1,4 +1,4 @@
-import { Range, isSessionTable, metadataKeys } from "@vuu-ui/vuu-utils";
+import { Range, buildColumnMap, getValueFormatter, isSessionTable, metadataKeys } from "@vuu-ui/vuu-utils";
 const EXPORT_EXCLUDED_COLUMNS = new Set([
     "vuuMsg",
     "vuuAction",
@@ -28,10 +28,31 @@ const triggerCsvDownload = (csv, filename)=>{
     document.body.removeChild(a);
     setTimeout(()=>URL.revokeObjectURL(url), 10000);
 };
+const createRowAccessor = (row, columnMap)=>new Proxy({}, {
+        get (_, prop) {
+            if ("string" == typeof prop) {
+                const idx = columnMap[prop];
+                if (void 0 !== idx) return row[idx];
+            }
+        },
+        has (_, prop) {
+            return "string" == typeof prop && void 0 !== columnMap[prop];
+        }
+    });
+const isExportableColumn = (descriptor)=>{
+    if (!descriptor) return true;
+    if (false === descriptor.exportable) return false;
+    if (descriptor.hidden) return false;
+    if (descriptor.isSystemColumn) return false;
+    if (true === descriptor.exportable) return true;
+    if ("client" === descriptor.source && !descriptor.exportFormatter) return false;
+    return true;
+};
 const exportCsvTemplate = async (dataSource, options = {})=>{
     const { filename = "template.csv", excludeColumns = [], columns, overrides, timeout = DEFAULT_TEMPLATE_TIMEOUT, onError, onSuccess } = options;
-    const sessionOverrides = overrides ?? (columns ? {
-        columns
+    const targetColumnNames = columns ? columns.filter((col)=>"string" == typeof col ? true : isExportableColumn(col) && "client" !== col.source).map((col)=>"string" == typeof col ? col : col.name) : void 0;
+    const sessionOverrides = overrides ?? (targetColumnNames ? {
+        columns: targetColumnNames
     } : void 0);
     if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource && "initialising" !== dataSource.status && "unsubscribed" !== dataSource.status) try {
         const sessionDataSource = await dataSource.createSessionDataSource("Empty", "export", sessionOverrides);
@@ -72,7 +93,7 @@ const exportCsvTemplate = async (dataSource, options = {})=>{
         console.warn("[exportCsvTemplate] createSessionDataSource failed, falling back to tableSchema", error);
     }
     const schema = dataSource.tableSchema;
-    const targetColumns = columns ?? overrides?.columns;
+    const targetColumns = targetColumnNames ?? overrides?.columns;
     if (void 0 !== targetColumns) {
         if (schema) {
             const schemaColumnNames = new Set(schema.columns.map((col)=>col.name));
@@ -99,7 +120,18 @@ const exportCsvTemplate = async (dataSource, options = {})=>{
     onSuccess?.();
 };
 const exportSessionTableToCsv = async (dataSource, options = {})=>{
-    const { filename = "export.csv", copyOption = "All", excludeColumns = [], maxRows = MAX_EXPORT_ROWS, columnDescriptors, overrides, timeout = DEFAULT_EXPORT_TIMEOUT, onError, onSuccess } = options;
+    const { filename = "export.csv", copyOption = "All", excludeColumns = [], maxRows = MAX_EXPORT_ROWS, columnDescriptors: rawColumnDescriptors, columns: rawColumns, overrides, timeout = DEFAULT_EXPORT_TIMEOUT, onError, onSuccess } = options;
+    const rawInputColumns = rawColumns ?? rawColumnDescriptors;
+    const columnDescriptors = rawInputColumns?.map((col)=>"string" == typeof col ? {
+            name: col
+        } : col);
+    const sessionOverrides = overrides ? {
+        ...overrides,
+        columns: overrides.columns?.filter((name)=>{
+            const desc = columnDescriptors?.find((d)=>d.name === name);
+            return desc?.source !== "client";
+        })
+    } : void 0;
     const isRemote = !!dataSource.isRemote;
     if (isRemote && !isSessionTable(dataSource.table) && ("initialising" === dataSource.status || "unsubscribed" === dataSource.status)) {
         const error = new Error(`exportSessionTableToCsv: dataSource must be subscribed before exporting (current status: "${dataSource.status}")`);
@@ -108,7 +140,7 @@ const exportSessionTableToCsv = async (dataSource, options = {})=>{
     }
     let sessionDataSource;
     if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource) try {
-        sessionDataSource = await dataSource.createSessionDataSource(copyOption, "export", overrides);
+        sessionDataSource = await dataSource.createSessionDataSource(copyOption, "export", sessionOverrides);
     } catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
         if (onError) return void onError(error);
@@ -152,18 +184,23 @@ const exportSessionTableToCsv = async (dataSource, options = {})=>{
                 const { columns } = message;
                 if (columnDescriptors) {
                     const subscribedSet = new Set(columns);
-                    const unknown = columnDescriptors.filter((d)=>!excluded.has(d.name) && !subscribedSet.has(d.name)).map((d)=>d.name);
+                    const unknown = columnDescriptors.filter((d)=>"client" !== d.source && !excluded.has(d.name) && !subscribedSet.has(d.name)).map((d)=>d.name);
                     if (unknown.length > 0) return void fail(new Error(`exportToCsv: unknown column(s) in columnDescriptors: ${unknown.join(", ")}`));
                     descriptorMap = Object.fromEntries(columnDescriptors.map((d)=>[
                             d.name,
                             d
                         ]));
                 }
-                exportCols = columns.filter((name)=>!excluded.has(name));
-                colNameToRowIdx = Object.fromEntries(columns.map((name, i)=>[
-                        name,
-                        metadataKeys.count + i
-                    ]));
+                if (rawColumns) exportCols = rawColumns.map((c)=>"string" == typeof c ? c : c.name).filter((name)=>!excluded.has(name) && isExportableColumn(descriptorMap[name]));
+                else if (columnDescriptors?.some((d)=>"client" === d.source)) {
+                    const definedNames = new Set(columnDescriptors.map((d)=>d.name));
+                    const remainingSubscribed = columns.filter((name)=>!excluded.has(name) && !definedNames.has(name) && isExportableColumn(descriptorMap[name]));
+                    exportCols = [
+                        ...columnDescriptors.filter((d)=>!excluded.has(d.name) && isExportableColumn(d)).map((d)=>d.name),
+                        ...remainingSubscribed
+                    ];
+                } else exportCols = columns.filter((name)=>!excluded.has(name) && isExportableColumn(descriptorMap[name]));
+                colNameToRowIdx = buildColumnMap(columns);
             } else if ("viewport-update" === message.type) {
                 if ("size-only" === message.mode) {
                     totalSize = message.size ?? 0;
@@ -191,11 +228,21 @@ const exportSessionTableToCsv = async (dataSource, options = {})=>{
                         ];
                         for(let i = 0; i < totalSize; i++){
                             const row = collectedRows.get(i);
-                            if (row) lines.push(exportCols.map((c)=>{
-                                const raw = row[colNameToRowIdx[c]];
-                                const formatter = descriptorMap[c]?.exportFormatter;
-                                return csvCell(formatter ? formatter(raw) : raw);
-                            }).join(","));
+                            if (row) {
+                                const rowAccessor = createRowAccessor(row, colNameToRowIdx);
+                                lines.push(exportCols.map((c)=>{
+                                    const descriptor = descriptorMap[c];
+                                    const isClientCol = descriptor?.source === "client";
+                                    const raw = isClientCol ? void 0 : void 0 !== colNameToRowIdx[c] ? row[colNameToRowIdx[c]] : void 0;
+                                    let formatted;
+                                    if (descriptor?.exportFormatter) formatted = descriptor.exportFormatter(raw, rowAccessor);
+                                    else if (descriptor && ("type" in descriptor || "serverDataType" in descriptor)) {
+                                        const tableFormatter = getValueFormatter(descriptor);
+                                        formatted = tableFormatter(raw);
+                                    } else formatted = raw;
+                                    return csvCell(formatted);
+                                }).join(","));
+                            }
                         }
                         triggerCsvDownload(lines.join("\r\n"), filename);
                         onSuccess?.();
@@ -213,9 +260,9 @@ const exportSessionTableToCsv = async (dataSource, options = {})=>{
         };
         activeSessionDataSource.subscribe({
             range: Range(0, 0),
-            columns: overrides?.columns
+            columns: sessionOverrides?.columns
         }, handleMessage);
     });
 };
 const exportToCsv = async (dataSource, options)=>exportSessionTableToCsv(dataSource, options);
-export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv };
+export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv, isExportableColumn };

package/src/csv-export/index.js

@@ -1,2 +1,2 @@
-export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv } from "./export-utils.js";
+export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv, isExportableColumn } from "./export-utils.js";
 export { useCsvExport } from "./useCsvExport.js";

package/src/csv-export/useCsvExport.js

@@ -6,7 +6,7 @@ function useCsvExport(propsOrDataSource) {
     const config = propsOrDataSource && "table" in propsOrDataSource ? {
         dataSource: propsOrDataSource
     } : propsOrDataSource ?? {};
-    const { dataSource: defaultDataSource, onError, onSuccess } = config;
+    const { dataSource: defaultDataSource, tableConfig, columns: defaultColumns, onError, onSuccess } = config;
     const exportCsv = useCallback(async (options, overrideDataSource)=>{
         const activeDataSource = overrideDataSource ?? defaultDataSource;
         if (!activeDataSource) {
@@ -19,7 +19,9 @@ function useCsvExport(propsOrDataSource) {
         setIsExporting(true);
         setError(null);
         try {
+            const columnsToExport = options?.columns ?? options?.columnDescriptors ?? defaultColumns ?? tableConfig?.columns;
             await exportToCsv(activeDataSource, {
+                columns: columnsToExport,
                 ...options,
                 onError: (err)=>{
                     setError(err);
@@ -42,6 +44,8 @@ function useCsvExport(propsOrDataSource) {
         }
     }, [
         defaultDataSource,
+        defaultColumns,
+        tableConfig,
         onError,
         onSuccess
     ]);
@@ -57,7 +61,9 @@ function useCsvExport(propsOrDataSource) {
         setIsExporting(true);
         setError(null);
         try {
+            const templateColumns = options?.columns ?? defaultColumns ?? tableConfig?.columns;
             await exportCsvTemplate(activeDataSource, {
+                columns: templateColumns,
                 ...options,
                 onError: (err)=>{
                     setError(err);
@@ -80,6 +86,8 @@ function useCsvExport(propsOrDataSource) {
         }
     }, [
         defaultDataSource,
+        defaultColumns,
+        tableConfig,
         onError,
         onSuccess
     ]);

package/types/csv-export/export-utils.d.ts

@@ -1,16 +1,28 @@
 import type { CopyOption, DataSource, SessionDataSourceOverrides } from "@vuu-ui/vuu-data-types";
-export type ExportColumnDescriptor<TName extends string = string> = {
-    name: TName;
-    /** Override the column name used as the CSV header label. */
+import type { ColumnDescriptor, RowAccessor } from "@vuu-ui/vuu-table-types";
+export type { RowAccessor };
+export type ExportServerColumnDescriptor = Omit<ColumnDescriptor, "source" | "exportFormatter"> & {
+    name: string;
+    source?: "server";
     label?: string;
-    exportFormatter?: (value: unknown) => string;
+    exportable?: boolean;
+    exportFormatter?: (value: unknown, row: RowAccessor) => string;
 };
-export interface ExportToCsvOptions<TName extends string = string> {
+export type ExportClientColumnDescriptor = Omit<ColumnDescriptor, "source" | "exportFormatter"> & {
+    name: string;
+    source: "client";
+    label?: string;
+    exportable?: boolean;
+    exportFormatter: (value: unknown, row: RowAccessor) => string;
+};
+export type ExportColumnDescriptor = ExportServerColumnDescriptor | ExportClientColumnDescriptor;
+export interface ExportToCsvOptions {
     filename?: string;
     copyOption?: CopyOption;
     excludeColumns?: string[];
     maxRows?: number;
-    columnDescriptors?: ExportColumnDescriptor<TName>[];
+    columnDescriptors?: readonly (ExportColumnDescriptor | ColumnDescriptor)[];
+    columns?: readonly (string | ExportColumnDescriptor | ColumnDescriptor)[];
     overrides?: SessionDataSourceOverrides;
     /** Timeout in milliseconds before the export times out. Default: 30_000ms (0 to disable). */
     timeout?: number;
@@ -20,13 +32,14 @@ export interface ExportToCsvOptions<TName extends string = string> {
 export interface ExportCsvTemplateOptions {
     filename?: string;
     excludeColumns?: string[];
-    columns?: string[];
+    columns?: readonly (string | ColumnDescriptor)[];
     overrides?: SessionDataSourceOverrides;
     /** Timeout in milliseconds before template generation times out. Default: 10_000ms (0 to disable). */
     timeout?: number;
     onError?: (error: Error) => void;
     onSuccess?: () => void;
 }
+export declare const isExportableColumn: (descriptor?: ExportColumnDescriptor | ColumnDescriptor) => boolean;
 /** Downloads a single-row CSV containing only the column headers, for use as an import template. */
 export declare const exportCsvTemplate: (dataSource: DataSource, options?: ExportCsvTemplateOptions) => Promise<void>;
 /**
@@ -35,8 +48,8 @@ export declare const exportCsvTemplate: (dataSource: DataSource, options?: Expor
  * then triggers a browser download. The session data source is unsubscribed automatically once the download
  * is initiated.
  */
-export declare const exportSessionTableToCsv: <TName extends string = string>(dataSource: DataSource, options?: ExportToCsvOptions<TName>) => Promise<void>;
+export declare const exportSessionTableToCsv: (dataSource: DataSource, options?: ExportToCsvOptions) => Promise<void>;
 /**
  * Creates an export session table from `dataSource`, collects all rows in memory, then triggers a CSV download.
  */
-export declare const exportToCsv: <TName extends string = string>(dataSource: DataSource, options?: ExportToCsvOptions<TName>) => Promise<void>;
+export declare const exportToCsv: (dataSource: DataSource, options?: ExportToCsvOptions) => Promise<void>;

package/types/csv-export/index.d.ts

@@ -1,2 +1,2 @@
-export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv, type ExportColumnDescriptor, type ExportCsvTemplateOptions, type ExportToCsvOptions, } from "./export-utils";
+export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv, isExportableColumn, type ExportClientColumnDescriptor, type ExportColumnDescriptor, type ExportCsvTemplateOptions, type ExportServerColumnDescriptor, type ExportToCsvOptions, type RowAccessor, } from "./export-utils";
 export { useCsvExport, type UseCsvExportProps, type UseCsvExportResult, } from "./useCsvExport";

package/types/csv-export/useCsvExport.d.ts

@@ -1,14 +1,17 @@
 import type { DataSource } from "@vuu-ui/vuu-data-types";
-import { type ExportCsvTemplateOptions, type ExportToCsvOptions } from "./export-utils";
+import type { ColumnDescriptor, TableConfig } from "@vuu-ui/vuu-table-types";
+import { type ExportColumnDescriptor, type ExportCsvTemplateOptions, type ExportToCsvOptions } from "./export-utils";
 export interface UseCsvExportProps {
     dataSource?: DataSource;
+    tableConfig?: TableConfig;
+    columns?: readonly (string | ExportColumnDescriptor | ColumnDescriptor)[];
     onError?: (error: Error) => void;
     onSuccess?: () => void;
 }
 export interface UseCsvExportResult {
     isExporting: boolean;
     error: Error | null;
-    exportCsv: <TName extends string = string>(options?: ExportToCsvOptions<TName>, overrideDataSource?: DataSource) => Promise<void>;
+    exportCsv: (options?: ExportToCsvOptions, overrideDataSource?: DataSource) => Promise<void>;
     exportTemplate: (options?: ExportCsvTemplateOptions, overrideDataSource?: DataSource) => Promise<void>;
 }
 export declare function useCsvExport(propsOrDataSource?: DataSource | UseCsvExportProps): UseCsvExportResult;

package/types/inline-add-row/useInlineAddRow.d.ts

@@ -38,7 +38,8 @@ export declare const useInlineAddRow: ({ columns }: UseInlineAddRowProps) => {
         allowColumnHeaderMenu?: false;
         colHeaderContentRenderer?: string;
         colHeaderLabelRenderer?: string;
-        exportFormatter?: (value: unknown) => string;
+        exportable?: boolean;
+        exportFormatter?: (value: unknown, row: import("@vuu-ui/vuu-table-types").RowAccessor) => string;
         getIcon?: (row: DataRow) => string | undefined;
         groupable?: boolean;
         hidden?: boolean;

package/types/src/calculated-column/CalculatedColumnPanel.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from "react";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { VuuColumnDataType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ColumnModel } from "../column-picker/ColumnModel";
+export interface CalculatedColumnPanelProps extends HTMLAttributes<HTMLDivElement> {
+    column: ColumnDescriptor;
+    columnModel: ColumnModel;
+    onChangeColumn: (column: ColumnDescriptor) => void;
+    onChangeServerDataType?: (name: VuuColumnDataType) => void;
+    vuuTable: VuuTable;
+}
+export declare const CalculatedColumnPanel: ({ column: columnProp, columnModel, onChangeColumn, onChangeServerDataType: onChangeServerDataTypeProp, vuuTable, }: CalculatedColumnPanelProps) => import("react").JSX.Element;

package/types/src/calculated-column/useCalculatedColumnPanel.d.ts

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

package/types/src/calculated-column/useEditCalculatedColumn.d.ts

@@ -0,0 +1,13 @@
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { ColumnModel } from "../column-picker/ColumnModel";
+export interface EditCalculatedColumnProps {
+    calculatedColumn?: ColumnDescriptor;
+    columnModel: ColumnModel;
+    onSaveColumn?: (caclulatedColumn: ColumnDescriptor) => void;
+    vuuTable?: VuuTable;
+}
+export declare const useEditCalculatedColumn: ({ calculatedColumn, columnModel, onSaveColumn, vuuTable, }: EditCalculatedColumnProps) => {
+    onCreateCalculatedColumn: () => void;
+    onEditCalculatedColumn: () => void;
+};

package/types/src/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/src/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/src/cell-edit-validators/index.d.ts

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

package/types/src/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").MemoExoticComponent<({ column, dataRow, }: TableCellRendererProps) => import("react").JSX.Element>;

package/types/src/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.Element;

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

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

package/types/src/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/src/cell-renderers/button-cell/IconButtonCell.d.ts

@@ -0,0 +1,6 @@
+import { TableCellRendererProps } from "@vuu-ui/vuu-table-types";
+/**
+ * To assign an icon to the cell, give the columndescriptor
+ * a className. In css, assign an icon variable to --vuu-svg-icon.
+ */
+export declare const IconButtonCell: ({ column, dataRow }: TableCellRendererProps) => import("react").JSX.Element;

package/types/src/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").MemoExoticComponent<({ column, dataRow, editedDuringCurrentSession, onEdit, }: TableCellRendererProps) => import("react").JSX.Element>;

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

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

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

@@ -0,0 +1,6 @@
+export * from "./background-cell";
+export * from "./dropdown-cell";
+export * from "./lookup-cell";
+export * from "./pct-progress-cell";
+export * from "./progress-cell";
+export { IconButtonCell } from "./button-cell/IconButtonCell";

package/types/src/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").MemoExoticComponent<({ column, dataRow, }: TableCellRendererProps) => import("react").JSX.Element>;

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

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

package/types/src/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, dataRow }: TableCellProps) => import("react").JSX.Element;

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

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

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

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

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

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

package/types/src/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.Element>;

package/types/src/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/src/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/src/column-expression-input/column-language-parser/ColumnExpressionTreeWalker.d.ts

@@ -0,0 +1,57 @@
+import type { Tree } from "@vuu-ui/vuu-codemirror";
+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/src/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/src/column-expression-input/column-language-parser/generated/column-parser.d.ts

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

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

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

package/types/src/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/src/column-expression-input/column-language-parser/test.d.mts

@@ -0,0 +1 @@
+export declare const walkTree: (tree: any, source: any) => void;

package/types/src/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/src/column-expression-input/highlighting.d.ts

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

package/types/src/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/src/column-expression-input/theme.d.ts

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

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

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

package/types/src/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;
+};