@vuu-ui/vuu-utils 2.1.19-beta.2 → 2.1.19-beta.4

package/src/common-types.js

@@ -1,11 +0,0 @@
-const MEASURES = {
-    horizontal: {
-        positionProp: "left",
-        sizeProp: "width"
-    },
-    vertical: {
-        positionProp: "top",
-        sizeProp: "height"
-    }
-};
-export { MEASURES };

package/src/component-registry.js

@@ -1,83 +0,0 @@
-import { hasCustomRenderer, isColumnTypeRenderer, isTypeDescriptor } from "./column-utils.js";
-const containersSet = new Set();
-const viewsSet = new Set();
-const layoutComponentsMap = new Map();
-const cellRenderersMap = new Map();
-const columnHeaderRenderersMap = new Map();
-const configEditorsMap = new Map();
-const cellConfigPanelsMap = new Map();
-const editRuleValidatorsMap = new Map();
-const optionsMap = new Map();
-const rowClassGeneratorsMap = new Map();
-const isTypeCompatible = (rendererType, serverDataType)=>{
-    if (void 0 === rendererType || "private" === rendererType) return true;
-    if (!Array.isArray(rendererType)) return rendererType === serverDataType;
-    if ("json" === serverDataType) return false;
-    return rendererType.includes(serverDataType);
-};
-const isContainer = (componentType)=>containersSet.has(componentType);
-const isView = (componentType)=>viewsSet.has(componentType);
-const isLayoutComponent = (componentType)=>isContainer(componentType) || isView(componentType);
-const isCellRenderer = (type, component)=>void 0 !== component && "cell-renderer" === type;
-const isColumnHeaderContentRenderer = (type, component)=>"column-header-content-renderer" === type;
-const isColumnHeaderLabelRenderer = (type, component)=>"column-header-label-renderer" === type;
-const isCellConfigPanel = (type, component)=>"cell-config-panel" === type;
-const isEditRuleValidator = (type, component)=>"data-edit-validator" === type;
-const isRowClassGenerator = (type, component)=>"row-class-generator" === type;
-function registerComponent(componentName, component, componentType, options) {
-    if ("container" === componentType || "view" === componentType || "component" === componentType) {
-        layoutComponentsMap.set(componentName, component);
-        if ("container" === componentType) containersSet.add(componentName);
-        else if ("view" === componentType) viewsSet.add(componentName);
-    } else if (isCellRenderer(componentType, component)) cellRenderersMap.set(componentName, component);
-    else if (isColumnHeaderContentRenderer(componentType, component)) columnHeaderRenderersMap.set(componentName, component);
-    else if (isColumnHeaderLabelRenderer(componentType, component)) columnHeaderRenderersMap.set(componentName, component);
-    else if (isCellConfigPanel(componentType, component)) cellConfigPanelsMap.set(componentName, component);
-    else if (isEditRuleValidator(componentType, component)) editRuleValidatorsMap.set(componentName, component);
-    else if (isRowClassGenerator(componentType, component)) rowClassGeneratorsMap.set(componentName, component);
-    if (options) optionsMap.set(componentName, options);
-}
-const registerConfigurationEditor = (componentName, configurationEditor)=>{
-    configEditorsMap.set(componentName, configurationEditor);
-};
-const getRegisteredCellRenderers = (cellRendererDataType)=>{
-    const rendererNames = Array.from(cellRenderersMap.keys());
-    const allRenderers = rendererNames.map((name)=>({
-            name,
-            ...optionsMap.get(name)
-        })).filter(({ userCanAssign })=>false !== userCanAssign);
-    if (cellRendererDataType) return allRenderers.filter((renderer)=>isTypeCompatible(renderer.serverDataType, cellRendererDataType));
-    return allRenderers;
-};
-const getLayoutComponent = (componentName)=>{
-    const layoutComponent = layoutComponentsMap.get(componentName);
-    if (layoutComponent) return layoutComponent;
-    throw Error(`layout component ${componentName} not found in ComponentRegistry`);
-};
-const getCellRendererOptions = (renderName)=>optionsMap.get(renderName);
-function getCellRenderer(column) {
-    return dataCellRenderer(column);
-}
-function getColumnHeaderContentRenderer(column) {
-    if (column.colHeaderContentRenderer) return columnHeaderRenderersMap.get(column.colHeaderContentRenderer);
-}
-function getColumnHeaderLabelRenderer(column) {
-    if (column.colHeaderLabelRenderer) return columnHeaderRenderersMap.get(column.colHeaderLabelRenderer);
-}
-const getRowClassNameGenerator = (generatorId)=>rowClassGeneratorsMap.get(generatorId);
-function getConfigurationEditor(configEditor = "") {
-    return configEditorsMap.get(configEditor);
-}
-function getCellConfigPanelRenderer(name) {
-    return cellConfigPanelsMap.get(name);
-}
-function getEditRuleValidator(name) {
-    return editRuleValidatorsMap.get(name);
-}
-function dataCellRenderer(column) {
-    if ("boolean" === column.serverDataType && !hasCustomRenderer(column.type)) return cellRenderersMap.get("checkbox-cell");
-    if (column.editable && !hasCustomRenderer(column.type)) return cellRenderersMap.get("input-cell");
-    if (isTypeDescriptor(column.type) && isColumnTypeRenderer(column.type.renderer)) return cellRenderersMap.get(column.type.renderer?.name);
-    if ("boolean" === column.serverDataType) return cellRenderersMap.get("checkbox-cell");
-}
-export { getCellConfigPanelRenderer, getCellRenderer, getCellRendererOptions, getColumnHeaderContentRenderer, getColumnHeaderLabelRenderer, getConfigurationEditor, getEditRuleValidator, getLayoutComponent, getRegisteredCellRenderers, getRowClassNameGenerator, isContainer, isLayoutComponent, isView, registerComponent, registerConfigurationEditor };

package/src/context-definitions/DataContext.js

@@ -1,15 +0,0 @@
-import { createContext } from "react";
-const getServerAPI = ()=>{
-    throw Error("no DataProvider has been installed");
-};
-class NullDataSourceConstructor {
-    constructor(_){
-        throw Error("no DataProvider has been installed");
-    }
-}
-const DataContext = /*#__PURE__*/ createContext({
-    isLocalData: false,
-    getServerAPI: getServerAPI,
-    VuuDataSource: NullDataSourceConstructor
-});
-export { DataContext, NullDataSourceConstructor };

package/src/context-definitions/DataProvider.js

@@ -1,13 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { useContext } from "react";
-import { DataContext } from "./DataContext.js";
-const DataProvider = ({ children, getServerAPI, isLocalData = true, VuuDataSource })=>/*#__PURE__*/ jsx(DataContext.Provider, {
-        value: {
-            isLocalData,
-            VuuDataSource,
-            getServerAPI
-        },
-        children: children
-    });
-const useData = ()=>useContext(DataContext);
-export { DataProvider, useData };

package/src/context-definitions/DataSourceProvider.js

@@ -1,18 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { createContext, useContext } from "react";
-const DataSourceContext = /*#__PURE__*/ createContext({
-    dataSource: void 0
-});
-const DataSourceProvider = ({ children, dataSource })=>/*#__PURE__*/ jsx(DataSourceContext.Provider, {
-        value: {
-            dataSource
-        },
-        children: children
-    });
-function useDataSource(throwIfNoDataSource = false) {
-    const { dataSource } = useContext(DataSourceContext);
-    if (dataSource) return dataSource;
-    if (throwIfNoDataSource) throw Error("[DataSOurceProvider] useDataSource,no DataSourceProvider has been declared ");
-    console.warn("[DataSourceProvider] useDataSource: no DataSourceProvider has been declared");
-}
-export { DataSourceContext, DataSourceProvider, useDataSource };

package/src/context-definitions/WorkspaceContext.js

@@ -1,14 +0,0 @@
-import react, { useContext } from "react";
-const WorkspaceContext = /*#__PURE__*/ react.createContext({
-    getApplicationSettings: ()=>void 0,
-    layoutMetadata: [],
-    saveLayout: ()=>void 0,
-    saveApplicationLayout: ()=>void 0,
-    saveApplicationSettings: ()=>void 0,
-    loadLayoutById: ()=>void 0
-});
-const usePlaceholderJSON = ()=>{
-    const { layoutPlaceholderJSON } = useContext(WorkspaceContext);
-    return layoutPlaceholderJSON;
-};
-export { WorkspaceContext, usePlaceholderJSON };

package/src/cookie-utils.js

@@ -1,15 +0,0 @@
-const getCookieValue = (name)=>{
-    if (globalThis.document?.cookie !== void 0) return globalThis.document.cookie.split("; ").find((row)=>row.startsWith(`${name}=`))?.split("=")[1];
-};
-function setCookieValue(name, value, days) {
-    let expires = "";
-    if ("number" == typeof days) {
-        const date = new Date();
-        date.setTime(date.getTime() + 24 * days * 3600000);
-        expires = "; expires=" + date.toUTCString();
-    }
-    const encodedName = encodeURIComponent(name);
-    const encodedValue = encodeURIComponent(value);
-    document.cookie = `${encodedName}=${encodedValue}${expires};`;
-}
-export { getCookieValue, setCookieValue };

package/src/css-utils.js

@@ -1,5 +0,0 @@
-const importCSS = async (path)=>{
-    const container = new CSSStyleSheet();
-    return fetch(path).then((x)=>x.text()).then((x)=>container.replace(x));
-};
-export { importCSS };

package/src/data-editing/DataEditingProvider.js

@@ -1,13 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { createContext, useContext } from "react";
-const DataEditingContext = /*#__PURE__*/ createContext(void 0);
-const DataEditingProvider = ({ children, editSession })=>/*#__PURE__*/ jsx(DataEditingContext.Provider, {
-        value: editSession,
-        children: children
-    });
-function useEditSession(throwIfUnavailable = false) {
-    const editSession = useContext(DataEditingContext);
-    if (void 0 !== editSession) return editSession;
-    if (throwIfUnavailable) throw Error("[useEditSession] no DataEditingContext in scope. You need to enclose editable component(s) with DataEditingProvider");
-}
-export { DataEditingProvider, useEditSession };

package/src/data-editing/EditButtons.js

@@ -1,32 +0,0 @@
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { Button } from "@salt-ds/core";
-import { useCallback, useMemo, useState } from "react";
-const EditButtons = ({ editSession, onCancel, onSave })=>{
-    const [editState, setEditState] = useState("clean");
-    const handleSave = useCallback(()=>{
-        onSave("stale" === editState);
-    }, [
-        editState,
-        onSave
-    ]);
-    useMemo(()=>{
-        editSession?.on("editState", setEditState);
-    }, [
-        editSession
-    ]);
-    return /*#__PURE__*/ jsxs(Fragment, {
-        children: [
-            /*#__PURE__*/ jsx(Button, {
-                disabled: "clean" === editState || "invalid" === editState,
-                onClick: handleSave,
-                sentiment: "accented",
-                children: "stale" === editState ? "Save (force)" : "Save"
-            }),
-            /*#__PURE__*/ jsx(Button, {
-                onClick: onCancel,
-                children: "Cancel"
-            })
-        ]
-    });
-};
-export { EditButtons };

package/src/data-editing/EditModeProvider.js

@@ -1,18 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState } from "react";
-const EditModeContext = /*#__PURE__*/ createContext({
-    isEditMode: false,
-    setEditMode: ()=>"EditModeProvider in place"
-});
-const EditModeProvider = ({ children })=>{
-    const [isEditMode, setEditMode] = useState(false);
-    return /*#__PURE__*/ jsx(EditModeContext.Provider, {
-        value: {
-            isEditMode,
-            setEditMode
-        },
-        children: children
-    });
-};
-const useEditMode = ()=>useContext(EditModeContext);
-export { EditModeProvider, useEditMode };

package/src/data-editing/EditSession.js

@@ -1,149 +0,0 @@
-import { EventEmitter } from "../event-emitter.js";
-import { isRpcError } from "../protocol-message-utils.js";
-class EditError extends Error {
-}
-class StaleUpdateError extends Error {
-}
-class EditSession extends EventEmitter {
-    #rowEdits = new Map();
-    #editCount = 0;
-    #invalidCount = 0;
-    #sourceTableDataSource;
-    #sessionDataSource;
-    #inEditMode = false;
-    constructor(dataSource){
-        super();
-        this.#sourceTableDataSource = dataSource;
-    }
-    get editCount() {
-        return this.#editCount;
-    }
-    set editCount(val) {
-        if (val !== this.#editCount) {
-            const oldCount = this.#editCount;
-            this.#editCount = val;
-            if (0 === val) this.emit("editState", "clean");
-            else if (0 === oldCount) this.emit("editState", "dirty");
-        }
-    }
-    get invalidCount() {
-        return this.#invalidCount;
-    }
-    set invalidCount(val) {
-        if (val !== this.#invalidCount) {
-            const oldCount = this.#invalidCount;
-            this.#invalidCount = val;
-            if (0 === val) this.emit("editState", 0 === this.#editCount ? "clean" : "dirty");
-            else if (0 === oldCount) this.emit("editState", "invalid");
-        }
-    }
-    clear() {
-        this.#rowEdits.clear();
-        this.#editCount = 0;
-        this.#inEditMode = false;
-    }
-    async begin(editSessionMode) {
-        try {
-            this.#inEditMode = true;
-            const sessionDataSource = await this.#sourceTableDataSource?.beginEditSession?.(editSessionMode);
-            this.#sessionDataSource = sessionDataSource;
-            return sessionDataSource;
-        } catch (e) {
-            this.#inEditMode = false;
-        }
-    }
-    get dataSource() {
-        return this.#sessionDataSource ?? this.#sourceTableDataSource;
-    }
-    async end(saveChanges = false, force = false) {
-        try {
-            if (this.#inEditMode) {
-                await this.dataSource?.endEditSession?.(saveChanges, force);
-                this.clear();
-            }
-        } catch (e) {
-            if (e instanceof StaleUpdateError) this.emit("editState", "stale");
-            else console.error(`[EditSession] ${e.message}`);
-        }
-    }
-    get inEditMode() {
-        return this.#inEditMode;
-    }
-    get editState() {
-        return 0 === this.editCount ? "clean" : "dirty";
-    }
-    getOrCreateRowEdits(key) {
-        const rowEditDetails = this.#rowEdits.get(key);
-        if (rowEditDetails) return rowEditDetails;
-        {
-            const rowEditDetails = {
-                cellEdits: new Map()
-            };
-            this.#rowEdits.set(key, rowEditDetails);
-            return rowEditDetails;
-        }
-    }
-    storeCellEdit(cellEdits, column, originalValue, editedValue, isValid) {
-        const cellEdit = cellEdits.get(column);
-        if (cellEdit) {
-            if (cellEdit.originalValue === editedValue) {
-                cellEdits.delete(column);
-                cellEdit.isDeleted = true;
-                if (cellEdit.isValid) this.editCount -= 1;
-                else this.invalidCount -= 1;
-            } else if (isValid && false === cellEdit.isValid) {
-                cellEdit.isValid = true;
-                cellEdit.editedValue = editedValue;
-                this.#invalidCount -= 1;
-                this.editCount += 1;
-            }
-            return cellEdit;
-        }
-        {
-            const cellEdit = {
-                originalValue,
-                editedValue,
-                isValid
-            };
-            cellEdits.set(column, cellEdit);
-            if (isValid) this.editCount += 1;
-            return cellEdit;
-        }
-    }
-    async commit(key, columnName, originalValue, typedValue, isValid) {
-        if (!this.#inEditMode) throw new Error("No edit session in progress");
-        const rowEditDetails = this.getOrCreateRowEdits(key);
-        if (isValid) {
-            const { cellEdits } = rowEditDetails;
-            const cellEdit = this.storeCellEdit(cellEdits, columnName, originalValue, typedValue, isValid);
-            if (cellEdit.isDeleted) {
-                if (0 === rowEditDetails.cellEdits.size) this.#rowEdits.delete(key);
-            }
-            if (this.dataSource?.editCell) {
-                const response = await this.dataSource.editCell(key, columnName, typedValue);
-                if (isRpcError(response)) {
-                    cellEdit.isValid = false;
-                    this.invalidCount += 1;
-                }
-                return {
-                    editedDuringCurrentSession: cellEdit.originalValue !== typedValue,
-                    ...response
-                };
-            }
-        } else {
-            const { cellEdits } = rowEditDetails;
-            let cellEdit = cellEdits.get(columnName);
-            if (cellEdit && false !== cellEdit.isValid) {
-                cellEdit.isValid = false;
-                this.invalidCount += 1;
-            } else if (void 0 === cellEdit) {
-                cellEdit = this.storeCellEdit(cellEdits, columnName, originalValue, typedValue, isValid);
-                this.invalidCount += 1;
-            }
-            return {
-                editedDuringCurrentSession: false
-            };
-        }
-    }
-}
-export { EditError, EditSession, StaleUpdateError };

package/src/data-editing/edit-utils.js

@@ -1,37 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { formatDate } from "../date/index.js";
-const isInlineEditingSession = (editSessionMode)=>editSessionMode.startsWith("inline");
-const timeFormatter = formatDate({
-    time: "hh:mm:ss"
-});
-const getVuuEditMessage = (dataRow, column, originalValue)=>{
-    const vuuMsg = dataRow.vuuMsg;
-    if ("string" == typeof vuuMsg && "" !== vuuMsg) {
-        const columnMessages = vuuMsg.split(",");
-        const msgForCol = columnMessages.find((msg)=>msg.startsWith(`${column.name}:`));
-        if (msgForCol) {
-            const [, value, updatedValue, ts] = msgForCol.split(":");
-            const updateTime = timeFormatter(new Date(parseInt(ts)));
-            return /*#__PURE__*/ jsxs("span", {
-                children: [
-                    "Update rejected. Original value ",
-                    /*#__PURE__*/ jsx("b", {
-                        children: originalValue
-                    }),
-                    " could not be updated to ",
-                    /*#__PURE__*/ jsx("b", {
-                        children: value
-                    }),
-                    ". It was updated to ",
-                    /*#__PURE__*/ jsx("b", {
-                        children: updatedValue
-                    }),
-                    " at ",
-                    updateTime,
-                    "."
-                ]
-            });
-        }
-    }
-};
-export { getVuuEditMessage, isInlineEditingSession };

package/src/data-editing/useEditableTable.js

@@ -1,76 +0,0 @@
-import { useCallback, useMemo, useState } from "react";
-import { useData } from "../context-definitions/DataProvider.js";
-import { useLayoutEffectSkipFirst } from "../useLayoutEffectSkipFirst.js";
-import { EditSession } from "./EditSession.js";
-const useEditableTable = ({ columns, dataSource: dataSourceProp, editSessionMode = "inline-all-rows", isEditMode, onCancel, onSave, table })=>{
-    const { VuuDataSource } = useData();
-    const [sessionDataSource, setSessionDataSource] = useState(void 0);
-    useLayoutEffectSkipFirst(()=>{
-        console.warn("[useEditableTable] columns and or table changed");
-    }, [
-        columns,
-        table
-    ]);
-    const dataSource = useMemo(()=>{
-        if (dataSourceProp) return dataSourceProp;
-        if (table) return new VuuDataSource({
-            columns,
-            table
-        });
-        throw Error("useEditableTable unable to provide DataSource, neither dataSource nor table available as props");
-    }, [
-        VuuDataSource,
-        columns,
-        dataSourceProp,
-        table
-    ]);
-    const editSession = useMemo(()=>new EditSession(dataSource), [
-        dataSource
-    ]);
-    const handleCancel = useCallback(()=>{
-        try {
-            editSession.end();
-            onCancel();
-        } catch (e) {}
-    }, [
-        editSession,
-        onCancel
-    ]);
-    const handleSave = useCallback(async (force = false)=>{
-        dataSource.resume?.();
-        try {
-            await editSession.end(true, force);
-            if (false === editSession.inEditMode) onSave();
-        } catch (e) {
-            console.log(`[useEditableTable] handleSave ${e.message}`);
-        }
-    }, [
-        dataSource,
-        editSession,
-        onSave
-    ]);
-    useMemo(async ()=>{
-        console.log(`[useEditableTable] editMode ${isEditMode}`);
-        if (isEditMode) try {
-            const sessionDataSource = await editSession.begin(editSessionMode);
-            if (sessionDataSource) setSessionDataSource(sessionDataSource);
-        } catch (e) {
-            console.error(e);
-            onCancel();
-        }
-        else await editSession.end();
-    }, [
-        editSession,
-        editSessionMode,
-        isEditMode,
-        onCancel
-    ]);
-    return {
-        dataSource,
-        editSession,
-        onCancel: handleCancel,
-        onSave: handleSave,
-        sessionDataSource
-    };
-};
-export { useEditableTable };

package/src/data-utils.js

@@ -1,55 +0,0 @@
-const UP1 = "up1";
-const UP2 = "up2";
-const DOWN1 = "down1";
-const DOWN2 = "down2";
-const decimalPattern = /^-?[0-9]*\.[0-9]*$/;
-const stringIsValidInt = (val)=>parseInt(val, 10).toString() === val;
-const stringIsValidDecimal = (val)=>stringIsValidInt(val) || decimalPattern.test(val);
-const stringIsValidNumber = (val)=>stringIsValidInt(val) || stringIsValidDecimal(val);
-const numericTypeOfStringValue = (val)=>stringIsValidInt(val) ? "int" : stringIsValidDecimal(val) ? "double" : "NaN";
-const isValidNumber = (n)=>"number" == typeof n && isFinite(n);
-const EMPTY = {};
-const shallowEquals = (o1 = EMPTY, o2 = EMPTY)=>{
-    const props1 = Object.keys(o1);
-    const props2 = Object.keys(o2);
-    return props1.length === props2.length && props1.every((key)=>o1[key] === o2[key]);
-};
-function getMovingValueDirection(newValue, direction, prevValue, decimalPlaces) {
-    if (void 0 === newValue) return "";
-    if (!isFinite(newValue) || void 0 === prevValue || void 0 === direction) return "";
-    {
-        let diff = newValue - prevValue;
-        if (diff) {
-            if ("number" == typeof decimalPlaces) diff = newValue.toFixed(decimalPlaces) - prevValue.toFixed(decimalPlaces);
-        }
-        if (!diff) return "";
-        if ("" === direction) if (diff < 0) return DOWN1;
-        else return UP1;
-        if (diff > 0) if (direction === DOWN1 || direction === DOWN2 || direction === UP2) return UP1;
-        else return UP2;
-        else if (direction === UP1 || direction === UP2 || direction === DOWN2) return DOWN1;
-        else return DOWN2;
-    }
-}
-function asInteger(value, defaultValue) {
-    if ("number" == typeof value) return Number.isInteger(value) ? value : value < 0 ? Math.ceil(value) : Math.floor(value);
-    {
-        const integerValue = parseInt(value ?? "");
-        if (!isNaN(integerValue)) return integerValue;
-        if ("number" == typeof defaultValue) return defaultValue;
-        throw Error(`parseIndex invalid value ${value}`);
-    }
-}
-const dataDescriptorTypeToVuuRowDataItemType = ({ serverDataType = "string" })=>{
-    switch(serverDataType){
-        case "double":
-        case "int":
-        case "long":
-            return "number";
-        case "boolean":
-            return "boolean";
-        default:
-            return "string";
-    }
-};
-export { DOWN1, DOWN2, UP1, UP2, asInteger, dataDescriptorTypeToVuuRowDataItemType, getMovingValueDirection, isValidNumber, numericTypeOfStringValue, shallowEquals, stringIsValidDecimal, stringIsValidInt, stringIsValidNumber };