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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.0",
+  "version": "3.3.1",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
@@ -9,13 +9,13 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@vuu-ui/vuu-data-local": "3.2.0",
-    "@vuu-ui/vuu-utils": "3.2.0"
+    "@vuu-ui/vuu-data-local": "3.3.1",
+    "@vuu-ui/vuu-utils": "3.3.1"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "3.2.0",
-    "@vuu-ui/vuu-data-types": "3.2.0",
-    "@vuu-ui/vuu-table-types": "3.2.0"
+    "@vuu-ui/vuu-protocol-types": "3.3.1",
+    "@vuu-ui/vuu-data-types": "3.3.1",
+    "@vuu-ui/vuu-table-types": "3.3.1"
   },
   "sideEffects": false,
   "files": [

package/src/TickingArrayDataSource.js

@@ -63,17 +63,19 @@ class TickingArrayDataSource extends ArrayDataSource {
     isSessionDataSourceOf(dataSource) {
         return this.#sourceTableDataSource === dataSource;
     }
-    async createSessionDataSource(copyOption) {
+    async createSessionDataSource(copyOption, sessionType = "edit") {
         const rpcResponse = await this?.rpcRequest?.({
             type: "RPC_REQUEST",
             rpcName: "createSessionTable",
             params: {
-                copyOption
+                copyOption,
+                sessionType
             }
         });
         if (isRpcSuccess(rpcResponse)) {
             const { table: sessionTable } = rpcResponse.data;
-            const columns = this.config.columns.includes("vuu_action") ? this.config.columns : this.config.columns.concat("vuu_action");
+            const baseColumns = this.config.columns.includes("vuuAction") ? this.config.columns : this.config.columns.concat("vuuAction");
+            const columns = "import" !== sessionType || baseColumns.includes("vuuRowNum") ? baseColumns : baseColumns.concat("vuuRowNum");
             const sessionDataSource = this.#vuuModule?.createDataSource(sessionTable.table, sessionTable.table, {
                 ...this.config,
                 columns
@@ -113,11 +115,13 @@ class TickingArrayDataSource extends ArrayDataSource {
         });
     }
     addRow = async (rowData = {})=>{
+        const keyValue = rowData[this.tableSchema.key];
+        const key = void 0 !== keyValue ? String(keyValue) : "vuuRowNum" in rowData ? String(rowData.vuuRowNum) : void 0;
         const response = await this.rpcRequest?.({
             type: "RPC_REQUEST",
             rpcName: "addRow",
             params: {
-                key: rowData[this.tableSchema.key],
+                key,
                 data: rowData
             }
         });

package/src/core/module/VuuModule.js

@@ -177,7 +177,7 @@ class VuuModule {
             const { key, mode = "hard" } = rpcRequest.params;
             const sessionTable = this.getSessionTable(viewPortId, false);
             if (sessionTable) {
-                if ("soft" === mode) sessionTable.update(key, "vuu_action", "deleteRow");
+                if ("soft" === mode) sessionTable.update(key, "vuuAction", "deleteRow");
                 else sessionTable.delete(key);
                 return {
                     type: "SUCCESS_RESULT",
@@ -215,7 +215,7 @@ class VuuModule {
                 const deletedKeys = [];
                 if (selectedRowIds.length > 0) {
                     for (const key of selectedRowIds){
-                        if ("soft" === mode) sessionTable.update(key, "vuu_action", "deleteRow");
+                        if ("soft" === mode) sessionTable.update(key, "vuuAction", "deleteRow");
                         else sessionTable.delete(key);
                         deletedKeys.push(key);
                     }
@@ -259,7 +259,7 @@ class VuuModule {
                     type: "ERROR_RESULT",
                     errorMessage: `undoRowChange: session row not found for key ${key}`
                 };
-                const action = sessionRow[sessionTable.map.vuu_action];
+                const action = sessionRow[sessionTable.map.vuuAction];
                 if ("addRow" === action) {
                     sessionTable.delete(key);
                     return {
@@ -278,7 +278,7 @@ class VuuModule {
                     const restoredRow = sessionRow.slice();
                     for (const column of sourceTable.schema.columns)restoredRow[sessionTable.map[column.name]] = sourceRow[sourceTable.map[column.name]];
                     sessionTable.updateRow(restoredRow);
-                    sessionTable.update(key, "vuu_action", "");
+                    sessionTable.update(key, "vuuAction", "");
                 }
                 return {
                     type: "SUCCESS_RESULT",
@@ -312,10 +312,10 @@ class VuuModule {
             }
             if (targetTable) try {
                 const sessionRow = sessionTable?.findByKey(key);
-                if (sessionRow?.[sessionTable.map.vuu_action] === "deleteRow") throw Error("editCell: cannot edit a deleted row");
+                if (sessionRow?.[sessionTable.map.vuuAction] === "deleteRow") throw Error("editCell: cannot edit a deleted row");
                 assertUpdateIsValid(targetTable.schema, column, data);
                 targetTable.update(key, column, data);
-                if (sessionTable && sessionTable.findByKey(key)?.[sessionTable.map.vuu_action] !== "addRow") sessionTable.update(key, "vuu_action", "editCell");
+                if (sessionTable && sessionTable.findByKey(key)?.[sessionTable.map.vuuAction] !== "addRow") sessionTable.update(key, "vuuAction", "editCell");
                 return {
                     type: "SUCCESS_RESULT",
                     data: void 0
@@ -374,7 +374,7 @@ class VuuModule {
     createSessionTableService = async (rpcRequest)=>{
         if (isCreateSessionTableRpcRequest(rpcRequest)) {
             const { viewPortId } = rpcRequest.context;
-            const { copyOption } = rpcRequest.params;
+            const { copyOption, sessionType } = rpcRequest.params;
             const subscription = this.getSubscriptionByViewport(viewPortId);
             const { dataSource } = subscription;
             const { table: vuuTable } = dataSource;
@@ -383,7 +383,7 @@ class VuuModule {
                 if (sourceTable) {
                     const sessionTableName = `session-${uuid()}`;
                     try {
-                        const sessionTable = this.createSessionTable(sourceTable, sessionTableName, copyOption, dataSource);
+                        const sessionTable = this.createSessionTable(sourceTable, sessionTableName, copyOption, dataSource, sessionType);
                         this.#sessionTableMap[sessionTableName] = sessionTable;
                         this.#sessionSourceTableMap[sessionTableName] = vuuTable.table;
                         subscription.sessionTableName = sessionTableName;
@@ -460,9 +460,9 @@ class VuuModule {
                 type: "ERROR_RESULT",
                 errorMessage: `addRow: no active session table for viewport ${viewPortId}`
             };
-            const { data } = rpcRequest.params;
+            const { data, key } = rpcRequest.params;
             const keyColumn = sessionTable.schema.key;
-            const rowKey = data[keyColumn] ?? uuid();
+            const rowKey = data[keyColumn] ?? key ?? uuid();
             const rowData = {
                 ...data,
                 [keyColumn]: rowKey
@@ -470,7 +470,7 @@ class VuuModule {
             const columnMap = sessionTable.map;
             const columnCount = Object.keys(columnMap).length;
             const row = new Array(columnCount).fill("");
-            row[columnMap.vuu_action] = "addRow";
+            row[columnMap.vuuAction] = "addRow";
             for (const [col, idx] of Object.entries(columnMap))if (void 0 !== rowData[col]) row[idx] = rowData[col];
             sessionTable.insert(row);
             return {
@@ -500,7 +500,7 @@ class VuuModule {
                 {
                     let rejectedCount = 0;
                     const vuuMsgIdx = sessionTable.map[this.#sessionTableMessageColumn];
-                    const actionIdx = sessionTable.map.vuu_action;
+                    const actionIdx = sessionTable.map.vuuAction;
                     const sessionTimestampIdx = sessionTable.map.vuuUpdatedTimestamp;
                     const sourceTimestampIdx = sourceTable.map.vuuUpdatedTimestamp;
                     const sourceColumns = sourceTable.schema.columns;
@@ -559,17 +559,17 @@ class VuuModule {
         }
         throw Error("[VuuModule] applyBulkEdits invalid rpc type");
     };
-    createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource) {
+    createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource, sessionType) {
         if ("All" === editSessionMode || editSessionMode.endsWith("all-rows")) return this.createSessionTableWithAllRows(sourceTable, sessionTableName);
         if ("Selected" === editSessionMode || "selected-rows" === editSessionMode) return this.createSessionTableFromSelectedRows(sourceTable, sessionTableName, dataSource);
-        if ("Empty" === editSessionMode || "empty-session-table" === editSessionMode) return this.createEmptySessionTable(sourceTable, sessionTableName);
+        if ("Empty" === editSessionMode || "empty-session-table" === editSessionMode) return this.createEmptySessionTable(sourceTable, sessionTableName, sessionType);
         throw Error(`[VuuModule] createSessionTable, invalid editSessionMode ${editSessionMode}`);
     }
     createSessionTableWithAllRows({ data, schema }, _sessionTableName) {
         const sessionSchema = sessionTableSchema(schema);
         return new Table(sessionSchema, data.map((row)=>sessionTableRow(row, schema)), buildDataColumnMapFromSchema(sessionSchema));
     }
-    createEmptySessionTable({ schema }, sessionTableName) {
+    createEmptySessionTable({ schema }, sessionTableName, sessionType) {
         const sessionSchema = sessionTableSchema({
             ...schema,
             table: {
@@ -577,6 +577,10 @@ class VuuModule {
                 table: sessionTableName
             }
         });
+        if ("import" === sessionType) sessionSchema.columns.push({
+            name: "vuuRowNum",
+            serverDataType: "int"
+        });
         return new Table(sessionSchema, [], buildDataColumnMapFromSchema(sessionSchema));
     }
     createSessionTableFromSelectedRows({ data, map, schema }, sessionTableName, dataSource) {

package/src/session-table-utils.js

@@ -4,7 +4,7 @@ const { KEY: KEY } = metadataKeys;
 const sessionTableRow = (row, schema)=>{
     const sessionRow = row.slice();
     if (!schema.columns.some(({ name })=>"vuuMsg" === name)) sessionRow.push("");
-    if (!schema.columns.some(({ name })=>"vuu_action" === name)) sessionRow.push("");
+    if (!schema.columns.some(({ name })=>"vuuAction" === name)) sessionRow.push("");
     return sessionRow;
 };
 const createSessionTableFromSelectedRows = (table, selectedRowIds)=>{
@@ -19,8 +19,8 @@ const sessionTableSchema = (schema)=>{
         name: "vuuMsg",
         serverDataType: "string"
     });
-    if (!columns.some(({ name })=>"vuu_action" === name)) columns.push({
-        name: "vuu_action",
+    if (!columns.some(({ name })=>"vuuAction" === name)) columns.push({
+        name: "vuuAction",
         serverDataType: "string"
     });
     return {

package/types/TickingArrayDataSource.d.ts

@@ -1,5 +1,5 @@
 import { ArrayDataSource, type ArrayDataSourceConstructorProps } from "@vuu-ui/vuu-data-local";
-import type { DataSourceBase, DataSource, DataSourceRowWithBigint, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceVisualLinkCreatedMessage, DeleteRowMode, CopyOption, EditSessionMode } from "@vuu-ui/vuu-data-types";
+import type { DataSourceBase, DataSource, DataSourceRowWithBigint, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceVisualLinkCreatedMessage, DeleteRowMode, CopyOption, EditSessionMode, SessionType } from "@vuu-ui/vuu-data-types";
 import type { LinkDescriptorWithLabel, RpcResultError, RpcResultSuccess, VuuCreateVisualLink, VuuMenu, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
 import type { IVuuModule, RpcMenuService, RpcService } from "./core/module/VuuModule";
 import type { Table } from "./Table";
@@ -24,7 +24,7 @@ export declare class TickingArrayDataSource extends ArrayDataSource {
     get links(): LinkDescriptorWithLabel[] | undefined;
     getSelectedRowIds(): string[];
     isSessionDataSourceOf(dataSource: DataSource): boolean;
-    createSessionDataSource(copyOption: CopyOption): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
+    createSessionDataSource(copyOption: CopyOption, sessionType?: SessionType): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
     beginEditSession(editSessionMode?: EditSessionMode): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
     editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultSuccess | RpcResultError>;
     addRow: (rowData?: Record<string, VuuRowDataItemType>) => Promise<true | string>;

package/types/core/module/VuuModule.d.ts

@@ -1,4 +1,4 @@
-import type { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSourceSubscribedMessage, DataSourceVisualLinkCreatedMessage, EditSessionMode, CopyOption, TableSchema } from "@vuu-ui/vuu-data-types";
+import type { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSourceSubscribedMessage, DataSourceVisualLinkCreatedMessage, EditSessionMode, CopyOption, SessionType, TableSchema } from "@vuu-ui/vuu-data-types";
 import type { VuuMenu, VuuLink, LinkDescriptorWithLabel, VuuRpcMenuResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcServiceRequest, RpcResultSuccess, RpcResultError, VuuRpcMenuRequest } from "@vuu-ui/vuu-protocol-types";
 import { Table } from "../../Table";
 import { TickingArrayDataSource } from "../../TickingArrayDataSource";
@@ -69,9 +69,9 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     private addRow;
     private endEditSession;
     private applyBulkEdits;
-    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: EditSessionMode | CopyOption, dataSource: TickingArrayDataSource): Table;
+    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: EditSessionMode | CopyOption, dataSource: TickingArrayDataSource, sessionType?: SessionType): Table;
     protected createSessionTableWithAllRows({ data, schema }: Table, _sessionTableName: string): Table;
-    protected createEmptySessionTable({ schema }: Table, sessionTableName: string): Table;
+    protected createEmptySessionTable({ schema }: Table, sessionTableName: string, sessionType?: SessionType): Table;
     protected createSessionTableFromSelectedRows({ data, map, schema }: Table, sessionTableName: string, dataSource: TickingArrayDataSource): Table;
 }
 export {};