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

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;
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor, ColumnDisplayAction } from "@vuu-ui/vuu-table-types";
+export type ColumnDisplayActionHandler = (action: ColumnDisplayAction) => void;
+export type DisplayColumnSettingsAction = {
+    type: "column-settings";
+    column: ColumnDescriptor;
+    /**  only for calculated columnn */
+    vuuTable?: VuuTable;
+};
+export type DisplaySettingsAction = DisplayColumnSettingsAction;
+export type TableSettingsActionHandler = (action: DisplaySettingsAction) => void;

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

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

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

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

package/types/src/column-picker/ColumnModel.d.ts

@@ -0,0 +1,81 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { EventEmitter, ValueOf } from "@vuu-ui/vuu-utils";
+export declare const ColumnChangeSource: {
+    readonly ColumnPicker: "column-picker";
+    readonly ColumnSettings: "column-settings";
+    readonly Table: "table";
+};
+export type ColumnChangeSource = ValueOf<typeof ColumnChangeSource>;
+export declare const SelectedColumnChangeType: {
+    readonly CalculatedColumnAdded: "calculated-column-added";
+    readonly ColumnAdded: "column-added";
+    readonly ColumnRemoved: "column-removed";
+    readonly ColumnUpdated: "column-updated";
+    readonly ColumnsReordered: "columns-reordered";
+};
+export type SelectedColumnChangeType = ValueOf<typeof SelectedColumnChangeType>;
+export interface SelectedColumnChangeColumnAdded {
+    type: Extract<SelectedColumnChangeType, "column-added">;
+    column: ColumnDescriptor;
+}
+export interface SelectedColumnChangeCalculatedColumnAdded {
+    type: Extract<SelectedColumnChangeType, "calculated-column-added">;
+    column: ColumnDescriptor;
+}
+export interface SelectedColumnChangeColumnUpdated {
+    type: Extract<SelectedColumnChangeType, "column-updated">;
+    column: ColumnDescriptor;
+}
+export interface SelectedColumnChangeColumnRemoved {
+    type: Extract<SelectedColumnChangeType, "column-removed">;
+    column: ColumnDescriptor;
+}
+export interface SelectedColumnChangeColumnsReordered {
+    type: Extract<SelectedColumnChangeType, "columns-reordered">;
+}
+export type SelectedColumnChangeDescriptor = SelectedColumnChangeCalculatedColumnAdded | SelectedColumnChangeColumnAdded | SelectedColumnChangeColumnRemoved | SelectedColumnChangeColumnUpdated | SelectedColumnChangeColumnsReordered;
+export declare const isColumnAdded: (change?: SelectedColumnChangeDescriptor) => change is SelectedColumnChangeColumnAdded;
+export declare const isColumnRemoved: (change?: SelectedColumnChangeDescriptor) => change is SelectedColumnChangeColumnRemoved;
+export declare const isColumnUpdated: (change?: SelectedColumnChangeDescriptor) => change is SelectedColumnChangeColumnUpdated;
+export declare const isColumnsReordered: (change?: SelectedColumnChangeDescriptor) => change is SelectedColumnChangeColumnsReordered;
+export type ColumnsChangeHandler = (columns: readonly ColumnDescriptor[], changeSource: ColumnChangeSource, changeDescriptor?: SelectedColumnChangeDescriptor) => void;
+export type ColumnEvents = {
+    change: ColumnsChangeHandler;
+    render: (o: object) => void;
+};
+export declare class ColumnModel extends EventEmitter<ColumnEvents> {
+    #private;
+    /**
+     * All available columns, including selected columns.
+     */
+    allColumns: readonly ColumnDescriptor[];
+    constructor(
+    /**
+     * All available columns, including selected columns.
+     */
+    allColumns: readonly ColumnDescriptor[], 
+    /**
+     * Columns already selected and rendered in Table.
+     */
+    selectedColumns: readonly ColumnDescriptor[]);
+    get availableColumns(): ColumnDescriptor[];
+    set searchPattern(pattern: string);
+    get searchPattern(): string;
+    get selectedColumns(): readonly ColumnDescriptor[];
+    setSelectedColumns(selectedColumns: readonly ColumnDescriptor[], source: ColumnChangeSource, changeDescriptor?: SelectedColumnChangeDescriptor): void;
+    getColumn(name: string): ColumnDescriptor;
+    addItemToSelectedColumns(name: string, source: ColumnChangeSource): void;
+    removeItemFromSelectedColumns(name: string, source: ColumnChangeSource): void;
+    reorderSelectedColumns(orderedColumnNames: string[], source: ColumnChangeSource): void;
+    updateColumn(currentColumn: ColumnDescriptor, newColumn: ColumnDescriptor): void;
+    updateColumn(column: ColumnDescriptor): void;
+    /**
+     * Used when adding a calculated column
+     *
+     * @param column
+     *
+     * @param addToSelectedColumns
+     */
+    addColumn(column: ColumnDescriptor, addToSelectedColumns?: boolean): void;
+    private notifyListeners;
+}

package/types/src/column-picker/ColumnPicker.d.ts

@@ -0,0 +1,10 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { HTMLAttributes, MouseEventHandler } from "react";
+import { ListBoxProps } from "@salt-ds/core";
+import { ColumnPickerHookProps } from "./useColumnPicker";
+export declare const classBaseListItem = "vuuColumnPickerListItem";
+export interface ColumnPickerProps extends ColumnPickerHookProps, Pick<ListBoxProps<ColumnDescriptor>, "selected" | "onSelectionChange">, HTMLAttributes<HTMLDivElement> {
+    allowCreateCalculatedColumn?: boolean;
+    onClickCreateCalculatedColumn?: MouseEventHandler<HTMLButtonElement>;
+}
+export declare const ColumnPicker: import("react").ForwardRefExoticComponent<ColumnPickerProps & import("react").RefAttributes<HTMLDivElement>>;

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

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

package/types/src/column-picker/useColumnPicker.d.ts

@@ -0,0 +1,16 @@
+import { ColumnDescriptor, TableSelectionModel } from "@vuu-ui/vuu-table-types";
+import { FormEventHandler, MouseEventHandler } from "react";
+import { ColumnModel, SelectedColumnChangeType } from "./ColumnModel";
+export type ColumnSelectionModel = Extract<TableSelectionModel, "none" | "single">;
+export type SelectedColumnsChangeHandler = (columns: ColumnDescriptor[], changeType: SelectedColumnChangeType) => void;
+export interface ColumnPickerHookProps {
+    columnModel: ColumnModel;
+}
+export declare const useColumnPicker: ({ columnModel: model, }: ColumnPickerHookProps) => {
+    availableColumns: ColumnDescriptor[];
+    onAddItemToSelectedList: MouseEventHandler<HTMLButtonElement>;
+    onRemoveItemFromSelectedList: MouseEventHandler<HTMLButtonElement>;
+    onChangeSearchInput: FormEventHandler;
+    searchText: string;
+    selectedColumns: readonly ColumnDescriptor[];
+};

package/types/src/column-picker/useTableColumnPicker.d.ts

@@ -0,0 +1,7 @@
+import { ColumnModel } from "./ColumnModel";
+export interface TableColumnPickerHookProps {
+    columnModel: ColumnModel;
+}
+export declare const useTableColumnPicker: ({ columnModel, }: TableColumnPickerHookProps) => {
+    showColumnPicker: (title?: string) => void;
+};

package/types/src/column-picker/useTableColumnPickerDeprecated.d.ts

@@ -0,0 +1,14 @@
+import type { DataSource } from "@vuu-ui/vuu-data-types";
+import { ColumnDescriptor, TableConfigChangeHandler } from "@vuu-ui/vuu-table-types";
+export type TableColumnChangeHandler = (columns: ColumnDescriptor[], change: unknown) => void;
+export interface ColumnPickerHookProps {
+    readonly availableColumns: ColumnDescriptor[];
+    dataSource: DataSource;
+    readonly selectedColumns: ColumnDescriptor[];
+    onTableColumnChange?: TableColumnChangeHandler;
+}
+export declare const useTableColumnPickerDeprecated: ({ availableColumns, dataSource, onTableColumnChange, selectedColumns: initialSelectedColumns, }: ColumnPickerHookProps) => {
+    onTableConfigChange: TableConfigChangeHandler;
+    showColumnPicker: (title?: string) => void;
+    selectedColumns: ColumnDescriptor[];
+};

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

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

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

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

package/types/src/column-settings-panel/useColumnSettings.d.ts

@@ -0,0 +1,30 @@
+import { ColumnDescriptor, TableConfig, ColumnTypeFormatting } from "@vuu-ui/vuu-table-types";
+import { CellRendererDescriptor, ColumnRenderPropsChangeHandler } from "@vuu-ui/vuu-utils";
+import { VuuColumnDataType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { FormEventHandler } from "react";
+import { DataValueTypeSimple } from "@vuu-ui/vuu-data-types";
+import { ColumnModel } from "../column-picker/ColumnModel";
+/**
+ * Describes the props for a Column Configuration Editor, for which
+ * an implementation is provided in vuu-table-extras
+ */
+export interface ColumnSettingsProps {
+    column: ColumnDescriptor;
+    columnModel: ColumnModel;
+    onConfigChange?: (config: TableConfig) => void;
+    vuuTable?: VuuTable;
+}
+export declare const useColumnSettings: ({ column: columnProp, columnModel, }: Omit<ColumnSettingsProps, "vuuTable">) => {
+    availableRenderers: CellRendererDescriptor[];
+    column: ColumnDescriptor;
+    navigateNextColumn: () => void;
+    navigatePrevColumn: () => void;
+    onChange: FormEventHandler;
+    onChangeCalculatedColumnName: (name: string) => void;
+    onChangeFormatting: (formatting: ColumnTypeFormatting) => void;
+    onChangeRendering: ColumnRenderPropsChangeHandler;
+    onChangeServerDataType: (serverDataType: VuuColumnDataType) => void;
+    onChangeToggleButton: FormEventHandler;
+    onChangeType: (type: DataValueTypeSimple) => void;
+    onInputCommit: () => void;
+};

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

@@ -0,0 +1,42 @@
+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. */
+    label?: string;
+    exportFormatter?: (value: unknown) => string;
+};
+export interface ExportToCsvOptions<TName extends string = string> {
+    filename?: string;
+    copyOption?: CopyOption;
+    excludeColumns?: string[];
+    maxRows?: number;
+    columnDescriptors?: ExportColumnDescriptor<TName>[];
+    overrides?: SessionDataSourceOverrides;
+    /** Timeout in milliseconds before the export times out. Default: 30_000ms (0 to disable). */
+    timeout?: number;
+    onError?: (error: Error) => void;
+    onSuccess?: () => void;
+}
+export interface ExportCsvTemplateOptions {
+    filename?: string;
+    excludeColumns?: string[];
+    columns?: string[];
+    overrides?: SessionDataSourceOverrides;
+    /** Timeout in milliseconds before template generation times out. Default: 10_000ms (0 to disable). */
+    timeout?: number;
+    onError?: (error: Error) => void;
+    onSuccess?: () => void;
+}
+/** 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>;
+/**
+ * Subscribes to `dataSource` (creating an export session data source if a view data source is passed),
+ * collects all rows in memory in index order, serialises them to CSV (excluding internal session columns),
+ * 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>;
+/**
+ * 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>;

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

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

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

@@ -0,0 +1,14 @@
+import type { DataSource } from "@vuu-ui/vuu-data-types";
+import { type ExportCsvTemplateOptions, type ExportToCsvOptions } from "./export-utils";
+export interface UseCsvExportProps {
+    dataSource?: DataSource;
+    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>;
+    exportTemplate: (options?: ExportCsvTemplateOptions, overrideDataSource?: DataSource) => Promise<void>;
+}
+export declare function useCsvExport(propsOrDataSource?: DataSource | UseCsvExportProps): UseCsvExportResult;

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

@@ -0,0 +1,69 @@
+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, 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";
+export type CsvUploadImportedResult = {
+    tableData: CsvUploadTableData;
+};
+export type CsvUploadPreviewResult = {
+    dataSource: DataSource;
+    editSession: EditSession;
+    tableData: CsvUploadTableData;
+};
+export type CsvUploadErrors = {
+    schemaError?: CsvUploadError;
+    validationError?: CsvUploadError;
+    importError?: CsvUploadError;
+};
+export type CsvUploadError = {
+    message: string;
+    parseError?: CsvParseError;
+    validationError?: CsvValidationStructuredError;
+    source: "schema" | "validation" | "import";
+};
+export type CsvUploadErrorResult = {
+    errors: CsvUploadErrors;
+};
+export type CsvUploadSessionTable = VuuTable;
+export type CsvUploadSessionEndReason = "saved" | "discarded" | "failed";
+export type CsvUploadSessionEndResult = {
+    reason: CsvUploadSessionEndReason;
+    sessionTable?: CsvUploadSessionTable;
+};
+export type CsvUploadPhase = "idle" | "processing" | "preview-ready" | "importing" | "imported" | "failed";
+export interface CsvUploadProps {
+    children?: ReactNode;
+    dataSource: DataSource;
+    embedded?: boolean;
+    /**
+     * Schema of the import table, where it differs from the target table. Used to validate
+     * the CSV and to determine the session datasource columns. If omitted and importTable is
+     * provided, the schema is fetched via getTableSchema. Pass a stable reference.
+     */
+    importSchema?: TableSchema;
+    /** Expected import table, used to validate the session table returned by the server. */
+    importTable?: VuuTable;
+    onImportSessionStarted?: (dataSource: DataSource) => void;
+    onImportSessionEnded?: (result: CsvUploadSessionEndResult) => void;
+    onError?: (result: CsvUploadErrorResult | undefined) => void;
+    onImported?: (result: CsvUploadImportedResult) => void;
+    onPreview?: (result: CsvUploadPreviewResult) => void;
+    onProcessingStarted?: () => void;
+    dialogTitle?: string;
+    maxRows?: number;
+    onCancel?: () => void;
+    onClose?: () => void;
+    open?: boolean;
+    parseOptions?: CsvParseOptions;
+    importMode?: "direct" | "preview";
+    rowDefaults?: RowDefaultDataItemValues;
+    validators?: Record<string, CsvColumnValidator>;
+    /**
+     * Custom renderer for the error panel.
+     */
+    renderError?: (error: CsvUploadErrorResult) => ReactNode;
+}
+export declare const CsvUpload: (props: CsvUploadProps) => import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { type EditSession } from "@vuu-ui/vuu-data-editing";
+import type { HTMLAttributes } from "react";
+export interface DataUploadPreviewProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    editSession: EditSession;
+    onClose: () => void;
+    saveLabel?: string;
+    tableSchema: TableSchema;
+}
+export declare const DataUploadPreview: ({ className, editSession, onClose, saveLabel, tableSchema, ...htmlAttributes }: DataUploadPreviewProps) => import("react").JSX.Element;

package/types/src/csv-upload/data-upload-preview/useDataUploadPreview.d.ts

@@ -0,0 +1,17 @@
+import type { DataSource } from "@vuu-ui/vuu-data-types";
+import type { EditSession } from "@vuu-ui/vuu-data-editing";
+export interface UseDataUploadPreviewProps {
+    dataSource: DataSource;
+    editSession: EditSession;
+    onClose: () => void;
+}
+export declare const getSessionDataSource: (editSession: EditSession) => DataSource;
+export declare const useDataUploadPreview: ({ dataSource, editSession, onClose, }: UseDataUploadPreviewProps) => {
+    canCancel: boolean;
+    canSave: boolean;
+    hasSelection: boolean;
+    onCancel: () => Promise<void>;
+    onDelete: () => Promise<import("@vuu-ui/vuu-protocol-types").RpcResult>;
+    onSave: (force?: boolean) => Promise<void>;
+    sessionError: string | undefined;
+};

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

@@ -0,0 +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 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/src/csv-upload/parse/csv-constants.d.ts

@@ -0,0 +1,3 @@
+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/src/csv-upload/parse/csv-errors.d.ts

@@ -0,0 +1,47 @@
+export declare enum CsvParseErrorEnum {
+    EMPTY_FILE = "EMPTY_FILE",
+    INVALID_SEPARATOR = "INVALID_SEPARATOR",
+    INVALID_FORMAT = "INVALID_FORMAT",
+    UNQUOTED_VALUE = "UNQUOTED_VALUE",
+    EMPTY_HEADER_COLUMN = "EMPTY_HEADER_COLUMN",
+    DUPLICATE_HEADER_COLUMN = "DUPLICATE_HEADER_COLUMN",
+    ROW_COLUMN_COUNT_MISMATCH = "ROW_COLUMN_COUNT_MISMATCH"
+}
+export declare enum CsvValidationErrorEnum {
+    MISSING_KEY_COLUMN = "MISSING_KEY_COLUMN",
+    UNKNOWN_COLUMN = "UNKNOWN_COLUMN",
+    MAX_ROWS_EXCEEDED = "MAX_ROWS_EXCEEDED",
+    EMPTY_NON_STRING_VALUE = "EMPTY_NON_STRING_VALUE",
+    TYPE_MISMATCH = "TYPE_MISMATCH",
+    CUSTOM_VALIDATION = "CUSTOM_VALIDATION"
+}
+export type CsvErrorMap<TError extends string> = {
+    rowErrors: Record<number, Record<string, TError[]>>;
+    fileErrors: Record<string, TError[]>;
+};
+export type CsvStructuredError<TError extends string> = {
+    rowNum: number;
+    column: string;
+    value: string;
+    message: string;
+    errorEnum: TError;
+};
+export type CsvError<TError extends string> = {
+    errorMap: CsvErrorMap<TError>;
+    errors: CsvStructuredError<TError>[];
+    message: string;
+};
+export type CsvErrorState<TError extends string> = {
+    errorMap: CsvErrorMap<TError>;
+    errors: CsvStructuredError<TError>[];
+};
+export declare const createCsvErrorState: <TError extends string>() => CsvErrorState<TError>;
+export declare const addCsvFileError: <TError extends string>(state: CsvErrorState<TError>, columnName: string, error: TError, message: string, value?: string) => void;
+export declare const addCsvRowError: <TError extends string>(state: CsvErrorState<TError>, rowNum: number, columnName: string, error: TError, message: string, value?: string) => void;
+export declare const hasCsvErrors: <TError extends string>(errorMap: CsvErrorMap<TError>) => boolean;
+export type CsvParseErrorMap = CsvErrorMap<CsvParseErrorEnum>;
+export type CsvParseError = CsvError<CsvParseErrorEnum>;
+export type CsvValidationErrorType = CsvValidationErrorEnum | CsvParseErrorEnum;
+export type CsvValidationErrorMap = CsvErrorMap<CsvValidationErrorEnum>;
+export type CsvValidationStructuredError = CsvError<CsvValidationErrorType>;
+export type CsvValidationError = CsvStructuredError<CsvValidationErrorType>;

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

@@ -0,0 +1,11 @@
+import { type CsvParseError } from "./csv-errors";
+export { CsvParseErrorEnum, type CsvError, type CsvErrorMap, type CsvStructuredError, type CsvParseError, type CsvParseErrorMap, } from "./csv-errors";
+export type CsvParseResult = {
+    error?: CsvParseError;
+    header: string[];
+    rows: string[][];
+};
+export type CsvParseOptions = {
+    requireQuotedValues?: boolean;
+};
+export declare const parseCsv: (csvText: string, options?: CsvParseOptions) => CsvParseResult;

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

@@ -0,0 +1,18 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+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;
+    errors: CsvValidationError[];
+    parseRowError?: CsvParseError;
+    rows: Record<string, VuuRowDataItemType>[];
+};
+export type CsvValidationOptions = {
+    maxRows?: number;
+    validators?: Record<string, CsvColumnValidator>;
+};
+export declare const validateCsvAgainstSchema: (parsed: CsvParseResult, tableSchema: TableSchema, options?: CsvValidationOptions) => CsvValidationResult;

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

@@ -0,0 +1,21 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { CsvUploadError } from "../CsvUpload";
+import type { CsvParseError } from "./csv-parse";
+import type { CsvValidationError, CsvValidationResult } from "./csv-schema-validation";
+export type CsvUploadTableData = {
+    columns: string[];
+    rows: VuuRowDataItemType[][];
+};
+export declare const toErrorMessage: (error: unknown) => string;
+export declare const isCsvParseError: (value: unknown) => value is CsvParseError;
+export declare const hasFileParseErrors: (parseError: CsvParseError) => boolean;
+export declare const createUploadError: (source: CsvUploadError["source"], message: string, parseError?: CsvParseError, validationError?: CsvUploadError["validationError"]) => CsvUploadError;
+export declare const mergeValidationWithParseErrors: (schemaValidation: CsvValidationResult, parseError: CsvParseError | undefined) => CsvValidationResult;
+export declare const buildRowErrorMessage: (prefix: string, rowErrors: string[]) => string;
+export declare const toValidationErrorsFromParseRowErrors: (parseError: CsvParseError) => CsvValidationError[];
+export declare const normalizeTableData: (value: unknown, fallback: CsvUploadTableData) => CsvUploadTableData;
+export type RpcBatchResult = {
+    errors: string[];
+    results: unknown[];
+};
+export declare const executeBatchRpcCalls: <T>(items: T[], executor: (item: T) => Promise<unknown>, errorFormatter: (item: T, error: string) => string) => Promise<RpcBatchResult>;

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

@@ -0,0 +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 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";