@vuu-ui/vuu-utils 3.0.0 → 3.1.0-beta.2

package/src/promise-utils.js

@@ -0,0 +1,26 @@
+class DeferredPromise {
+    #promise;
+    #resolve = ()=>console.log("resolve was not set");
+    #reject = ()=>console.log("reject was not set");
+    #resolved = false;
+    constructor(){
+        this.#promise = new Promise((resolve, reject)=>{
+            this.#resolve = resolve;
+            this.#reject = reject;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    get isResolved() {
+        return this.#resolved;
+    }
+    resolve(value) {
+        this.#resolved = true;
+        return this.#resolve(value);
+    }
+    get reject() {
+        return this.#reject;
+    }
+}
+export { DeferredPromise };

package/src/protocol-message-utils.js

@@ -0,0 +1,71 @@
+import { isView } from "./component-registry.js";
+const MENU_RPC_TYPES = [
+    "VIEW_PORT_MENUS_SELECT_RPC",
+    "VIEW_PORT_MENU_TABLE_RPC",
+    "VIEW_PORT_MENU_ROW_RPC",
+    "VIEW_PORT_MENU_CELL_RPC"
+];
+const INVALID_SESSION = "Invalid session";
+const SESSION_LIMIT_EXCEEDED = "User session limit exceeded";
+const INVALID_TOKEN = "Invalid token";
+const TOKEN_EXPIRED = "Token has expired";
+const InvalidLoginMessages = [
+    INVALID_SESSION,
+    SESSION_LIMIT_EXCEEDED,
+    INVALID_TOKEN,
+    TOKEN_EXPIRED
+];
+const isErrorMessage = (message)=>"object" == typeof message && message?.type === "ERROR";
+const isLoginErrorMessage = (message)=>"string" == typeof message && InvalidLoginMessages.includes(message);
+const isSelectRequest = (message)=>message && "object" == typeof message && "type" in message && ("SELECT_ROW" === message.type || "DESELECT_ROW" === message.type || "SELECT_ROW_RANGE" === message.type || "SELECT_ALL" === message.type || "DESELECT_ALL" === message.type);
+const isSelectSuccessWithRowCount = (response)=>[
+        "SELECT_ROW_SUCCESS",
+        "DESELECT_ROW_SUCCESS",
+        "SELECT_ROW_RANGE_SUCCESS",
+        "SELECT_ALL_SUCCESS",
+        "DESELECT_ALL_SUCCESS"
+    ].includes(response.type ?? "") && "number" == typeof response.selectedRowCount;
+const isRpcServiceRequest = (message)=>"RPC_REQUEST" === message.type;
+const hasViewPortContext = (message)=>"VIEWPORT_CONTEXT" === message.context.type;
+const isVuuMenuRpcRequest = (message)=>MENU_RPC_TYPES.includes(message["type"]);
+const isLoginResponse = (message)=>null !== message && "object" == typeof message && "type" in message && ("LOGIN_SUCCESS" === message.type || "LOGIN_FAIL" === message.type);
+const isRpcSuccess = (rpcResult)=>rpcResult?.type === "SUCCESS_RESULT";
+const isRpcError = (rpcResult)=>rpcResult?.type === "ERROR_RESULT";
+const isRequestResponse = (message)=>"requestId" in message;
+const isOpenSessionTableDialogMessage = (rpcResponse)=>"VIEW_PORT_MENU_RESP" === rpcResponse.type && isOpenDialogAction(rpcResponse.action) && "tableSchema" in rpcResponse.action;
+const isOpenDialogAction = (action)=>void 0 !== action && "OPEN_DIALOG_ACTION" === action.type;
+const isTypeaheadRequest = (request)=>isRpcServiceRequest(request) && ("getUniqueFieldValues" === request.rpcName || "getUniqueFieldValuesStartingWith" === request.rpcName);
+const isCreateVpSuccess = (response)=>"CREATE_VP_SUCCESS" === response.type;
+const isSessionTable = (table)=>{
+    if (null !== table && "object" == typeof table && "table" in table && "module" in table) return table.table.startsWith("session");
+    return false;
+};
+function isActionMessage(rpcResponse) {
+    return "VIEW_PORT_MENU_RESP" === rpcResponse.type;
+}
+function isSessionTableActionMessage(rpcResponse) {
+    return isActionMessage(rpcResponse) && isOpenDialogAction(rpcResponse.action) && isSessionTable(rpcResponse.action.table) && (rpcResponse.action?.renderComponent === "inline-form" || rpcResponse.action?.renderComponent === "grid");
+}
+function isCustomComponentActionMessage(rpcResponse) {
+    return isActionMessage(rpcResponse) && isOpenDialogAction(rpcResponse.action) && isSessionTable(rpcResponse.action.table) && "string" == typeof rpcResponse.action.renderComponent && isView(rpcResponse.action.renderComponent);
+}
+const numericTypes = [
+    "int",
+    "long",
+    "double",
+    "scaleddecimal2",
+    "scaleddecimal4",
+    "scaleddecimal6",
+    "scaleddecimal8"
+];
+function isNumericType(dataType) {
+    return numericTypes.includes(dataType);
+}
+const isAddRowRpcRequest = (rpcRequest)=>"addRow" === rpcRequest.rpcName;
+const isEditCellRpcRequest = (rpcRequest)=>"editCell" === rpcRequest.rpcName;
+const isBeginEditSessionRpcRequest = (rpcRequest)=>"beginEditSession" === rpcRequest.rpcName;
+const isEndEditSessionRpcRequest = (rpcRequest)=>"endEditSession" === rpcRequest.rpcName;
+const isUndoRowChangeRpcRequest = (rpcRequest)=>"undoRowChange" === rpcRequest.rpcName;
+const isDeleteSelectedRowsRpcRequest = (rpcRequest)=>"deleteSelectedRows" === rpcRequest.rpcName;
+const isCreateSessionTableRpcRequest = (rpcRequest)=>"createSessionTable" === rpcRequest.rpcName;
+export { INVALID_SESSION, INVALID_TOKEN, SESSION_LIMIT_EXCEEDED, TOKEN_EXPIRED, hasViewPortContext, isActionMessage, isAddRowRpcRequest, isBeginEditSessionRpcRequest, isCreateSessionTableRpcRequest, isCreateVpSuccess, isCustomComponentActionMessage, isDeleteSelectedRowsRpcRequest, isEditCellRpcRequest, isEndEditSessionRpcRequest, isErrorMessage, isLoginErrorMessage, isLoginResponse, isNumericType, isOpenDialogAction, isOpenSessionTableDialogMessage, isRequestResponse, isRpcError, isRpcServiceRequest, isRpcSuccess, isSelectRequest, isSelectSuccessWithRowCount, isSessionTable, isSessionTableActionMessage, isTypeaheadRequest, isUndoRowChangeRpcRequest, isVuuMenuRpcRequest };

package/src/range-utils.js

@@ -0,0 +1,125 @@
+class RangeImpl {
+    from;
+    to;
+    #baseFrom;
+    #renderBufferSize = 0;
+    #baseTo;
+    constructor(from, to, renderBufferSize = 0){
+        this.from = from;
+        this.to = to;
+        this.#baseFrom = from;
+        this.#baseTo = to;
+        this.#renderBufferSize = renderBufferSize;
+    }
+    get reset() {
+        return new RangeImpl(0, this.#baseTo - this.#baseFrom, this.#renderBufferSize);
+    }
+    get withBuffer() {
+        return getFullRange(this, this.#renderBufferSize);
+    }
+    equals(range) {
+        return range.from === this.#baseFrom && range.to === this.#baseTo;
+    }
+    toJson() {
+        return {
+            from: this.from,
+            to: this.to,
+            baseFrom: this.#baseFrom,
+            baseTo: this.#baseTo,
+            renderBufferSize: this.#renderBufferSize
+        };
+    }
+}
+const Range = (from, to, renderBufferSize)=>new RangeImpl(from, to, renderBufferSize);
+const NULL_RANGE = Range(0, 0);
+function getFullRange({ from, to }, bufferSize = 0, maxRangeEnd = Number.MAX_SAFE_INTEGER) {
+    if (0 === from && 0 === to) return {
+        from,
+        to
+    };
+    if (0 === bufferSize) if (maxRangeEnd < from) return {
+        from: 0,
+        to: 0
+    };
+    else return {
+        from,
+        to: Math.min(to, maxRangeEnd)
+    };
+    {
+        if (0 === from) return {
+            from,
+            to: Math.min(to + bufferSize, maxRangeEnd)
+        };
+        const shortfallBefore = from - bufferSize < 0;
+        const shortfallAfter = maxRangeEnd - (to + bufferSize) < 0;
+        if (shortfallBefore && shortfallAfter) return {
+            from: 0,
+            to: maxRangeEnd
+        };
+        if (shortfallBefore) return {
+            from: 0,
+            to: to + bufferSize
+        };
+        if (shortfallAfter) return {
+            from: Math.max(0, from - bufferSize),
+            to: maxRangeEnd
+        };
+        else return {
+            from: from - bufferSize,
+            to: to + bufferSize
+        };
+    }
+}
+const withinRange = (value, { from, to })=>value >= from && value < to;
+const rangeNewItems = ({ from: from1, to: to1 }, newRange)=>{
+    const { from: from2, to: to2 } = newRange;
+    const noOverlap = from2 >= to1 || to2 <= from1;
+    const newFullySubsumesOld = from2 < from1 && to2 > to1;
+    return noOverlap || newFullySubsumesOld ? newRange : to2 > to1 ? {
+        from: to1,
+        to: to2
+    } : {
+        from: from2,
+        to: from1
+    };
+};
+class WindowRange {
+    from;
+    to;
+    constructor(from, to){
+        this.from = from;
+        this.to = to;
+    }
+    isWithin(index) {
+        return withinRange(index, this);
+    }
+    overlap(from, to) {
+        return from >= this.to || to < this.from ? [
+            0,
+            0
+        ] : [
+            Math.max(from, this.from),
+            Math.min(to, this.to)
+        ];
+    }
+    copy() {
+        return new WindowRange(this.from, this.to);
+    }
+}
+const constrainRangeWidth = (range, maxRangeWidth = Number.MAX_SAFE_INTEGER)=>{
+    if (range.to - range.from < maxRangeWidth) return range;
+    console.warn(`[range-utils] range ${range.from} - ${range.to} exceeds maxRangeWidth ${maxRangeWidth} for this table `);
+    return {
+        from: range.from,
+        to: range.from + maxRangeWidth
+    };
+};
+const constrainRange = (range, maxRangeEnd, maxRangeWidth)=>{
+    if (!(maxRangeEnd > 0) || !(maxRangeEnd < range.to)) return constrainRangeWidth(range, maxRangeWidth);
+    if (maxRangeEnd > range.from) return constrainRangeWidth({
+        from: range.from,
+        to: maxRangeEnd
+    }, maxRangeWidth);
+    throw Error(`constrainRange: cannot apply the maxRangeEnd ${maxRangeEnd} to range ${range.from} - ${range.to}`);
+};
+export { NULL_RANGE, Range, WindowRange, constrainRange, getFullRange, rangeNewItems, withinRange };

package/src/react-utils.js

@@ -0,0 +1,64 @@
+import { Children, isValidElement, useEffect, useMemo, useRef } from "react";
+const EMPTY_ARRAY = [];
+const asReactElements = (children)=>{
+    const isArray = Array.isArray(children);
+    const count = isArray ? children.length : Children.count(children);
+    if (isArray && children.every(isValidElement)) return children;
+    if (1 === count && !isArray && isValidElement(children)) return [
+        children
+    ];
+    if (count > 1) return children;
+    return EMPTY_ARRAY;
+};
+const useIsMounted = (id = "")=>{
+    const isMountedRef = useRef(false);
+    useEffect(()=>{
+        console.log(`is MOUNTED ${id}`);
+        isMountedRef.current = true;
+        return ()=>{
+            console.log(`is UNMOUNTED ${id}`);
+            isMountedRef.current = false;
+        };
+    }, [
+        id
+    ]);
+    return isMountedRef;
+};
+const isSimpleStateValue = (arg)=>"function" != typeof arg;
+const createSyntheticEvent = (event)=>{
+    let isDefaultPrevented = false;
+    let isPropagationStopped = false;
+    const preventDefault = ()=>{
+        isDefaultPrevented = true;
+        event.preventDefault();
+    };
+    const stopPropagation = ()=>{
+        isPropagationStopped = true;
+        event.stopPropagation();
+    };
+    return {
+        nativeEvent: event,
+        currentTarget: event.currentTarget,
+        target: event.target,
+        bubbles: event.bubbles,
+        cancelable: event.cancelable,
+        defaultPrevented: event.defaultPrevented,
+        eventPhase: event.eventPhase,
+        isTrusted: event.isTrusted,
+        preventDefault,
+        isDefaultPrevented: ()=>isDefaultPrevented,
+        stopPropagation,
+        isPropagationStopped: ()=>isPropagationStopped,
+        persist: ()=>void 0,
+        timeStamp: event.timeStamp,
+        type: event.type
+    };
+};
+const useStableReference = (value)=>{
+    const referenceToProp = useRef(value);
+    useMemo(()=>referenceToProp.current = value, [
+        value
+    ]);
+    return referenceToProp;
+};
+export { asReactElements, createSyntheticEvent, isSimpleStateValue, useIsMounted, useStableReference };

package/src/round-decimal.js

@@ -0,0 +1,83 @@
+const PUNCTUATION_STR = String.fromCharCode(8200);
+const DIGIT_STR = String.fromCharCode(8199);
+const DECIMALS_AUTO = -1;
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER.toString();
+const MAX_INTEGER_DIGITS = MAX_SAFE_INTEGER.length;
+const exceedsMaxSafeInteger = (value)=>value.length > MAX_INTEGER_DIGITS || value.length === MAX_INTEGER_DIGITS && value > MAX_SAFE_INTEGER;
+const Space = {
+    DIGIT: DIGIT_STR,
+    TWO_DIGITS: DIGIT_STR + DIGIT_STR,
+    THREE_DIGITS: DIGIT_STR + DIGIT_STR + DIGIT_STR,
+    FULL_PADDING: [
+        null,
+        PUNCTUATION_STR + DIGIT_STR,
+        PUNCTUATION_STR + DIGIT_STR + DIGIT_STR,
+        PUNCTUATION_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR,
+        PUNCTUATION_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR
+    ]
+};
+const Zero = {
+    DIGIT: "0",
+    TWO_DIGITS: "00",
+    THREE_DIGITS: "000",
+    FULL_PADDING: [
+        null,
+        "0",
+        "00",
+        "000",
+        "0000"
+    ]
+};
+function padLeft(value, maxLength = 6) {
+    return (LEADING_FILL + value).slice(-maxLength);
+}
+const LEADING_FILL = DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR;
+const Align = {
+    Right: "right",
+    Center: "center",
+    Left: "left"
+};
+function pad(n, dp, Pad) {
+    let len = n.length;
+    const diff = dp - len;
+    if (diff > 0) {
+        if (1 === diff) n += Pad.DIGIT;
+        else if (2 === diff) n += Pad.TWO_DIGITS;
+        else if (3 === diff) n += Pad.THREE_DIGITS;
+    } else {
+        if (diff < 0) {
+            n = n.slice(0, dp);
+            len = dp;
+        }
+        if (Pad === Space && "0" === n.charAt(len - 1)) {
+            n = n.replace(/0+$/, "");
+            return pad(n, dp, Pad);
+        }
+    }
+    return n;
+}
+function roundDecimal(value, align = Align.Right, decimals = 4, zeroPad, alignOnDecimals, useLocaleString = true, roundingRule = "round") {
+    if (void 0 === value || "number" != typeof value || isNaN(value)) return "";
+    let integral;
+    let fraction;
+    let Pad;
+    const [part1, part2 = ""] = value.toString().split(".");
+    const actualDecimals = part2.length;
+    integral = "-0" === part1 ? "-0" : useLocaleString ? parseFloat(part1).toLocaleString() : parseFloat(part1).toString();
+    if (align === Align.Left && alignOnDecimals) integral = padLeft(integral);
+    fraction = decimals === DECIMALS_AUTO || actualDecimals === decimals ? part2 : actualDecimals > decimals ? "round" === roundingRule ? parseFloat("0." + part2).toFixed(decimals).slice(2) : part2.slice(0, decimals) : (Pad = zeroPad ? Zero : alignOnDecimals && align !== Align.Left ? Space : null) ? 0 === actualDecimals ? Pad.FULL_PADDING[decimals] ?? "" : pad(part2, decimals, Pad) : part2;
+    return integral + (fraction ? "." + fraction : "");
+}
+function roundScaledDecimal(value, align = Align.Right, decimals = 4, zeroPad, alignOnDecimals, useLocaleString = true, roundingRule = "round") {
+    let integral;
+    let fraction;
+    let Pad;
+    if ("" === value) return "";
+    const [part1, part2 = ""] = value.split(".");
+    const actualDecimals = part2.length;
+    integral = "" === part1 ? "0" : "-0" === part1 ? "-0" : useLocaleString ? exceedsMaxSafeInteger(value) ? BigInt(part1).toLocaleString() : parseFloat(part1).toLocaleString() : part1;
+    if (align === Align.Left && alignOnDecimals) integral = padLeft(integral);
+    fraction = decimals === DECIMALS_AUTO || actualDecimals === decimals ? part2 : actualDecimals > decimals ? "round" === roundingRule ? parseFloat("0." + part2).toFixed(decimals).slice(2) : part2.slice(0, decimals) : (Pad = zeroPad ? Zero : alignOnDecimals && align !== Align.Left ? Space : null) ? 0 === actualDecimals ? Pad.FULL_PADDING[decimals] ?? "" : pad(part2, decimals, Pad) : part2;
+    return integral + (fraction ? "." + fraction : "");
+}
+export { exceedsMaxSafeInteger, roundDecimal, roundScaledDecimal };

package/src/row-utils.js

@@ -0,0 +1,43 @@
+import { metadataKeys } from "./column-utils.js";
+const { IS_LEAF: IS_LEAF, KEY: KEY, IDX: IDX, SELECTED: SELECTED } = metadataKeys;
+const actualRowPositioning = (rowHeight)=>[
+        (dataRow)=>dataRow.index * rowHeight,
+        (position)=>Math.floor(position / rowHeight),
+        false
+    ];
+const virtualRowPositioning = (rowHeight, virtualisedExtent, pctScrollTop)=>[
+        (dataRow, offset = 0)=>{
+            const rowOffset = pctScrollTop.current * virtualisedExtent;
+            return (dataRow.index - offset) * rowHeight - rowOffset;
+        },
+        (position)=>{
+            const rowOffset = pctScrollTop.current * virtualisedExtent;
+            return Math.round((position + rowOffset) / rowHeight);
+        },
+        true
+    ];
+const asDataSourceRowObject = (row, columnMap)=>{
+    const { [IS_LEAF]: isLeaf, [KEY]: key, [IDX]: index } = row;
+    const rowObject = {
+        key,
+        index,
+        isGroupRow: !isLeaf,
+        isSelected: 0 !== row[SELECTED],
+        data: {}
+    };
+    for (const [colName, colIdx] of Object.entries(columnMap))rowObject.data[colName] = row[colIdx];
+    return rowObject;
+};
+const vuuRowToDataSourceRow = ({ rowIndex, rowKey, sel: isSelected = 0, ts, data }, keys)=>[
+        rowIndex,
+        keys.keyFor(rowIndex),
+        true,
+        false,
+        0,
+        0,
+        rowKey,
+        isSelected,
+        ts,
+        false
+    ].concat(data);
+export { actualRowPositioning, asDataSourceRowObject, virtualRowPositioning, vuuRowToDataSourceRow };

package/src/selection-utils.js

@@ -0,0 +1,50 @@
+const deselectItem = (selectionModel, rowKey, rangeSelect, preserveExistingSelection = false)=>({
+        preserveExistingSelection,
+        rowKey,
+        type: "DESELECT_ROW"
+    });
+const selectItem = (selectionModel, rowKey, rangeSelect, preserveExistingSelection = false, activeRowKey)=>{
+    const singleSelect = "single" === selectionModel || "single-no-deselect" === selectionModel;
+    const actsLikeSingleSelect = singleSelect || void 0 === activeRowKey;
+    if ("none" === selectionModel) return;
+    if (actsLikeSingleSelect) {
+        const preserveSelection = singleSelect ? false : preserveExistingSelection;
+        return {
+            preserveExistingSelection: preserveSelection,
+            rowKey,
+            type: "SELECT_ROW"
+        };
+    }
+    if (rangeSelect) return {
+        preserveExistingSelection,
+        fromRowKey: rowKey,
+        toRowKey: activeRowKey,
+        type: "SELECT_ROW_RANGE"
+    };
+};
+const splitSelectableRanges = (rows, isRowSelectable, preserveExistingSelection)=>{
+    const requests = [];
+    let fromKey;
+    let toKey;
+    for (const row of rows)if (isRowSelectable(row)) {
+        if (!fromKey) fromKey = row.key;
+        toKey = row.key;
+    } else if (fromKey && toKey) {
+        requests.push({
+            type: "SELECT_ROW_RANGE",
+            fromRowKey: fromKey,
+            toRowKey: toKey,
+            preserveExistingSelection: requests.length > 0 ? true : preserveExistingSelection
+        });
+        fromKey = void 0;
+        toKey = void 0;
+    }
+    if (fromKey && toKey) requests.push({
+        type: "SELECT_ROW_RANGE",
+        fromRowKey: fromKey,
+        toRowKey: toKey,
+        preserveExistingSelection: requests.length > 0 ? true : preserveExistingSelection
+    });
+    return requests;
+};
+export { deselectItem, selectItem, splitSelectableRanges };

package/src/shell-layout-types.js

@@ -0,0 +1,9 @@
+const VuuShellLocation = {
+    ContextPanel: "context-panel",
+    MultiWorkspaceContainer: "vuu-multi-workspace-container",
+    SidePanel: "vuu-side-panel",
+    SideToolbar: "vuu-side-toolbar",
+    Workspace: "vuu-workspace",
+    WorkspaceContainer: "vuu-workspace-container"
+};
+export { VuuShellLocation };

package/src/sort-utils.js

@@ -0,0 +1,75 @@
+const cycleSortType = (sortType)=>"A" === sortType ? "D" : "D" === sortType ? void 0 : "A";
+const NO_SORT = {
+    sortDefs: []
+};
+const toggleOrApplySort = ({ sortDefs }, { name: column }, extendSort = false, sortType)=>{
+    if (extendSort) {
+        const existingDef = sortDefs.find((sortDef)=>sortDef.column === column);
+        if (existingDef) return {
+            sortDefs: sortDefs.map((sortDef)=>sortDef.column === column ? {
+                    column,
+                    sortType: "A" === sortDef.sortType ? "D" : "A"
+                } : sortDef)
+        };
+        return {
+            sortDefs: sortDefs.concat({
+                column,
+                sortType: sortType ?? "A"
+            })
+        };
+    }
+    const newSortType = "string" == typeof sortType ? sortType : 1 === sortDefs.length && sortDefs[0].column === column ? cycleSortType(sortDefs[0].sortType) : "A";
+    return newSortType ? {
+        sortDefs: [
+            {
+                column,
+                sortType: newSortType
+            }
+        ]
+    } : NO_SORT;
+};
+const setSortColumn = ({ sortDefs }, column, sortType)=>{
+    if (void 0 === sortType) {
+        const columnSort = sortDefs.find((item)=>item.column === column.name);
+        if (columnSort) return {
+            sortDefs: [
+                {
+                    column: column.name,
+                    sortType: "A" === columnSort.sortType ? "D" : "A"
+                }
+            ]
+        };
+    }
+    return {
+        sortDefs: [
+            {
+                column: column.name,
+                sortType: sortType ?? "A"
+            }
+        ]
+    };
+};
+const addSortColumn = ({ sortDefs }, column, sortType = "A")=>{
+    const sortEntry = {
+        column: column.name,
+        sortType
+    };
+    if (sortDefs.length > 0) return {
+        sortDefs: sortDefs.concat(sortEntry)
+    };
+    return {
+        sortDefs: [
+            sortEntry
+        ]
+    };
+};
+const getSortStatus = (columnName, vuuSort)=>{
+    if (void 0 === vuuSort || 0 === vuuSort.sortDefs.length) return "no-sort";
+    {
+        const sortDef = vuuSort.sortDefs.find((sd)=>sd.column === columnName);
+        if (!sortDef) return "sort-other-column";
+        if (1 === vuuSort.sortDefs.length) return "A" === sortDef.sortType ? "single-sort-asc" : "single-sort-desc";
+        return "A" === sortDef.sortType ? "multi-sort-includes-column-asc" : "multi-sort-includes-column-desc";
+    }
+};
+export { addSortColumn, getSortStatus, setSortColumn, toggleOrApplySort };

package/src/table-schema-utils.js

@@ -0,0 +1,16 @@
+const toSchemaColumn = ({ editable, name, serverDataType = "string" })=>({
+        editable: "boolean" == typeof editable ? editable : void 0,
+        name,
+        serverDataType
+    });
+const getVuuTable = (schemaTable)=>{
+    if (!schemaTable.session) return schemaTable;
+    {
+        const { module, session } = schemaTable;
+        return {
+            module,
+            table: session
+        };
+    }
+};
+export { getVuuTable, toSchemaColumn };

package/src/text-utils.js

@@ -0,0 +1,15 @@
+const lastWord = (text)=>{
+    const trimmedText = text.trim();
+    const pos = trimmedText.lastIndexOf(" ");
+    if (-1 === pos) return trimmedText;
+    return trimmedText.slice(pos + 1);
+};
+const capitalize = (text)=>0 === text.length ? "" : text[0].toUpperCase() + text.slice(1);
+const singularForm = (typeName)=>"string" == typeof typeName ? typeName : typeName.singular;
+const pluralForm = (typeName)=>"string" == typeof typeName ? `${typeName}s` : typeName.plural;
+const regexp_worfify = /(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])/;
+const wordify = (text)=>{
+    const [firstWord, ...rest] = text.split(regexp_worfify);
+    return `${capitalize(firstWord)} ${rest.join(" ")}`;
+};
+export { capitalize, lastWord, pluralForm, singularForm, wordify };

package/src/theme-utils.js

@@ -0,0 +1,21 @@
+import { useMemo, useState } from "react";
+const checkCssToken = (tokenName)=>new Promise((resolve)=>{
+        requestAnimationFrame(()=>{
+            const saltSpacing100 = getComputedStyle(document.documentElement).getPropertyValue(tokenName);
+            resolve("" !== saltSpacing100);
+        });
+    });
+const ThemeLoadChecker = ({ children, cssToken = "--salt-spacing-100", theme })=>{
+    const [ready, setReady] = useState(false);
+    useMemo(async ()=>{
+        let ready = await checkCssToken(cssToken);
+        while(!ready)ready = await checkCssToken(cssToken);
+        setReady(true);
+    }, [
+        cssToken
+    ]);
+    if ("no-theme" === theme) return children;
+    if (false === ready) return null;
+    return children;
+};
+export { ThemeLoadChecker };