@vuu-ui/vuu-table-extras 4.0.0-alpha.20 → 4.0.0-alpha.22

package/src/csv-upload/useCsvUpload.js

@@ -1,203 +1,36 @@
-import { EditSession } from "@vuu-ui/vuu-data-editing";
-import { Range, isRpcError, isSessionTable, useData } from "@vuu-ui/vuu-utils";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Range, isSessionTable } from "@vuu-ui/vuu-utils";
+import { useCallback, useMemo, useRef, useState } from "react";
 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";
+import { CsvValidationErrorEnum, validateCsvAgainstSchema } from "./parse/csv-schema-validation.js";
+import { createUploadError, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, toErrorMessage } from "./parse/csv-upload-utils.js";
+import { useImportSchema } from "./session/useImportSchema.js";
+import { useImportSession } from "./session/useImportSession.js";
 const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importTable, onImportSessionEnded, onImportSessionReady, onError, onImported, onPreview, onProcessingStarted, maxRows, parseOptions, rowDefaults, validators })=>{
-    const { getServerAPI } = useData();
     const [validation, setValidation] = useState();
-    const [sessionTable, setSessionTable] = useState();
     const [isProcessingFile, setIsProcessingFile] = useState(false);
     const [isImporting, setIsImporting] = useState(false);
-    const [fetchedImportSchema, setFetchedImportSchema] = useState();
     const [error, setError] = useState();
+    const operationIdRef = useRef(0);
+    const processingPromiseRef = useRef(void 0);
     const handleError = useCallback((errResult)=>{
         setError(errResult);
         onError?.(errResult);
     }, [
         onError
     ]);
-    useEffect(()=>{
-        if (importSchema || void 0 === importTable) return void setFetchedImportSchema(void 0);
-        let cancelled = false;
-        (async ()=>{
-            try {
-                const server = await getServerAPI();
-                const tableSchema = await server.getTableSchema(importTable);
-                if (!cancelled) setFetchedImportSchema(tableSchema);
-            } catch (error) {
-                console.error("[useCsvUpload] failed to fetch import table schema", error);
-            }
-        })();
-        return ()=>{
-            cancelled = true;
-        };
-    }, [
-        getServerAPI,
+    const { schema, sessionOverrides } = useImportSchema({
+        dataSource,
         importSchema,
         importTable
-    ]);
-    const resolvedImportSchema = importSchema ?? fetchedImportSchema;
-    const sessionOverrides = useMemo(()=>{
-        const columns = resolvedImportSchema?.columns.map(({ name })=>name);
-        return columns || importTable ? {
-            columns,
-            table: importTable
-        } : void 0;
-    }, [
-        resolvedImportSchema,
-        importTable
-    ]);
-    const importDataSource = useMemo(()=>({
-            tableSchema: dataSource.tableSchema,
-            createSessionDataSource: async (copyOption, sessionType)=>{
-                if (!dataSource.createSessionDataSource) throw Error("[useCsvUpload] dataSource does not support createSessionDataSource");
-                const sessionDs = await dataSource.createSessionDataSource(copyOption, sessionType, sessionOverrides);
-                if (!sessionDs) throw Error("[useCsvUpload] Failed to create session datasource");
-                if (!sessionDs.columns.includes("vuuMsg")) sessionDs.columns = sessionDs.columns.concat("vuuMsg");
-                if (sessionDs.isRemote) return new Promise((resolve, reject)=>{
-                    const handleSubscribed = ()=>{
-                        sessionDs.removeListener("subscribed", handleSubscribed);
-                        resolve(sessionDs);
-                    };
-                    sessionDs.on("subscribed", handleSubscribed);
-                    try {
-                        sessionDs.subscribe({
-                            range: Range(0, 0)
-                        }, ()=>{});
-                    } catch (err) {
-                        sessionDs.removeListener("subscribed", handleSubscribed);
-                        reject(err);
-                    }
-                });
-                return sessionDs;
-            }
-        }), [
+    });
+    const { addAllRows, beginEditSession, checkSessionTableErrors, closePendingEditSession, editSession, endEditSessionAndNotify, releaseEditSessionOwnership, sessionDataSourceRef, sessionTable, setActiveSessionDataSource } = useImportSession({
         dataSource,
-        sessionOverrides
-    ]);
-    const editSession = useMemo(()=>new EditSession({
-            dataSource: importDataSource,
-            editSessionApi: "createSessionDataSource",
-            rowDefaults
-        }), [
-        importDataSource,
-        rowDefaults
-    ]);
-    const ownsEditSessionRef = useRef(true);
-    const operationIdRef = useRef(0);
-    const processingPromiseRef = useRef(void 0);
-    const sessionDataSourceRef = useRef(void 0);
-    useEffect(()=>()=>{
-            operationIdRef.current++;
-            const processingPromise = processingPromiseRef.current;
-            (async ()=>{
-                try {
-                    await processingPromise;
-                } finally{
-                    if (ownsEditSessionRef.current) try {
-                        await editSession.end(false);
-                    } catch (error) {
-                        console.error("[useCsvUpload] failed to discard edit session during cleanup", error);
-                    }
-                }
-            })();
-        }, [
-        editSession
-    ]);
-    const setActiveSessionDataSource = useCallback((sessionDataSource)=>{
-        sessionDataSourceRef.current = sessionDataSource;
-        const table = sessionDataSource?.table;
-        setSessionTable(table && isSessionTable(table) ? table : void 0);
-    }, []);
-    const endEditSessionAndNotify = useCallback(async (save, reason)=>{
-        const sessionDataSource = sessionDataSourceRef.current;
-        if (!sessionDataSource) throw Error("CsvUpload has no active edit session.");
-        if (!sessionDataSource.endEditSession) throw Error("CsvUpload requires the session datasource to support endEditSession.");
-        const currentSessionTable = sessionDataSource.table;
-        try {
-            await editSession.end(save);
-        } finally{
-            if ("unsubscribed" !== sessionDataSource.status && "function" == typeof sessionDataSource.unsubscribe) sessionDataSource.unsubscribe();
-            setActiveSessionDataSource(void 0);
-        }
-        onImportSessionEnded?.({
-            reason,
-            sessionTable: currentSessionTable && isSessionTable(currentSessionTable) ? currentSessionTable : void 0
-        });
-    }, [
-        editSession,
-        onImportSessionEnded,
-        setActiveSessionDataSource
-    ]);
+        sessionOverrides,
+        rowDefaults,
+        processingPromiseRef,
+        onImportSessionEnded
+    });
     const table = dataSource.table;
-    const schema = importTable ? resolvedImportSchema : resolvedImportSchema ?? dataSource.tableSchema;
-    const addAllRows = useCallback(async (mergedValidation, operationId)=>{
-        const vuuMsgByRow = new Map();
-        for (const { rowNum, column, message } of mergedValidation.errors){
-            if (rowNum < CSV_FIRST_DATA_ROW_NUMBER) continue;
-            const existing = vuuMsgByRow.get(rowNum);
-            const columnError = `${column}: ${message}`;
-            vuuMsgByRow.set(rowNum, existing ? `${existing}; ${columnError}` : columnError);
-        }
-        const parsedRowCount = mergedValidation.rows.length;
-        const unparsedErrorRows = [
-            ...vuuMsgByRow.keys()
-        ].filter((rowNum)=>rowNum - CSV_FIRST_DATA_ROW_NUMBER >= parsedRowCount).map((rowNum)=>({
-                rowNum,
-                rowData: {},
-                vuuMsg: vuuMsgByRow.get(rowNum) ?? ""
-            }));
-        const allRows = [
-            ...mergedValidation.rows.map((rowData, idx)=>({
-                    rowNum: idx + CSV_FIRST_DATA_ROW_NUMBER,
-                    rowData: rowData ?? {},
-                    vuuMsg: vuuMsgByRow.get(idx + CSV_FIRST_DATA_ROW_NUMBER) ?? ""
-                })),
-            ...unparsedErrorRows
-        ];
-        const rpcErrors = [];
-        for (const { rowNum, rowData, vuuMsg } of allRows){
-            if (operationId !== operationIdRef.current) return false;
-            try {
-                const payload = vuuMsg ? {
-                    vuuRowNum: rowNum,
-                    vuuMsg
-                } : {
-                    ...rowData,
-                    vuuRowNum: rowNum,
-                    vuuMsg
-                };
-                const result = await editSession.addRow(payload);
-                if (isRpcError(result)) throw Error(result.errorMessage);
-                if ("string" == typeof result) throw Error(result);
-            } catch (error) {
-                rpcErrors.push(`${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${toErrorMessage(error)}`);
-            }
-        }
-        if (rpcErrors.length > 0) throw Error(buildRowErrorMessage("Import failed", rpcErrors));
-        return true;
-    }, [
-        editSession
-    ]);
-    const beginEditSession = useCallback(async ()=>{
-        const sessionDataSource = await editSession.begin("Empty", "import");
-        const sessionVuuTable = sessionDataSource?.table;
-        if (void 0 === sessionDataSource || void 0 === sessionVuuTable || !isSessionTable(sessionVuuTable)) throw Error("CsvUpload createSessionDataSource returned no session datasource.");
-        setActiveSessionDataSource(sessionDataSource);
-        return sessionDataSource;
-    }, [
-        editSession,
-        setActiveSessionDataSource
-    ]);
-    const closePendingEditSession = useCallback(async (save)=>{
-        if (void 0 === sessionDataSourceRef.current) return;
-        await endEditSessionAndNotify(save, save ? "saved" : "discarded");
-    }, [
-        endEditSessionAndNotify
-    ]);
     const cancelImport = useCallback(async ()=>{
         operationIdRef.current++;
         processingPromiseRef.current = void 0;
@@ -256,8 +89,28 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         if (mergedValidation.rows.length > 0) try {
             const sessionDataSource = await beginEditSession();
             if (operationId !== operationIdRef.current) return;
-            const rowsAdded = await addAllRows(mergedValidation, operationId);
-            if (!rowsAdded) return;
+            const rowsAddedCount = await addAllRows(mergedValidation, ()=>operationId !== operationIdRef.current);
+            if (false === rowsAddedCount) return;
+            const expectedRowCount = rowsAddedCount;
+            sessionDataSource.range = Range(0, expectedRowCount);
+            const sessionErrors = await checkSessionTableErrors(sessionDataSource, expectedRowCount);
+            if (operationId !== operationIdRef.current) return;
+            if (sessionErrors.length > 0) {
+                const serverValidationErrors = sessionErrors.map(({ rowNum, message })=>({
+                        rowNum,
+                        column: "*",
+                        message,
+                        value: "",
+                        errorEnum: CsvValidationErrorEnum.CUSTOM_VALIDATION
+                    }));
+                setValidation((prev)=>prev ? {
+                        ...prev,
+                        errors: [
+                            ...prev.errors,
+                            ...serverValidationErrors
+                        ]
+                    } : void 0);
+            }
             onImportSessionReady?.(sessionDataSource);
         } catch (error) {
             if (void 0 !== sessionDataSourceRef.current) await endEditSessionAndNotify(false, "failed");
@@ -277,6 +130,7 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         handleError,
         editSession,
         addAllRows,
+        checkSessionTableErrors,
         maxRows,
         parseOptions,
         beginEditSession,
@@ -287,7 +141,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         endEditSessionAndNotify,
         schema,
         validators,
-        onImportSessionReady
+        onImportSessionReady,
+        sessionDataSourceRef
     ]);
     const handleFiles = useCallback(async (files)=>{
         const file = files[0];
@@ -355,7 +210,7 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
                     editSession,
                     tableData
                 });
-                ownsEditSessionRef.current = false;
+                releaseEditSessionOwnership();
             } else {
                 await endEditSessionAndNotify(true, "saved");
                 onImported?.({
@@ -383,6 +238,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         onImported,
         onPreview,
         importMode,
+        releaseEditSessionOwnership,
+        sessionDataSourceRef,
         validation
     ]);
     return {

package/src/freeze-control/FreezeControl.css.js

@@ -1,8 +1,8 @@
 const css = `
 .vuuFreezeControl {
   --freeze-control-flash-duration: .25s;
-  --freeze-control-active-button-color: var(--salt-palette-error-background);
-  --freeze-control-badge-color: var(--salt-palette-success-background);
+  --freeze-control-active-button-color: var(--salt-status-error-background);
+  --freeze-control-badge-color: var(--salt-status-success-background);
   height: fit-content;
   display: inline-flex;
 
@@ -31,7 +31,7 @@ const css = `
 
   & .vuuFreezeControl-buttonWrapper-active .saltToggleButton {
     background-color: var(--freeze-control-active-button-color);
-    color: var(--salt-actionable-secondary-foreground-active);
+    color: var(--salt-actionable-subtle-foreground-active);
   }
 
   & .saltToggleButtonGroup.vuuStateButtonGroup {
@@ -43,7 +43,7 @@ const css = `
   }
 
   & .vuuFreezeControl-customBadge {
-    color: var(--salt-text-primary-foreground);
+    color: var(--salt-content-primary-foreground);
     font-size: var(--salt-text-fontSize);
     height: var(--salt-size-base);
     width: var(--salt-size-base);

package/src/freeze-control/FrozenBanner.css.js

@@ -1,8 +1,8 @@
 const css = `
 .FrozenBanner {
-  --freeze-control-active-button-color: var(--salt-palette-error-background);
+  --freeze-control-active-button-color: var(--salt-status-error-background);
   background-color: var(--freeze-control-active-button-color);
-  color: var(--salt-actionable-secondary-foreground-active);
+  color: var(--salt-actionable-subtle-foreground-active);
   font-size: var(--salt-text-fontSize);
   height: var(--salt-size-base);
   padding: 0 var(--salt-spacing-200);

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

@@ -9,4 +9,4 @@ export interface CalculatedColumnPanelProps extends HTMLAttributes<HTMLDivElemen
     onChangeServerDataType?: (name: VuuColumnDataType) => void;
     vuuTable: VuuTable;
 }
-export declare const CalculatedColumnPanel: ({ column: columnProp, columnModel, onChangeColumn, onChangeServerDataType: onChangeServerDataTypeProp, vuuTable, }: CalculatedColumnPanelProps) => import("react").JSX.Element;
+export declare const CalculatedColumnPanel: ({ column: columnProp, columnModel, onChangeColumn, onChangeServerDataType: onChangeServerDataTypeProp, vuuTable, }: CalculatedColumnPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +1,2 @@
 import { TableCellRendererProps } from "@vuu-ui/vuu-table-types";
-export declare const BackgroundCell: import("react").MemoExoticComponent<({ column, dataRow, }: TableCellRendererProps) => import("react").JSX.Element>;
+export declare const BackgroundCell: import("react").MemoExoticComponent<({ column, dataRow, }: TableCellRendererProps) => import("react/jsx-runtime").JSX.Element>;

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

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

package/types/cell-renderers/button-cell/IconButtonCell.d.ts

@@ -3,4 +3,4 @@ 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;
+export declare const IconButtonCell: ({ column, dataRow }: TableCellRendererProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +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>;
+export declare const DropdownCell: import("react").MemoExoticComponent<({ column, dataRow, editedDuringCurrentSession, onEdit, }: TableCellRendererProps) => import("react/jsx-runtime").JSX.Element>;

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

@@ -1,2 +1,2 @@
 import { TableCellRendererProps } from "@vuu-ui/vuu-table-types";
-export declare const LookupCell: import("react").MemoExoticComponent<({ column, dataRow, }: TableCellRendererProps) => import("react").JSX.Element>;
+export declare const LookupCell: import("react").MemoExoticComponent<({ column, dataRow, }: TableCellRendererProps) => import("react/jsx-runtime").JSX.Element>;

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

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

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

@@ -7,4 +7,4 @@ export interface ColumnExpressionInputProps extends ExpressionSuggestionConsumer
     onSubmitExpression?: ColumnExpressionSubmitHandler;
     source?: string;
 }
-export declare const ColumnExpressionInput: import("react").MemoExoticComponent<({ onChange, onSubmitExpression, source, suggestionProvider, }: ColumnExpressionInputProps) => import("react").JSX.Element>;
+export declare const ColumnExpressionInput: import("react").MemoExoticComponent<({ onChange, onSubmitExpression, source, suggestionProvider, }: ColumnExpressionInputProps) => import("react/jsx-runtime").JSX.Element>;

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

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

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

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

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

@@ -6,4 +6,4 @@ export interface ColumnFormattingPanelProps extends HTMLAttributes<HTMLDivElemen
     column: ColumnDescriptor;
     onChangeRendering: (renderProps: ColumnTypeRendering) => void;
 }
-export declare const ColumnFormattingPanel: ({ availableRenderers, className, column, onChangeFormatting, onChangeColumnType, onChangeRendering, ...htmlAttributes }: ColumnFormattingPanelProps) => import("react").JSX.Element;
+export declare const ColumnFormattingPanel: ({ availableRenderers, className, column, onChangeFormatting, onChangeColumnType, onChangeRendering, ...htmlAttributes }: ColumnFormattingPanelProps) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -7,4 +7,4 @@ export interface ColumnMenuProps extends HTMLAttributes<HTMLSpanElement> {
     menuActionHandler?: MenuActionHandler<ColumnMenuActionType, ColumnDescriptor>;
     menuPermissions?: ColumnMenuPermissions;
 }
-export declare const ColumnMenu: ({ className, column, menuActionHandler: menuActionHandlerProp, menuPermissions: { allowSort, allowGroup, allowAggregation, allowHide, allowRemove, allowPin, }, }: ColumnMenuProps) => import("react").JSX.Element;
+export declare const ColumnMenu: ({ className, column, menuActionHandler: menuActionHandlerProp, menuPermissions: { allowSort, allowGroup, allowAggregation, allowHide, allowRemove, allowPin, }, }: ColumnMenuProps) => import("react/jsx-runtime").JSX.Element;

package/types/column-picker/ColumnPickerAction.d.ts

@@ -2,4 +2,4 @@ import { IconButtonProps } from "@vuu-ui/vuu-ui-controls";
 import { ColumnPickerHookProps } from "./useColumnPicker";
 export interface ColumnPickerActionProps extends Partial<IconButtonProps>, ColumnPickerHookProps {
 }
-export declare const ColumnPickerAction: ({ appearance, columnModel, icon, sentiment, ...IconButtonProps }: ColumnPickerActionProps) => import("react").JSX.Element;
+export declare const ColumnPickerAction: ({ appearance, columnModel, icon, sentiment, ...IconButtonProps }: ColumnPickerActionProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -4,4 +4,4 @@ export interface ColumnNameLabelProps {
     column: ColumnDescriptor;
     onClick?: MouseEventHandler;
 }
-export declare const ColumnNameLabel: ({ column, onClick }: ColumnNameLabelProps) => import("react").JSX.Element;
+export declare const ColumnNameLabel: ({ column, onClick }: ColumnNameLabelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -2,4 +2,4 @@ import { ColumnSettingsProps } from "./useColumnSettings";
 export interface ColumnSettinsPanelProps extends ColumnSettingsProps {
     onClickEditCalculatedColumn?: () => void;
 }
-export declare const ColumnSettingsPanel: ({ column: columnProp, columnModel, onClickEditCalculatedColumn, onConfigChange, }: ColumnSettinsPanelProps) => import("react").JSX.Element;
+export declare const ColumnSettingsPanel: ({ column: columnProp, columnModel, onClickEditCalculatedColumn, onConfigChange, }: ColumnSettinsPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -62,4 +62,4 @@ export interface CsvUploadProps {
     rowDefaults?: RowDefaultDataItemValues;
     validators?: Record<string, CsvColumnValidator>;
 }
-export declare const CsvUpload: (props: CsvUploadProps) => import("react").JSX.Element;
+export declare const CsvUpload: (props: CsvUploadProps) => import("react/jsx-runtime").JSX.Element;

package/types/csv-upload/data-upload-preview/DataUploadPreview.d.ts

@@ -7,4 +7,4 @@ export interface DataUploadPreviewProps extends Omit<HTMLAttributes<HTMLDivEleme
     saveLabel?: string;
     tableSchema: TableSchema;
 }
-export declare const DataUploadPreview: ({ className, editSession, onClose, saveLabel, tableSchema, ...htmlAttributes }: DataUploadPreviewProps) => import("react").JSX.Element;
+export declare const DataUploadPreview: ({ className, editSession, onClose, saveLabel, tableSchema, ...htmlAttributes }: DataUploadPreviewProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,4 +1,5 @@
 import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { DataSourceRow } from "@vuu-ui/vuu-data-types";
 import type { CsvUploadError } from "../CsvUpload";
 import type { CsvParseError } from "./csv-parse";
 import type { CsvValidationError, CsvValidationResult } from "./csv-schema-validation";
@@ -19,3 +20,11 @@ export type RpcBatchResult = {
     results: unknown[];
 };
 export declare const executeBatchRpcCalls: <T>(items: T[], executor: (item: T) => Promise<unknown>, errorFormatter: (item: T, error: string) => string) => Promise<RpcBatchResult>;
+export type SessionRowError = {
+    rowNum: number;
+    message: string;
+};
+export type SessionRowUpdateListener = () => void;
+export declare const getInlineRowErrorMessage: (result: unknown) => string | undefined;
+export declare const getRowVuuMsgError: (row: DataSourceRow, vuuMsgDataIndex: number, vuuRowNumDataIndex: number) => SessionRowError | undefined;
+export declare const waitForSessionErrors: (isRemote: boolean, sessionErrors: Map<string | number, SessionRowError>, receivedRowKeys: Set<string | number>, expectedRowCount: number, listeners: Set<SessionRowUpdateListener>, timeoutMs?: number) => Promise<SessionRowError[]>;

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

@@ -0,0 +1,2 @@
+export * from "./useImportSchema";
+export * from "./useImportSession";

package/types/csv-upload/session/useImportSchema.d.ts

@@ -0,0 +1,13 @@
+import type { DataSource, SessionDataSourceOverrides, TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export interface UseImportSchemaProps {
+    dataSource: DataSource;
+    importSchema?: TableSchema;
+    importTable?: VuuTable;
+}
+export interface UseImportSchemaResult {
+    resolvedImportSchema: TableSchema | undefined;
+    schema: TableSchema | undefined;
+    sessionOverrides: SessionDataSourceOverrides | undefined;
+}
+export declare const useImportSchema: ({ dataSource, importSchema, importTable, }: UseImportSchemaProps) => UseImportSchemaResult;

package/types/csv-upload/session/useImportSession.d.ts

@@ -0,0 +1,26 @@
+import type { DataSource, SessionDataSourceOverrides } from "@vuu-ui/vuu-data-types";
+import { EditSession, type RowDefaultDataItemValues } from "@vuu-ui/vuu-data-editing";
+import { type RefObject } from "react";
+import type { CsvValidationResult } from "../parse/csv-schema-validation";
+import { type SessionRowError } from "../parse/csv-upload-utils";
+import type { CsvUploadSessionEndReason, CsvUploadSessionEndResult, CsvUploadSessionTable } from "../CsvUpload";
+export interface UseImportSessionProps {
+    dataSource: DataSource;
+    sessionOverrides?: SessionDataSourceOverrides;
+    rowDefaults?: RowDefaultDataItemValues;
+    processingPromiseRef?: RefObject<Promise<void> | undefined>;
+    onImportSessionEnded?: (result: CsvUploadSessionEndResult) => void;
+}
+export interface UseImportSessionReturn {
+    addAllRows: (mergedValidation: CsvValidationResult, isCancelled: () => boolean) => Promise<number | false>;
+    beginEditSession: () => Promise<DataSource>;
+    checkSessionTableErrors: (sessionDs: DataSource, expectedRowCount: number) => Promise<SessionRowError[]>;
+    closePendingEditSession: (save: boolean) => Promise<void>;
+    editSession: EditSession;
+    endEditSessionAndNotify: (save: boolean, reason: CsvUploadSessionEndReason) => Promise<void>;
+    releaseEditSessionOwnership: () => void;
+    sessionDataSourceRef: React.MutableRefObject<DataSource | undefined>;
+    sessionTable: CsvUploadSessionTable | undefined;
+    setActiveSessionDataSource: (sessionDataSource?: DataSource) => void;
+}
+export declare const useImportSession: ({ dataSource, sessionOverrides, rowDefaults, processingPromiseRef, onImportSessionEnded, }: UseImportSessionProps) => UseImportSessionReturn;

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

@@ -1,5 +1,5 @@
 import type { DataSource, TableSchema } from "@vuu-ui/vuu-data-types";
-import { type RowDefaultDataItemValues } from "@vuu-ui/vuu-data-editing";
+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, type CsvColumnValidator } from "./parse/csv-schema-validation";

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

@@ -14,4 +14,4 @@ export interface DataSourceStatsProps extends DatasourceStatsHookProps, Omit<HTM
     selectionActions?: ReactNode;
     tooltrayActions?: ReactNode;
 }
-export declare const DataSourceStats: ({ children, className, dataSource, showRowStats, tooltrayActions, ...htmlAttributes }: DataSourceStatsProps) => import("react").JSX.Element;
+export declare const DataSourceStats: ({ children, className, dataSource, showRowStats, tooltrayActions, ...htmlAttributes }: DataSourceStatsProps) => import("react/jsx-runtime").JSX.Element;

package/types/freeze-control/FreezeControl.d.ts

@@ -12,4 +12,4 @@ export interface FreezeControlProps extends HTMLAttributes<HTMLDivElement>, Free
      */
     flashDuration?: number;
 }
-export declare const FreezeControl: ({ dataSource, className, newItemsLabel, flashDuration, ...htmlAttributes }: FreezeControlProps) => import("react").JSX.Element;
+export declare const FreezeControl: ({ dataSource, className, newItemsLabel, flashDuration, ...htmlAttributes }: FreezeControlProps) => import("react/jsx-runtime").JSX.Element;

package/types/freeze-control/FrozenBanner.d.ts

@@ -3,4 +3,4 @@ import { DataSource } from "@vuu-ui/vuu-data-types";
 export interface FrozenBannerProps extends HTMLAttributes<HTMLDivElement> {
     dataSource: DataSource;
 }
-export declare const FrozenBanner: ({ dataSource, className, ...htmlAttributes }: FrozenBannerProps) => import("react").JSX.Element | null;
+export declare const FrozenBanner: ({ dataSource, className, ...htmlAttributes }: FrozenBannerProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,3 +1,3 @@
 import type { BaseRowProps } from "@vuu-ui/vuu-table-types";
 export type InlineAddRowProps = BaseRowProps;
-export declare const InlineAddRow: ({ ariaRowIndex, className, columns, style, }: InlineAddRowProps) => import("react").JSX.Element;
+export declare const InlineAddRow: ({ ariaRowIndex, className, columns, style, }: InlineAddRowProps) => import("react/jsx-runtime").JSX.Element;

package/types/tabbed-table-config-panel/TabbedTableConfigPanel.d.ts

@@ -13,5 +13,5 @@ export interface TabbedTableConfigPanelProps extends ColumnPickerProps, Pick<Tab
     selectedTab?: TabName;
     vuuTable?: VuuTable;
 }
-export declare const TabbedTableConfigPanel: ({ allowCreateCalculatedColumn, className, columnModel, config, onDisplayAttributeChange, selectedTab, vuuTable, ...htmlAttributes }: TabbedTableConfigPanelProps) => import("react").JSX.Element;
+export declare const TabbedTableConfigPanel: ({ allowCreateCalculatedColumn, className, columnModel, config, onDisplayAttributeChange, selectedTab, vuuTable, ...htmlAttributes }: TabbedTableConfigPanelProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/types/tabbed-table-config-panel/TabbedTableSettingsAction.d.ts

@@ -4,4 +4,4 @@ import { TableDisplayAttributeChangeHandler } from "../table-settings-panel/Tabl
 export interface TabbedTableSettingsActionProps extends Partial<IconButtonProps>, TabbedTableConfigPanelHookProps {
     onDisplayAttributeChange: TableDisplayAttributeChangeHandler;
 }
-export declare const TabbedTableSettingsAction: ({ allowCreateCalculatedColumn, appearance, columnModel, config, icon, onDisplayAttributeChange, sentiment, vuuTable, ...IconButtonProps }: TabbedTableSettingsActionProps) => import("react").JSX.Element;
+export declare const TabbedTableSettingsAction: ({ allowCreateCalculatedColumn, appearance, columnModel, config, icon, onDisplayAttributeChange, sentiment, vuuTable, ...IconButtonProps }: TabbedTableSettingsActionProps) => import("react/jsx-runtime").JSX.Element;

package/types/table-footer/TableFooter.d.ts

@@ -6,5 +6,5 @@ export interface TableFooterProps extends HTMLAttributes<HTMLDivElement> {
 export declare const TableFooterTray: ({ children, position, }: {
     children: ReactNode;
     position?: "center" | "end";
-}) => import("react").JSX.Element;
-export declare const TableFooter: ({ children, className, onInvokeAction, tooltrayActions, ...htmlAttributes }: TableFooterProps) => import("react").JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TableFooter: ({ children, className, onInvokeAction, tooltrayActions, ...htmlAttributes }: TableFooterProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -10,7 +10,7 @@ export interface TableContextProps extends Pick<TableProps, "dataSource" | "rowA
 export declare const TableContext: import("react").Context<TableContextProps>;
 export declare const TableProvider: ({ children, dataSource, menuActionHandler, rowActionHandlers, }: TableContextProps & {
     children: ReactNode;
-}) => import("react").JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare function useTableContext(throwIfNoDataSource?: boolean): {
     dataSource: DataSource;
     menuActionHandler: MenuActionHandler<ColumnMenuActionType, ColumnDescriptor>;

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

@@ -19,4 +19,4 @@ export interface TableSettingsPanelProps {
   It updates the settings in state locally and notifies caller of
   every change via onChange callback
  */
-export declare const TableSettingsPanel: ({ onDisplayAttributeChange, tableDisplayAttributes: tableDisplayAttributesProp, permissions: permissionsProp, }: TableSettingsPanelProps) => import("react").JSX.Element;
+export declare const TableSettingsPanel: ({ onDisplayAttributeChange, tableDisplayAttributes: tableDisplayAttributesProp, permissions: permissionsProp, }: TableSettingsPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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;
-};