@vuu-ui/vuu-data-editing 3.2.0 → 3.3.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.0",
+  "version": "3.3.1",
   "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.2.0",
-    "@vuu-ui/vuu-utils": "3.2.0"
+    "@vuu-ui/vuu-ui-controls": "3.3.1",
+    "@vuu-ui/vuu-utils": "3.3.1"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.2.0",
-    "@vuu-ui/vuu-protocol-types": "3.2.0",
-    "@vuu-ui/vuu-table-types": "3.2.0"
+    "@vuu-ui/vuu-data-types": "3.3.1",
+    "@vuu-ui/vuu-protocol-types": "3.3.1",
+    "@vuu-ui/vuu-table-types": "3.3.1"
   },
   "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;
@@ -334,7 +339,7 @@ class EditSession extends EventEmitter {
         this.#transitionQueue = result.then(()=>void 0, ()=>void 0);
         return result;
     }
-    begin(copyOption = "All") {
+    begin(copyOption = "All", sessionType = "edit") {
         return this.#enqueue(async ()=>{
             if ("active" === this.#lifecycle.status || "error" === this.#lifecycle.status && "end" === this.#lifecycle.operation) {
                 const sessionDataSource = this.#sessionDataSource;
@@ -350,7 +355,7 @@ class EditSession extends EventEmitter {
             });
             try {
                 const sourceDataSource = this.#sourceTableDataSource;
-                const sessionDataSource = "beginEditSession" === this.#editSessionApi ? await sourceDataSource?.beginEditSession?.(toEditSessionMode(copyOption)) : await sourceDataSource?.createSessionDataSource?.(copyOption);
+                const sessionDataSource = "beginEditSession" === this.#editSessionApi ? await sourceDataSource?.beginEditSession?.(toEditSessionMode(copyOption)) : await sourceDataSource?.createSessionDataSource?.(copyOption, sessionType);
                 if (!sessionDataSource) throw new Error(`[EditSession] datasource does not support ${this.#editSessionApi}`);
                 this.#sessionDataSource = sessionDataSource;
                 this.#setStale(false);
@@ -358,6 +363,17 @@ class EditSession extends EventEmitter {
                     status: "active",
                     sessionDataSource
                 });
+                if (Object.keys(this.#rowDefaults).length > 0) {
+                    const schema = sessionDataSource.tableSchema;
+                    if (schema) {
+                        const columnNames = new Set(schema.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];
+                        }
+                    }
+                }
                 return sessionDataSource;
             } catch (cause) {
                 const error = cause instanceof Error ? cause : new Error(String(cause));

package/src/UndoCellRenderer.js

@@ -13,7 +13,7 @@ const UndoCellRenderer = ({ column, dataRow })=>{
     const editSession = useEditSession();
     const renderer = column.type?.renderer;
     const { icon, text } = getUndoButtonContent(renderer?.componentProps);
-    const tooltipContent = getUndoTooltipContent(dataRow.vuu_action);
+    const tooltipContent = getUndoTooltipContent(dataRow.vuuAction);
     if (void 0 === tooltipContent) return null;
     return /*#__PURE__*/ jsx(Tooltip, {
         content: tooltipContent,

package/src/edit-utils.js

@@ -4,7 +4,7 @@ const timeFormatter = formatDate({
     time: "hh:mm:ss"
 });
 const dataRowEditErrors = Symbol("vuuDataRowEditErrors");
-const isEditRowReadOnly = (dataRow)=>"deleteRow" === dataRow.vuu_action;
+const isEditRowReadOnly = (dataRow)=>"deleteRow" === dataRow.vuuAction;
 const withDataRowEditErrors = (dataRow, errors)=>{
     Object.defineProperty(dataRow, dataRowEditErrors, {
         configurable: true,

package/src/editActionRowClassNameGenerator.js

@@ -1,7 +1,7 @@
 import { registerComponent } from "@vuu-ui/vuu-utils";
 const EDIT_ACTION_ROW_CLASS_NAME_GENERATOR = "vuu-edit-actions";
 const editActionRowClassNameGenerator = (dataRow)=>{
-    switch(dataRow.vuu_action){
+    switch(dataRow.vuuAction){
         case "addRow":
             return "vuuTableRow-inserted";
         case "deleteRow":

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);

package/types/EditSession.d.ts

@@ -1,8 +1,19 @@
-import type { CopyOption, DataSource, DeleteRowMode, EditApi } from "@vuu-ui/vuu-data-types";
+import type { CopyOption, DataSource, DeleteRowMode, EditApi, SessionType } from "@vuu-ui/vuu-data-types";
 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;
@@ -62,7 +73,7 @@ export declare class EditSession extends EventEmitter<EditSessionEvents> {
     hasRowChanges(key: string): boolean;
     isCellEdited(key: string, columnName: string): boolean;
     undoRowChange(key: string): Promise<void>;
-    begin(copyOption?: CopyOption): Promise<DataSource>;
+    begin(copyOption?: CopyOption, sessionType?: SessionType): Promise<DataSource>;
     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,13 +16,15 @@ 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;
     dataSource: DataSource;