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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.20",
+  "version": "4.0.0-alpha.22",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -12,25 +12,24 @@
     "lezer-generate:column": "lezer-generator --output ./src/column-expression-input/column-language-parser/generated/column-parser.ts ./src/column-expression-input/column-language-parser/grammar/column.grammar"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.20"
+    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.22"
   },
   "dependencies": {
-    "@vuu-ui/core": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-codemirror": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-data-react": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-popups": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-table": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.20",
-    "@vuu-ui/vuu-ui-controls": "4.0.0-alpha.20",
+    "@vuu-ui/core": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-codemirror": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-data-react": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-popups": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-table": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.22",
+    "@vuu-ui/vuu-ui-controls": "4.0.0-alpha.22",
     "@lezer/lr": "1.4.2",
-    "@salt-ds/core": "1.67.0",
-    "@salt-ds/lab": "1.0.0-alpha.99",
-    "@salt-ds/styles": "0.2.1",
-    "@salt-ds/window": "0.1.1",
+    "@salt-ds/core": "1.72.0",
+    "@salt-ds/styles": "0.4.1",
+    "@salt-ds/window": "0.1.2",
     "csv-parse": "^7.0.0"
   },
   "peerDependencies": {

package/src/cell-renderers/pct-progress-cell/PctProgressCell.css.js

@@ -9,8 +9,8 @@ const css = `
 }
 
 .vuuPctProgressCell-progressBar {
-  background-color: var(--vuu-color-green-60-fade-30);
-  border-right: solid var(--progress-bar-width) var(--vuu-color-green-60);
+  background-color: var(--salt-color-green-600-40a);
+  border-right: solid var(--progress-bar-width) var(--salt-color-green-600);
   height: 20px;
   width: var(--progress-bar-pct, 0);
   display: inline-block;

package/src/cell-renderers/progress-cell/ProgressCell.css.js

@@ -13,7 +13,7 @@ const css = `
 }
 
 .vuuProgressCell-bg {
-  background-color: var(--salt-measured-background);
+  background-color: var(--salt-sentiment-neutral-track);
   width: 100%;
   height: 2px;
   display: inline-block;
@@ -23,7 +23,7 @@ const css = `
 }
 
 .vuuProgressCell-bar {
-  background-color: var(--salt-measured-fill);
+  background-color: var(--salt-sentiment-accent-background);
   height: 100%;
   transform: translateX(var(--progress-bar-pct, -100%));
   width: 100%;

package/src/column-expression-input/ColumnExpressionInput.css.js

@@ -5,15 +5,15 @@ const css = `
   --vuuFilterEditor-fontFamily: var(--salt-typography-fontFamily);
   --vuuFilterEditor-fontSize: var(--salt-text-fontSize);
   --vuuFilterEditor-cursorColor: var(--salt-content-secondary-foreground);
-  --vuuFilterEditor-selectionBackground: var(--salt-text-background-selected);
+  --vuuFilterEditor-selectionBackground: var(--salt-selectable-background-selected);
   --vuuFilterEditor-tooltipBackground: var(--salt-container-primary-background);
-  --vuuFilterEditor-tooltipBorder: solid 1px var(--vuu-color-purple-10);
+  --vuuFilterEditor-tooltipBorder: solid 1px var(--vuu-color-purple);
   --vuuFilterEditor-tooltipElevation: var(--salt-overlayable-shadow-popout);
   --vuuFilterEditor-suggestion-selectedBackground: var(--vuu-color-gray-10);
   --vuuFilterEditor-suggestion-selectedColor: var(--salt-content-primary-foreground);
   --vuuFilterEditor-suggestion-detailColor: var(--salt-content-secondary-foreground-disabled);
   --vuuFilterEditor-suggestion-height: 24px;
-  --vuuFilterEditor-variableColor: var(--vuu-color-purple-10);
+  --vuuFilterEditor-variableColor: var(--vuu-color-purple);
   box-sizing: border-box;
   align-items: center;
   height: 30px;
@@ -72,13 +72,13 @@ const css = `
 }
 
 .vuuFunctionDoc .example-container {
-  background-color: var(--vuu-color-gray-03);
+  background-color: var(--salt-color-gray-100);
   margin: 6px 0;
   padding: 3px;
 }
 
 .vuuFunctionDoc .example-expression {
-  color: var(--vuu-color-gray-80);
+  color: var(--salt-color-gray-800);
   font-family: var(--salt-typography-fontFamily-code);
   padding: 8px;
   font-weight: 500;

package/src/column-expression-input/theme.js

@@ -24,7 +24,7 @@ const vuuTheme = EditorView.theme({
         color: "var(--vuu-color-gray-50)"
     },
     ".cm-completionMatchedText": {
-        color: "var(--vuu-color-gray-80)",
+        color: "var(--salt-color-gray-800)",
         fontWeight: 700,
         textDecoration: "none"
     },

package/src/column-settings-panel/ColumnNameLabel.css.js

@@ -10,7 +10,7 @@ const css = `
 }
 
 .vuuColumnNameLabel-placeholder {
-  color: var(--vuu-color-gray-35);
+  color: var(--salt-color-gray-400);
 }
 
 

package/src/csv-export/export-utils.js

@@ -51,8 +51,9 @@ const isExportableColumn = (descriptor)=>{
 const exportCsvTemplate = async (dataSource, options = {})=>{
     const { filename = "template.csv", excludeColumns = [], columns, overrides, timeout = DEFAULT_TEMPLATE_TIMEOUT, onError, onSuccess } = options;
     const targetColumnNames = columns ? columns.filter((col)=>"string" == typeof col ? true : isExportableColumn(col) && "client" !== col.source).map((col)=>"string" == typeof col ? col : col.name) : void 0;
-    const sessionOverrides = overrides ?? (targetColumnNames ? {
-        columns: targetColumnNames
+    const targetColumns = targetColumnNames ?? overrides?.columns;
+    const sessionOverrides = overrides ?? (targetColumns ? {
+        columns: targetColumns
     } : void 0);
     if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource && "initialising" !== dataSource.status && "unsubscribed" !== dataSource.status) try {
         const sessionDataSource = await dataSource.createSessionDataSource("Empty", "export", sessionOverrides);
@@ -80,7 +81,16 @@ const exportCsvTemplate = async (dataSource, options = {})=>{
             }, (message)=>{
                 if ("subscribed" === message.type) {
                     const { columns: subColumns } = message;
-                    const exportCols = subColumns.filter((name)=>!excluded.has(name));
+                    const exportCols = targetColumns ? targetColumns.filter((name)=>!excluded.has(name)) : subColumns.filter((name)=>!excluded.has(name));
+                    if (0 === exportCols.length) {
+                        cleanup();
+                        const error = new Error("exportCsvTemplate: no columns available for export");
+                        if (onError) {
+                            onError(error);
+                            resolve();
+                        } else reject(error);
+                        return;
+                    }
                     const header = exportCols.map(csvCell).join(",");
                     triggerCsvDownload(`${header}\r\n`, filename);
                     cleanup();
@@ -93,7 +103,6 @@ const exportCsvTemplate = async (dataSource, options = {})=>{
         console.warn("[exportCsvTemplate] createSessionDataSource failed, falling back to tableSchema", error);
     }
     const schema = dataSource.tableSchema;
-    const targetColumns = targetColumnNames ?? overrides?.columns;
     if (void 0 !== targetColumns) {
         if (schema) {
             const schemaColumnNames = new Set(schema.columns.map((col)=>col.name));

package/src/csv-upload/CsvUpload.css.js

@@ -20,8 +20,8 @@ const css = `
   max-width: 480px;
   max-height: 120px;
   padding: var(--salt-spacing-100) var(--salt-spacing-200);
-  background-color: rgba(var(--salt-palette-interact-error-background), .05);
-  border-radius: var(--salt-size-borderRadius);
+  background-color: var(--salt-status-error-background);
+  border-radius: var(--salt-palette-corner);
   text-align: left;
   overflow-y: auto;
 }
@@ -33,9 +33,9 @@ const css = `
 }
 
 .vuuCsvUpload-errorItem {
-  font-size: var(--salt-text-fontSize-small);
-  color: var(--salt-status-error-foreground);
-  line-height: var(--salt-text-lineHeight-small);
+  font-size: var(--salt-text-label-fontSize);
+  color: var(--salt-status-error-foreground-informative);
+  line-height: var(--salt-text-label-lineHeight);
   word-break: break-word;
   margin-bottom: var(--salt-spacing-50);
 }
@@ -50,8 +50,8 @@ const css = `
 
 .vuuCsvUpload-errors {
   border: solid 1px var(--salt-status-error-borderColor);
-  border-radius: var(--salt-size-borderRadius);
-  color: var(--salt-status-error-foreground);
+  border-radius: var(--salt-palette-corner);
+  color: var(--salt-status-error-foreground-informative);
   gap: var(--salt-spacing-100);
   padding: var(--salt-spacing-200);
   display: grid;

package/src/csv-upload/parse/csv-upload-utils.js

@@ -1,4 +1,4 @@
-import { isRpcError } from "@vuu-ui/vuu-utils";
+import { isRpcError, metadataKeys } from "@vuu-ui/vuu-utils";
 import { CSV_FIRST_DATA_ROW_NUMBER } from "./csv-constants.js";
 const isRecord = (value)=>"object" == typeof value && null !== value;
 const toErrorMessage = (error)=>error instanceof Error ? error.message : String(error);
@@ -56,4 +56,49 @@ const executeBatchRpcCalls = async (items, executor, errorFormatter)=>{
         results
     };
 };
-export { buildRowErrorMessage, createUploadError, executeBatchRpcCalls, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, normalizeTableData, toErrorMessage, toValidationErrorsFromParseRowErrors };
+const getInlineRowErrorMessage = (result)=>{
+    if (isRecord(result) && "data" in result && isRecord(result.data)) {
+        const data = result.data;
+        const msg = data.vuuMsg ?? data.msg;
+        if ("string" == typeof msg && "" !== msg.trim()) return msg.trim();
+    }
+};
+const getRowVuuMsgError = (row, vuuMsgDataIndex, vuuRowNumDataIndex)=>{
+    if (-1 === vuuMsgDataIndex) return;
+    const msg = Array.isArray(row) ? row[vuuMsgDataIndex] : row?.vuuMsg;
+    if ("string" == typeof msg && "" !== msg.trim()) {
+        const rowNum = -1 !== vuuRowNumDataIndex && void 0 !== row[vuuRowNumDataIndex] ? Number(row[vuuRowNumDataIndex]) : Number(row[metadataKeys.IDX]) + CSV_FIRST_DATA_ROW_NUMBER;
+        return {
+            rowNum,
+            message: msg.trim()
+        };
+    }
+};
+const waitForSessionErrors = (isRemote, sessionErrors, receivedRowKeys, expectedRowCount, listeners, timeoutMs = 500)=>{
+    if (sessionErrors.size > 0 || !isRemote) return Promise.resolve([
+        ...sessionErrors.values()
+    ]);
+    return new Promise((resolve)=>{
+        let timeoutId;
+        const onUpdate = ()=>{
+            if (sessionErrors.size > 0 || receivedRowKeys.size >= expectedRowCount) {
+                cleanup();
+                resolve([
+                    ...sessionErrors.values()
+                ]);
+            }
+        };
+        const cleanup = ()=>{
+            clearTimeout(timeoutId);
+            listeners.delete(onUpdate);
+        };
+        listeners.add(onUpdate);
+        timeoutId = setTimeout(()=>{
+            cleanup();
+            resolve([
+                ...sessionErrors.values()
+            ]);
+        }, timeoutMs);
+    });
+};
+export { buildRowErrorMessage, createUploadError, executeBatchRpcCalls, getInlineRowErrorMessage, getRowVuuMsgError, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, normalizeTableData, toErrorMessage, toValidationErrorsFromParseRowErrors, waitForSessionErrors };

package/src/csv-upload/session/index.js

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

package/src/csv-upload/session/useImportSchema.js

@@ -0,0 +1,44 @@
+import { useData } from "@vuu-ui/vuu-utils";
+import { useEffect, useMemo, useState } from "react";
+const useImportSchema = ({ dataSource, importSchema, importTable })=>{
+    const { getServerAPI } = useData();
+    const [fetchedImportSchema, setFetchedImportSchema] = useState();
+    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("[useImportSchema] failed to fetch import table schema", error);
+            }
+        })();
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        getServerAPI,
+        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 schema = importTable ? resolvedImportSchema : resolvedImportSchema ?? dataSource.tableSchema;
+    return {
+        resolvedImportSchema,
+        schema,
+        sessionOverrides
+    };
+};
+export { useImportSchema };

package/src/csv-upload/session/useImportSession.js

@@ -0,0 +1,204 @@
+import { EditSession } from "@vuu-ui/vuu-data-editing";
+import { Range, buildColumnMap, isRpcError, isSessionTable, metadataKeys } from "@vuu-ui/vuu-utils";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { buildRowErrorMessage, getInlineRowErrorMessage, getRowVuuMsgError, toErrorMessage, waitForSessionErrors } from "../parse/csv-upload-utils.js";
+import { CSV_FIRST_DATA_ROW_NUMBER } from "../parse/csv-constants.js";
+const useImportSession = ({ dataSource, sessionOverrides, rowDefaults, processingPromiseRef, onImportSessionEnded })=>{
+    const sessionErrorsRef = useRef(new Map());
+    const receivedRowKeysRef = useRef(new Set());
+    const sessionRowUpdateListenersRef = useRef(new Set());
+    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");
+                const columnMap = buildColumnMap(sessionDs.columns);
+                const vuuMsgDataIndex = columnMap.vuuMsg ?? -1;
+                const vuuRowNumDataIndex = columnMap.vuuRowNum ?? -1;
+                const handleSessionMessage = (message)=>{
+                    if ("viewport-update" === message.type && message.rows) {
+                        for (const row of message.rows){
+                            const rowKey = row[metadataKeys.KEY] ?? row[metadataKeys.IDX];
+                            receivedRowKeysRef.current.add(rowKey);
+                            const error = getRowVuuMsgError(row, vuuMsgDataIndex, vuuRowNumDataIndex);
+                            if (error) sessionErrorsRef.current.set(rowKey, error);
+                        }
+                        for (const listener of sessionRowUpdateListenersRef.current)listener();
+                    } else if ("viewport-clear" === message.type) {
+                        sessionErrorsRef.current.clear();
+                        receivedRowKeysRef.current.clear();
+                    }
+                };
+                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)
+                        }, handleSessionMessage);
+                    } catch (err) {
+                        sessionDs.removeListener("subscribed", handleSubscribed);
+                        reject(err);
+                    }
+                });
+                if ("function" == typeof sessionDs.subscribe && "initialising" === sessionDs.status) try {
+                    sessionDs.subscribe({
+                        range: Range(0, 0)
+                    }, handleSessionMessage);
+                } catch  {}
+                return sessionDs;
+            }
+        }), [
+        dataSource,
+        sessionOverrides
+    ]);
+    const editSession = useMemo(()=>new EditSession({
+            dataSource: importDataSource,
+            editSessionApi: "createSessionDataSource",
+            rowDefaults
+        }), [
+        importDataSource,
+        rowDefaults
+    ]);
+    const ownsEditSessionRef = useRef(true);
+    const sessionDataSourceRef = useRef(void 0);
+    const [sessionTable, setSessionTable] = useState();
+    useEffect(()=>()=>{
+            const processingPromise = processingPromiseRef?.current;
+            (async ()=>{
+                try {
+                    await processingPromise;
+                } finally{
+                    if (ownsEditSessionRef.current) try {
+                        const sessionDs = sessionDataSourceRef.current ?? editSession.sessionDataSource;
+                        if (sessionDs?.status !== "unsubscribed") await editSession.end(false);
+                    } catch (error) {
+                        console.error("[useCsvUpload] failed to discard edit session during cleanup", error);
+                    }
+                }
+            })();
+        }, [
+        editSession,
+        processingPromiseRef
+    ]);
+    const setActiveSessionDataSource = useCallback((sessionDataSource)=>{
+        sessionDataSourceRef.current = sessionDataSource;
+        const table = sessionDataSource?.table;
+        setSessionTable(table && isSessionTable(table) ? table : void 0);
+    }, []);
+    const endEditSessionAndNotify = useCallback(async (save, reason)=>{
+        ownsEditSessionRef.current = false;
+        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
+    ]);
+    const beginEditSession = useCallback(async ()=>{
+        sessionErrorsRef.current.clear();
+        receivedRowKeysRef.current.clear();
+        ownsEditSessionRef.current = true;
+        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 releaseEditSessionOwnership = useCallback(()=>{
+        ownsEditSessionRef.current = false;
+    }, []);
+    const addAllRows = useCallback(async (mergedValidation, isCancelled)=>{
+        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 (isCancelled()) 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);
+                const inlineMsg = getInlineRowErrorMessage(result);
+                if (inlineMsg) sessionErrorsRef.current.set(rowNum, {
+                    rowNum,
+                    message: inlineMsg
+                });
+            } catch (error) {
+                rpcErrors.push(`${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${toErrorMessage(error)}`);
+            }
+        }
+        if (rpcErrors.length > 0) throw Error(buildRowErrorMessage("Import failed", rpcErrors));
+        return allRows.length;
+    }, [
+        editSession
+    ]);
+    const checkSessionTableErrors = useCallback(async (sessionDs, expectedRowCount)=>waitForSessionErrors(sessionDs.isRemote ?? false, sessionErrorsRef.current, receivedRowKeysRef.current, expectedRowCount, sessionRowUpdateListenersRef.current), []);
+    return {
+        addAllRows,
+        beginEditSession,
+        checkSessionTableErrors,
+        closePendingEditSession,
+        editSession,
+        endEditSessionAndNotify,
+        releaseEditSessionOwnership,
+        sessionDataSourceRef,
+        sessionTable,
+        setActiveSessionDataSource
+    };
+};
+export { useImportSession };