@vuu-ui/vuu-table-extras 3.3.9 → 3.3.11

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.9",
+  "version": "3.3.11",
   "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.3.9",
-    "@vuu-ui/vuu-protocol-types": "3.3.9"
+    "@vuu-ui/vuu-filter-types": "3.3.11",
+    "@vuu-ui/vuu-protocol-types": "3.3.11"
   },
   "dependencies": {
-    "@vuu-ui/vuu-codemirror": "3.3.9",
-    "@vuu-ui/vuu-data-editing": "3.3.9",
-    "@vuu-ui/vuu-data-react": "3.3.9",
-    "@vuu-ui/vuu-data-types": "3.3.9",
-    "@vuu-ui/vuu-table-types": "3.3.9",
-    "@vuu-ui/vuu-popups": "3.3.9",
-    "@vuu-ui/vuu-table": "3.3.9",
-    "@vuu-ui/vuu-utils": "3.3.9",
-    "@vuu-ui/vuu-ui-controls": "3.3.9",
+    "@vuu-ui/vuu-codemirror": "3.3.11",
+    "@vuu-ui/vuu-data-editing": "3.3.11",
+    "@vuu-ui/vuu-data-react": "3.3.11",
+    "@vuu-ui/vuu-data-types": "3.3.11",
+    "@vuu-ui/vuu-table-types": "3.3.11",
+    "@vuu-ui/vuu-popups": "3.3.11",
+    "@vuu-ui/vuu-table": "3.3.11",
+    "@vuu-ui/vuu-utils": "3.3.11",
+    "@vuu-ui/vuu-ui-controls": "3.3.11",
     "@lezer/lr": "1.4.2",
     "@salt-ds/core": "1.54.1",
     "@salt-ds/lab": "1.0.0-alpha.83",

package/src/csv-upload/CsvUpload.js

@@ -1,5 +1,5 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { Button, Dialog, DialogActions, DialogContent, DialogHeader, FileDropZone, FileDropZoneIcon, FileDropZoneTrigger } from "@salt-ds/core";
+import { Button, Dialog, DialogActions, DialogContent, DialogHeader, FileDropZone, FileDropZoneIcon, FileDropZoneTrigger, Text } from "@salt-ds/core";
 import { useComponentCssInjection } from "@salt-ds/styles";
 import { useWindow } from "@salt-ds/window";
 import { useCallback, useState } from "react";
@@ -18,6 +18,10 @@ const CsvUpload_CsvUpload = (props)=>{
         window: targetWindow
     });
     const { canImport, cancelImport, isProcessingFile, isImporting, importData, onDrop, onTriggerChange, schema, validation, error } = useCsvUpload(props);
+    const fileErrors = validation?.errors.filter((e)=>e.column in validation.errorMap.fileErrors) ?? [];
+    const hasErrors = !!error || validation && validation.errors.length > 0;
+    const isUploaded = canImport || isImporting;
+    const status = hasErrors ? "error" : isUploaded ? "success" : void 0;
     const handleCancel = useCallback(async ()=>{
         await cancelImport();
         if (!isControlledOpen) setInternalOpen(false);
@@ -36,38 +40,55 @@ const CsvUpload_CsvUpload = (props)=>{
     const content = /*#__PURE__*/ jsxs("div", {
         className: classBase,
         children: [
-            /*#__PURE__*/ jsxs(FileDropZone, {
+            /*#__PURE__*/ jsx(FileDropZone, {
                 className: `${classBase}-dropZone`,
                 disabled: void 0 === schema || isProcessingFile || isImporting,
                 onDrop: onDrop,
-                status: validation && validation.errors.length > 0 || error ? "error" : void 0,
-                children: [
-                    /*#__PURE__*/ jsx(FileDropZoneIcon, {}),
-                    validation && validation.errors.length > 0 ? /*#__PURE__*/ jsxs(Fragment, {
-                        children: [
-                            /*#__PURE__*/ jsx("div", {
-                                children: "Your file contains errors"
-                            }),
-                            /*#__PURE__*/ jsx("ul", {
-                                className: `${classBase}-errorList`,
-                                children: validation.errors.filter((e)=>e.column in validation.errorMap.fileErrors).map((error, i)=>/*#__PURE__*/ jsx("li", {
-                                        className: `${classBase}-errorItem`,
-                                        children: error.message
-                                    }, `${error.column}-${error.message}-${i}`))
-                            }),
-                            /*#__PURE__*/ jsx("div", {
-                                children: "Please rectify and reupload"
-                            })
-                        ]
-                    }) : /*#__PURE__*/ jsx("div", {
-                        children: "Drop a file here or"
-                    }),
-                    /*#__PURE__*/ jsx(FileDropZoneTrigger, {
-                        accept: ".csv,text/csv",
-                        onChange: onTriggerChange,
-                        children: "BROWSE FILES"
-                    })
-                ]
+                status: status,
+                children: isUploaded ? /*#__PURE__*/ jsxs(Fragment, {
+                    children: [
+                        /*#__PURE__*/ jsx(FileDropZoneIcon, {
+                            status: "success"
+                        }),
+                        /*#__PURE__*/ jsx("strong", {
+                            children: "Upload completed"
+                        })
+                    ]
+                }) : /*#__PURE__*/ jsxs(Fragment, {
+                    children: [
+                        /*#__PURE__*/ jsx(FileDropZoneIcon, {
+                            status: hasErrors ? "error" : void 0
+                        }),
+                        validation && validation.errors.length > 0 ? /*#__PURE__*/ jsxs(Fragment, {
+                            children: [
+                                /*#__PURE__*/ jsx("div", {
+                                    children: "Your file contains errors"
+                                }),
+                                fileErrors.length > 0 && /*#__PURE__*/ jsx("ul", {
+                                    className: `${classBase}-errorList`,
+                                    children: fileErrors.map((error, i)=>/*#__PURE__*/ jsx("li", {
+                                            className: `${classBase}-errorItem`,
+                                            children: error.message
+                                        }, `${error.column}-${error.message}-${i}`))
+                                }),
+                                /*#__PURE__*/ jsx("div", {
+                                    children: "Please rectify and reupload"
+                                })
+                            ]
+                        }) : /*#__PURE__*/ jsx("div", {
+                            children: "Drop a file here or"
+                        }),
+                        /*#__PURE__*/ jsx(FileDropZoneTrigger, {
+                            accept: ".csv,text/csv",
+                            onChange: onTriggerChange,
+                            children: "BROWSE FILES"
+                        }),
+                        /*#__PURE__*/ jsx(Text, {
+                            children: "Only .csv files"
+                        }),
+                        children
+                    ]
+                })
             }),
             error && (renderError ? renderError(error) : /*#__PURE__*/ jsxs("div", {
                 className: `${classBase}-errors`,
@@ -81,8 +102,7 @@ const CsvUpload_CsvUpload = (props)=>{
                         children: error.errors.importError?.message || error.errors.schemaError?.message || error.errors.validationError?.message || "An unexpected error occurred during import."
                     })
                 ]
-            })),
-            children
+            }))
         ]
     });
     const actions = /*#__PURE__*/ jsxs(DialogActions, {

package/src/csv-upload/parse/csv-constants.js

@@ -1,4 +1,4 @@
-const CSV_HEADER_ROW_NUMBER = 1;
-const CSV_FIRST_DATA_ROW_NUMBER = 2;
+const CSV_HEADER_ROW_NUMBER = 0;
+const CSV_FIRST_DATA_ROW_NUMBER = 1;
 const MAX_ROWS_IN_CSV = 10000;
 export { CSV_FIRST_DATA_ROW_NUMBER, CSV_HEADER_ROW_NUMBER, MAX_ROWS_IN_CSV };

package/src/csv-upload/parse/csv-errors.js

@@ -15,6 +15,7 @@ var csv_errors_CsvValidationErrorEnum = /*#__PURE__*/ function(CsvValidationErro
     CsvValidationErrorEnum["MAX_ROWS_EXCEEDED"] = "MAX_ROWS_EXCEEDED";
     CsvValidationErrorEnum["EMPTY_NON_STRING_VALUE"] = "EMPTY_NON_STRING_VALUE";
     CsvValidationErrorEnum["TYPE_MISMATCH"] = "TYPE_MISMATCH";
+    CsvValidationErrorEnum["CUSTOM_VALIDATION"] = "CUSTOM_VALIDATION";
     return CsvValidationErrorEnum;
 }({});
 const createCsvErrorState = ()=>({

package/src/csv-upload/parse/csv-schema-validation.js

@@ -20,6 +20,10 @@ const validateCsvAgainstSchema = (parsed, tableSchema, options)=>{
     parsed.rows.forEach((rowValues, rowIndex)=>{
         const rowNum = rowIndex + CSV_FIRST_DATA_ROW_NUMBER;
         const typedRow = {};
+        const rawRow = parsed.header.reduce((acc, headerCol, idx)=>{
+            acc[headerCol] = rowValues[idx];
+            return acc;
+        }, {});
         parsed.header.forEach((columnName, columnIndex)=>{
             const rawValue = rowValues[columnIndex];
             const schemaType = schemaColumns.get(columnName);
@@ -33,6 +37,11 @@ const validateCsvAgainstSchema = (parsed, tableSchema, options)=>{
                 return;
             }
             if (void 0 === value) return void addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.TYPE_MISMATCH, `Value '${rawValue}' is not a valid ${toType}`, rawValue);
+            const customValidator = options?.validators?.[columnName];
+            if (customValidator) {
+                const validationResult = customValidator(rawValue, columnName, rawRow);
+                if (true !== validationResult) return void addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.CUSTOM_VALIDATION, "string" == typeof validationResult ? validationResult : `Value '${rawValue}' failed custom validation.`, rawValue);
+            }
             typedRow[columnName] = value;
         });
         typedRows.push(typedRow);

package/src/csv-upload/useCsvUpload.js

@@ -5,7 +5,7 @@ import { parseCsv } from "./parse/csv-parse.js";
 import { validateCsvAgainstSchema } from "./parse/csv-schema-validation.js";
 import { buildRowErrorMessage, createUploadError, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, toErrorMessage } from "./parse/csv-upload-utils.js";
 import { CSV_FIRST_DATA_ROW_NUMBER } from "./parse/csv-constants.js";
-const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importTable, onImportSessionEnded, onImportSessionStarted, onError, onImported, onPreview, onProcessingStarted, maxRows, parseOptions, rowDefaults })=>{
+const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importTable, onImportSessionEnded, onImportSessionStarted, onError, onImported, onPreview, onProcessingStarted, maxRows, parseOptions, rowDefaults, validators })=>{
     const { getServerAPI } = useData();
     const [validation, setValidation] = useState();
     const [sessionTable, setSessionTable] = useState();
@@ -140,7 +140,7 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
             if (rowNum < CSV_FIRST_DATA_ROW_NUMBER) continue;
             const existing = vuuMsgByRow.get(rowNum);
             const columnError = `${column}: ${message}`;
-            vuuMsgByRow.set(rowNum, existing ? `${existing}; ${columnError}` : `Row ${rowNum}: ${columnError}`);
+            vuuMsgByRow.set(rowNum, existing ? `${existing}; ${columnError}` : `${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${columnError}`);
         }
         const parsedRowCount = mergedValidation.rows.length;
         const unparsedErrorRows = [
@@ -174,7 +174,7 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
                 if (isRpcError(result)) throw Error(result.errorMessage);
                 if ("string" == typeof result) throw Error(result);
             } catch (error) {
-                rpcErrors.push(`Row ${rowNum}: ${toErrorMessage(error)}`);
+                rpcErrors.push(`${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${toErrorMessage(error)}`);
             }
         }
         if (rpcErrors.length > 0) throw Error(buildRowErrorMessage("Import failed", rpcErrors));
@@ -240,7 +240,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
             return;
         }
         const schemaValidation = validateCsvAgainstSchema(parsedCsv, schema, {
-            maxRows
+            maxRows,
+            validators
         });
         if (Object.keys(schemaValidation.errorMap.fileErrors).length > 0) {
             setValidation(schemaValidation);
@@ -288,7 +289,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         dataSource.table,
         table,
         endEditSessionAndNotify,
-        schema
+        schema,
+        validators
     ]);
     const handleFiles = useCallback(async (files)=>{
         const file = files[0];

package/types/csv-upload/CsvUpload.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from "react";
 import type { RowDefaultDataItemValues, EditSession } from "@vuu-ui/vuu-data-editing";
 import type { CsvParseError, CsvParseOptions } from "./parse/csv-parse";
-import type { CsvValidationStructuredError } from "./parse/csv-schema-validation";
+import type { CsvValidationStructuredError, CsvColumnValidator } from "./parse/csv-schema-validation";
 import type { DataSource, TableSchema } from "@vuu-ui/vuu-data-types";
 import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
 import type { CsvUploadTableData } from "./parse/csv-upload-utils";
@@ -60,6 +60,7 @@ export interface CsvUploadProps {
     parseOptions?: CsvParseOptions;
     importMode?: "direct" | "preview";
     rowDefaults?: RowDefaultDataItemValues;
+    validators?: Record<string, CsvColumnValidator>;
     /**
      * Custom renderer for the error panel.
      */

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

@@ -1,7 +1,7 @@
 export { CsvUpload, type CsvUploadError, type CsvUploadProps, type CsvUploadErrorResult, type CsvUploadErrors, type CsvUploadPhase, type CsvUploadImportedResult, type CsvUploadPreviewResult, type CsvUploadSessionEndReason, type CsvUploadSessionEndResult, type CsvUploadSessionTable, } from "./CsvUpload";
 export { useCsvUpload, type CsvUploadHookProps, type UseCsvUploadReturn, } from "./useCsvUpload";
 export { DataUploadPreview, type DataUploadPreviewProps, } from "./data-upload-preview/DataUploadPreview";
-export { validateCsvAgainstSchema, type CsvValidationOptions, type CsvValidationResult, } from "./parse/csv-schema-validation";
+export { validateCsvAgainstSchema, type CsvColumnValidator, type CsvValidationOptions, type CsvValidationResult, } from "./parse/csv-schema-validation";
 export { parseCsv, type CsvParseOptions, type CsvParseResult, } from "./parse/csv-parse";
 export { CsvValidationErrorEnum, CsvParseErrorEnum, type CsvError, type CsvErrorMap, type CsvStructuredError, type CsvValidationError, type CsvValidationErrorMap, type CsvValidationErrorType, type CsvValidationStructuredError, type CsvParseError, type CsvParseErrorMap, } from "./parse/csv-errors";
 export { CSV_FIRST_DATA_ROW_NUMBER, CSV_HEADER_ROW_NUMBER, } from "./parse/csv-constants";

package/types/csv-upload/parse/csv-constants.d.ts

@@ -1,3 +1,3 @@
-export declare const CSV_HEADER_ROW_NUMBER = 1;
-export declare const CSV_FIRST_DATA_ROW_NUMBER = 2;
+export declare const CSV_HEADER_ROW_NUMBER = 0;
+export declare const CSV_FIRST_DATA_ROW_NUMBER = 1;
 export declare const MAX_ROWS_IN_CSV = 10000;

package/types/csv-upload/parse/csv-errors.d.ts

@@ -12,7 +12,8 @@ export declare enum CsvValidationErrorEnum {
     UNKNOWN_COLUMN = "UNKNOWN_COLUMN",
     MAX_ROWS_EXCEEDED = "MAX_ROWS_EXCEEDED",
     EMPTY_NON_STRING_VALUE = "EMPTY_NON_STRING_VALUE",
-    TYPE_MISMATCH = "TYPE_MISMATCH"
+    TYPE_MISMATCH = "TYPE_MISMATCH",
+    CUSTOM_VALIDATION = "CUSTOM_VALIDATION"
 }
 export type CsvErrorMap<TError extends string> = {
     rowErrors: Record<number, Record<string, TError[]>>;

package/types/csv-upload/parse/csv-schema-validation.d.ts

@@ -3,6 +3,7 @@ import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
 import type { CsvValidationError, CsvValidationErrorMap, CsvParseError } from "./csv-errors";
 import type { CsvParseResult } from "./csv-parse";
 export { CsvValidationErrorEnum, type CsvValidationError, type CsvValidationErrorMap, type CsvValidationErrorType, type CsvValidationStructuredError, } from "./csv-errors";
+export type CsvColumnValidator = (value: string, columnName: string, row: Record<string, string>) => boolean | string;
 export type CsvValidationResult = {
     columns: string[];
     errorMap: CsvValidationErrorMap;
@@ -12,5 +13,6 @@ export type CsvValidationResult = {
 };
 export type CsvValidationOptions = {
     maxRows?: number;
+    validators?: Record<string, CsvColumnValidator>;
 };
 export declare const validateCsvAgainstSchema: (parsed: CsvParseResult, tableSchema: TableSchema, options?: CsvValidationOptions) => CsvValidationResult;

package/types/csv-upload/parse/index.d.ts

@@ -1,5 +1,5 @@
 export { CSV_FIRST_DATA_ROW_NUMBER, CSV_HEADER_ROW_NUMBER, } from "./csv-constants";
 export { CsvParseErrorEnum, CsvValidationErrorEnum, type CsvError, type CsvErrorMap, type CsvErrorState, type CsvParseError, type CsvParseErrorMap, type CsvStructuredError, type CsvValidationError, type CsvValidationErrorMap, type CsvValidationErrorType, type CsvValidationStructuredError, addCsvFileError, addCsvRowError, createCsvErrorState, hasCsvErrors, } from "./csv-errors";
 export { parseCsv, type CsvParseOptions, type CsvParseResult, } from "./csv-parse";
-export { validateCsvAgainstSchema, type CsvValidationOptions, type CsvValidationResult, } from "./csv-schema-validation";
+export { validateCsvAgainstSchema, type CsvColumnValidator, type CsvValidationOptions, type CsvValidationResult, } from "./csv-schema-validation";
 export { buildRowErrorMessage, executeBatchRpcCalls, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, normalizeTableData, toErrorMessage, toValidationErrorsFromParseRowErrors, type CsvUploadTableData, type RpcBatchResult, } from "./csv-upload-utils";

package/types/csv-upload/useCsvUpload.d.ts

@@ -2,7 +2,7 @@ import type { DataSource, TableSchema } from "@vuu-ui/vuu-data-types";
 import { type RowDefaultDataItemValues } from "@vuu-ui/vuu-data-editing";
 import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
 import { type CsvParseOptions } from "./parse/csv-parse";
-import { type CsvValidationResult } from "./parse/csv-schema-validation";
+import { type CsvValidationResult, type CsvColumnValidator } from "./parse/csv-schema-validation";
 import type { CsvUploadErrorResult, CsvUploadImportedResult, CsvUploadPreviewResult, CsvUploadSessionEndResult, CsvUploadSessionTable } from "./CsvUpload";
 export interface CsvUploadHookProps {
     dataSource: DataSource;
@@ -25,6 +25,7 @@ export interface CsvUploadHookProps {
     parseOptions?: CsvParseOptions;
     /** Default column values applied to every addRow call. Pass a stable reference — a new object triggers EditSession recreation. */
     rowDefaults?: RowDefaultDataItemValues;
+    validators?: Record<string, CsvColumnValidator>;
 }
 export type UseCsvUploadReturn = {
     canImport: boolean;
@@ -39,4 +40,4 @@ export type UseCsvUploadReturn = {
     validation: CsvValidationResult | undefined;
     error: CsvUploadErrorResult | undefined;
 };
-export declare const useCsvUpload: ({ dataSource, importMode, importSchema, importTable, onImportSessionEnded, onImportSessionStarted, onError, onImported, onPreview, onProcessingStarted, maxRows, parseOptions, rowDefaults, }: CsvUploadHookProps) => UseCsvUploadReturn;
+export declare const useCsvUpload: ({ dataSource, importMode, importSchema, importTable, onImportSessionEnded, onImportSessionStarted, onError, onImported, onPreview, onProcessingStarted, maxRows, parseOptions, rowDefaults, validators, }: CsvUploadHookProps) => UseCsvUploadReturn;

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;