@vuu-ui/vuu-data-editing 3.3.0 → 3.3.2

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Shared data editing APIs and React components for VUU UI",
   "main": "./src/index.js",
   "author": "heswell",
@@ -12,13 +12,13 @@
   },
   "dependencies": {
     "@salt-ds/core": "1.54.1",
-    "@vuu-ui/vuu-ui-controls": "3.3.0",
-    "@vuu-ui/vuu-utils": "3.3.0"
+    "@vuu-ui/vuu-ui-controls": "3.3.2",
+    "@vuu-ui/vuu-utils": "3.3.2"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.3.0",
-    "@vuu-ui/vuu-protocol-types": "3.3.0",
-    "@vuu-ui/vuu-table-types": "3.3.0"
+    "@vuu-ui/vuu-data-types": "3.3.2",
+    "@vuu-ui/vuu-protocol-types": "3.3.2",
+    "@vuu-ui/vuu-table-types": "3.3.2"
   },
   "peerDependencies": {
     "react": "^19.2.3"

package/src/EditSession.js

@@ -28,6 +28,7 @@ class EditSession extends EventEmitter {
     #cellCommitRevisions = new Map();
     #deleteMode;
     #editSessionApi;
+    #rowDefaults;
     #sourceTableDataSource;
     #sessionDataSource;
     #newRowState = {
@@ -41,11 +42,12 @@ class EditSession extends EventEmitter {
         status: "idle"
     };
     #transitionQueue = Promise.resolve();
-    constructor(dataSource, deleteMode = "soft", editSessionApi = "createSessionDataSource"){
+    constructor({ dataSource, deleteMode = "soft", editSessionApi = "createSessionDataSource", rowDefaults = {} }){
         super();
         this.#sourceTableDataSource = dataSource;
         this.#deleteMode = deleteMode;
         this.#editSessionApi = editSessionApi;
+        this.#rowDefaults = rowDefaults;
     }
     get editCount() {
         return this.#editCount;
@@ -245,7 +247,10 @@ class EditSession extends EventEmitter {
     async addRow(rowData = {}) {
         const addRow = this.dataSource?.addRow;
         if (void 0 === addRow) throw Error("[EditSession] datasource does not support adding rows");
-        const response = await addRow.call(this.dataSource, rowData);
+        const response = await addRow.call(this.dataSource, {
+            ...this.#rowDefaults,
+            ...rowData
+        });
         if (void 0 === response) throw Error("[EditSession] datasource returned no response when adding row");
         if (!isRpcError(response)) this.addCount = this.#addCount + 1;
         return response;
@@ -358,6 +363,7 @@ class EditSession extends EventEmitter {
                     status: "active",
                     sessionDataSource
                 });
+                this.reconcileWithSessionSchema();
                 return sessionDataSource;
             } catch (cause) {
                 const error = cause instanceof Error ? cause : new Error(String(cause));
@@ -370,6 +376,21 @@ class EditSession extends EventEmitter {
             }
         });
     }
+    reconcileWithSessionSchema() {
+        const sessionSchema = this.#sessionDataSource?.tableSchema;
+        if (void 0 === sessionSchema) return;
+        const columnNames = new Set(sessionSchema.columns.map((c)=>c.name));
+        const unknown = Object.keys(this.#rowDefaults).filter((key)=>!columnNames.has(key));
+        if (unknown.length > 0) {
+            console.warn(`[EditSession] rowDefaults contains columns not in table schema, removing: ${unknown.join(", ")}`);
+            for (const key of unknown)delete this.#rowDefaults[key];
+        }
+        const sourceKey = this.#sourceTableDataSource?.tableSchema?.key;
+        if (void 0 !== sourceKey && sourceKey !== sessionSchema.key) {
+            console.warn(`[EditSession] source table key '${sourceKey}' differs from session table key '${sessionSchema.key}', discarding pending edits`);
+            this.#clearEdits();
+        }
+    }
     get dataSource() {
         return this.#sessionDataSource ?? this.#sourceTableDataSource;
     }

package/src/useEditableTable.js

@@ -5,7 +5,7 @@ import { EDIT_ACTION_ROW_CLASS_NAME_GENERATOR } from "./editActionRowClassNameGe
 const EDIT_ACTION_ROW_CLASS_NAME_GENERATORS = [
     EDIT_ACTION_ROW_CLASS_NAME_GENERATOR
 ];
-const useEditableTable = ({ columns, dataSource: dataSourceProp, deleteMode = "soft", editSessionApi = "createSessionDataSource", copyOption = "All", isEditMode, onCancel, onSave, table })=>{
+const useEditableTable = ({ columns, dataSource: dataSourceProp, deleteMode = "soft", editSessionApi = "createSessionDataSource", copyOption = "All", isEditMode, onCancel, onSave, rowDefaults, table })=>{
     const { VuuDataSource } = useData();
     const [selectionCount, setSelectionCount] = useState(0);
     useLayoutEffectSkipFirst(()=>{
@@ -27,9 +27,15 @@ const useEditableTable = ({ columns, dataSource: dataSourceProp, deleteMode = "s
         dataSourceProp,
         table
     ]);
-    const editSession = useMemo(()=>new EditSession(sourceDataSource, deleteMode, editSessionApi), [
+    const editSession = useMemo(()=>new EditSession({
+            dataSource: sourceDataSource,
+            deleteMode,
+            editSessionApi,
+            rowDefaults
+        }), [
         deleteMode,
         editSessionApi,
+        rowDefaults,
         sourceDataSource
     ]);
     const [lifecycle, setLifecycle] = useState(editSession.lifecycle);
@@ -79,12 +85,16 @@ const useEditableTable = ({ columns, dataSource: dataSourceProp, deleteMode = "s
     ]);
     useEffect(()=>{
         if (!sessionDataSource) return void setSubscribedSessionDataSource(void 0);
-        const handleSubscribed = ()=>setSubscribedSessionDataSource(sessionDataSource);
+        const handleSubscribed = ()=>{
+            editSession.reconcileWithSessionSchema();
+            setSubscribedSessionDataSource(sessionDataSource);
+        };
         setSubscribedSessionDataSource(void 0);
         sessionDataSource.on("subscribed", handleSubscribed);
         if ("subscribed" === sessionDataSource.status && sessionDataSource.tableSchema) handleSubscribed();
         return ()=>sessionDataSource.removeListener("subscribed", handleSubscribed);
     }, [
+        editSession,
         sessionDataSource
     ]);
     useEffect(()=>{
@@ -121,10 +131,15 @@ const useEditableTable = ({ columns, dataSource: dataSourceProp, deleteMode = "s
     const canCancel = "active" === lifecycle.status || "error" === lifecycle.status && "end" === lifecycle.operation;
     const canSave = canCancel && ("dirty" === editState || "stale" === editState) && 0 === editSession.invalidCount;
     const isEditSessionReady = isEditMode && void 0 !== sessionDataSource && sessionDataSource === editSession.sessionDataSource && subscribedSessionDataSource === sessionDataSource && "subscribed" === sessionDataSource.status && void 0 !== sessionDataSource.tableSchema;
+    const editSchema = subscribedSessionDataSource?.tableSchema;
+    const viewSchema = sourceDataSource.tableSchema;
+    const columnsDiverge = void 0 !== editSchema && void 0 !== viewSchema && (editSchema.columns.length !== viewSchema.columns.length || editSchema.columns.some((column, index)=>column.name !== viewSchema.columns[index]?.name));
     return {
         canCancel,
         canSave,
+        columnsDiverge,
         dataSource,
+        editSchema,
         editSession,
         lifecycle,
         hasSelection: selectionCount > 0,

package/types/EditSession.d.ts

@@ -2,7 +2,18 @@ import type { CopyOption, DataSource, DeleteRowMode, EditApi, SessionType } from
 import type { RpcResult, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
 import { EventEmitter } from "@vuu-ui/vuu-utils";
 export type EditState = "clean" | "dirty" | "invalid" | "stale";
+/** Column name to default value mapping applied to every addRow call when a column is absent from the row data. */
+export type RowDefaultDataItemValues = Record<string, VuuRowDataItemType>;
 export type EditSessionApi = "createSessionDataSource" | "beginEditSession";
+export type EditSessionConstructorProps = {
+    dataSource: EditApi;
+    /** @default "soft" */
+    deleteMode?: DeleteRowMode;
+    /** @default "createSessionDataSource" */
+    editSessionApi?: EditSessionApi;
+    /** Default column values merged into every addRow call for absent columns. Pass a stable reference. */
+    rowDefaults?: RowDefaultDataItemValues;
+};
 export type NewRowState = {
     columns: readonly string[];
     draftRevision: number;
@@ -39,7 +50,7 @@ type EditSessionEvents = {
 export declare class EditSession extends EventEmitter<EditSessionEvents> {
     #private;
     static readonly newRowKey = "__vuu_new_row__";
-    constructor(dataSource: EditApi, deleteMode?: DeleteRowMode, editSessionApi?: EditSessionApi);
+    constructor({ dataSource, deleteMode, editSessionApi, rowDefaults, }: EditSessionConstructorProps);
     get editCount(): number;
     set editCount(val: number);
     get invalidCount(): number;
@@ -63,6 +74,11 @@ export declare class EditSession extends EventEmitter<EditSessionEvents> {
     isCellEdited(key: string, columnName: string): boolean;
     undoRowChange(key: string): Promise<void>;
     begin(copyOption?: CopyOption, sessionType?: SessionType): Promise<DataSource>;
+    /**
+     * Safe to call repeatedly - schema of a remote session table typically arrives
+     * after begin() resolves, so callers re-invoke this once 'subscribed' fires.
+     */
+    reconcileWithSessionSchema(): void;
     get dataSource(): EditApi<import("@vuu-ui/vuu-data-types").DataSourceRow<VuuRowDataItemType>> | undefined;
     get sessionDataSource(): DataSource | undefined;
     end(saveChanges?: boolean, force?: boolean): Promise<void>;

package/types/index.d.ts

@@ -3,7 +3,7 @@ export { useCellEdited } from "./useCellEdited";
 export { getVuuEditMessage, isInlineEditingSession, isEditRowReadOnly, withDataRowEditErrors, } from "./edit-utils";
 export { EditButtons, type EditButtonProps } from "./EditButtons";
 export { EditModeProvider, useEditMode, type EditModeContextProps, } from "./EditModeProvider";
-export { EditError, EditSession, SupersededEditError, type EditLifecycle, type NewRowState, type EditState, } from "./EditSession";
+export { EditError, EditSession, SupersededEditError, type EditLifecycle, type EditSessionConstructorProps, type NewRowState, type EditState, type RowDefaultDataItemValues, } from "./EditSession";
 export { StaleUpdateError } from "@vuu-ui/vuu-utils";
 export { EDIT_ACTION_ROW_CLASS_NAME_GENERATOR, editActionRowClassNameGenerator, } from "./editActionRowClassNameGenerator";
 export { getUndoButtonContent, getUndoTooltipContent, UNDO_CELL_RENDERER, UndoCellRenderer, type UndoCellRendererComponentProps, } from "./UndoCellRenderer";

package/types/useEditableTable.d.ts

@@ -1,6 +1,6 @@
 import type { CopyOption, DataSource, DeleteRowMode } from "@vuu-ui/vuu-data-types";
 import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
-import { EditSession, type EditLifecycle, type EditSessionApi } from "./EditSession";
+import { EditSession, type EditLifecycle, type EditSessionApi, type RowDefaultDataItemValues } from "./EditSession";
 export type EditMode = "edit" | "view";
 export interface EditableTableHookProps {
     /**
@@ -16,16 +16,20 @@ export interface EditableTableHookProps {
     isEditMode: boolean;
     onCancel: () => void;
     onSave: () => void;
+    /** Default column values applied to every addRow call. Pass a stable reference — a new object triggers EditSession recreation. */
+    rowDefaults?: RowDefaultDataItemValues;
     /**
      * If dataSource not provided, new DataSource
      * will be created using table and columns
      */
     table?: VuuTable;
 }
-export declare const useEditableTable: ({ columns, dataSource: dataSourceProp, deleteMode, editSessionApi, copyOption, isEditMode, onCancel, onSave, table, }: EditableTableHookProps) => {
+export declare const useEditableTable: ({ columns, dataSource: dataSourceProp, deleteMode, editSessionApi, copyOption, isEditMode, onCancel, onSave, rowDefaults, table, }: EditableTableHookProps) => {
     canCancel: boolean;
     canSave: boolean;
+    columnsDiverge: boolean;
     dataSource: DataSource;
+    editSchema: import("@vuu-ui/vuu-data-types").TableSchema | undefined;
     editSession: EditSession;
     lifecycle: EditLifecycle;
     hasSelection: boolean;