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

package/src/form-utils.js

@@ -0,0 +1,71 @@
+import { stringIsValidDecimal, stringIsValidInt, stringIsValidLong } from "./data-utils.js";
+import { Time, isValidTimeString } from "./date/index.js";
+import { queryClosest } from "./html-utils.js";
+import { ScaledDecimal2, ScaledDecimal4, ScaledDecimal6, ScaledDecimal8 } from "./ScaledDecimal.js";
+class DataValidationError extends Error {
+    actualType;
+    expectedType;
+    constructor(message, expectedType, actualType){
+        super(message);
+        this.actualType = actualType;
+        this.expectedType = expectedType;
+    }
+}
+const getFieldName = (target)=>{
+    const saltFormField = queryClosest(target, "[data-field]");
+    const fieldName = saltFormField?.dataset.field;
+    if (fieldName) return fieldName;
+    throw Error("named form field not found");
+};
+const isNumber = (type, value)=>"number" === type;
+const isValidRange = ([val1, val2])=>{
+    if (isValidTimeString(val1) && isValidTimeString(val2)) return val2 > val1;
+    return true;
+};
+function getTypedRange([value1, value2], dataType, options) {
+    return [
+        getTypedValue(value1, dataType, false, options),
+        getTypedValue(value2, dataType, false, options)
+    ];
+}
+const getActualType = (value)=>{
+    if ("boolean" == typeof value) return "boolean";
+    if ("number" == typeof value) return "number";
+    return "string";
+};
+function getTypedValue(value, type, throwIfInvalid = false, options) {
+    switch(type){
+        case "int":
+            if (stringIsValidInt(value)) return parseInt(value, 10);
+            if (!throwIfInvalid) return;
+            throw Error(`value ${value} is not a valid ${type}`);
+        case "long":
+            if (stringIsValidLong(value)) return BigInt(value);
+            if (!throwIfInvalid) return;
+            throw Error(`value ${value} is not a valid ${type}`);
+        case "scaleddecimal2":
+            return ScaledDecimal2(value);
+        case "scaleddecimal4":
+            return ScaledDecimal4(value);
+        case "scaleddecimal6":
+            return ScaledDecimal6(value);
+        case "scaleddecimal8":
+            return ScaledDecimal8(value);
+        case "double":
+        case "number":
+            if (stringIsValidDecimal(value)) return parseFloat(value);
+            if (!throwIfInvalid) return;
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "decimal", getActualType(value));
+        case "boolean":
+            return "true" === value;
+        case "time":
+            if (isValidTimeString(value)) if (options?.type === "TimeString") return value;
+            else return +Time(value).asDate();
+            if (value.length > 0 && Time.isDateInMillis(value)) return Number(value);
+            if (!throwIfInvalid) return;
+            else throw Error(`value ${value} is not a valid ${type}`);
+        default:
+            return value;
+    }
+}
+export { DataValidationError, getFieldName, getTypedRange, getTypedValue, isNumber, isValidRange };

package/src/formatting-utils.js

@@ -0,0 +1,58 @@
+import { isDateTimeDataValue, isMappedValueTypeRenderer, isNanoTimestampColumn, isTimeDataValue, isTypeDescriptor } from "./column-utils.js";
+import { dateTimePattern, formatDate } from "./date/index.js";
+import { roundDecimal, roundScaledDecimal } from "./round-decimal.js";
+import { isNumericType } from "./protocol-message-utils.js";
+const DEFAULT_NUMERIC_FORMAT = {};
+const defaultValueFormatter = (value)=>null == value ? "" : "string" == typeof value ? value : value.toString();
+const dateFormatter = (column)=>{
+    if (isNanoTimestampColumn(column)) {
+        const pattern = dateTimePattern(column.type);
+        const formatter = formatDate(pattern);
+        return (value)=>{
+            if ("string" != typeof value || "" === value) return "";
+            {
+                const bigIntValue = BigInt(value);
+                const dateTimeValue = Number(bigIntValue / 1000000n);
+                const nanoSeconds = (bigIntValue % 1000000n).toString().padStart(9, "0");
+                return `${formatter(new Date(dateTimeValue))}.${nanoSeconds}`;
+            }
+        };
+    }
+    {
+        const pattern = dateTimePattern(column.type);
+        const formatter = formatDate(pattern);
+        return (value)=>{
+            if ("number" == typeof value && 0 !== value) return formatter(new Date(value));
+            return "";
+        };
+    }
+};
+const numericFormatter = ({ align = "right", serverDataType, type })=>{
+    if (void 0 === type || "string" == typeof type) return defaultValueFormatter;
+    {
+        const { alignOnDecimals = false, decimals, roundingRule, useLocaleString, zeroPad = false } = type.formatting ?? DEFAULT_NUMERIC_FORMAT;
+        return (value)=>{
+            if (serverDataType?.startsWith("scaleddecimal")) if ("string" == typeof value) return roundScaledDecimal(value, align, decimals, zeroPad, alignOnDecimals, useLocaleString, roundingRule);
+            else throw Error(`[formatting-utils] numericFormatter, invalid data for ${serverDataType}: '${value}'`);
+            if ("string" == typeof value && (value.startsWith("Σ") || value.startsWith("["))) return value;
+            const number = "number" == typeof value ? value : "string" == typeof value ? parseFloat(value) : void 0;
+            return roundDecimal(number, align, decimals, zeroPad, alignOnDecimals, useLocaleString, roundingRule);
+        };
+    }
+};
+const mapFormatter = (map)=>(value)=>map[value] ?? "";
+const NumericTypes = [
+    "decimal",
+    "number"
+];
+const getValueFormatter = (column)=>{
+    const { serverDataType = "string" } = column;
+    if (isDateTimeDataValue(column) || isTimeDataValue(column)) return dateFormatter(column);
+    const { type } = column;
+    if (isTypeDescriptor(type) && isMappedValueTypeRenderer(type?.renderer)) return mapFormatter(type.renderer.map);
+    if (isNumericType(serverDataType) || isTypeDescriptor(type) && NumericTypes.includes(type.name)) return numericFormatter(column);
+    if ("string" === serverDataType || "char" === serverDataType) return (value)=>value;
+    return defaultValueFormatter;
+};
+const lowerCase = (str)=>str.toLowerCase();
+export { defaultValueFormatter, getValueFormatter, lowerCase, numericFormatter };

package/src/getUniqueId.js

@@ -0,0 +1,2 @@
+const getUniqueId = ()=>`hw-${Math.round(1e5 * Math.random())}`;
+export { getUniqueId };

package/src/group-utils.js

@@ -0,0 +1,16 @@
+function addGroupColumn(groupBy, column) {
+    if (groupBy.length > 0) return groupBy.concat(column.name);
+    return [
+        column.name
+    ];
+}
+const removeGroupColumn = (groupBy, column)=>groupBy.filter((colName)=>colName !== column.name);
+const getGroupStatus = (columnName, groupBy)=>{
+    if (void 0 === groupBy || 0 === groupBy.length) return "no-groupby";
+    {
+        const indexPos = groupBy.indexOf(columnName);
+        if (-1 === indexPos) return 1 === groupBy.length ? "single-groupby-other-column" : "multi-groupby-other-columns";
+        return 1 === groupBy.length ? "single-groupby" : "single-groupby-other-column";
+    }
+};
+export { addGroupColumn, getGroupStatus, removeGroupColumn };

package/src/html-utils.js

@@ -0,0 +1,108 @@
+const createEl = (elementType, className, textContent)=>{
+    const el = document.createElement(elementType);
+    if (className) el.className = className;
+    if (textContent) el.textContent = textContent;
+    return el;
+};
+const getFocusableElement = (el, tabIndex)=>{
+    if (el) {
+        if (el.hasAttribute("tabindex")) {
+            const rootTabIndex = parseInt(el.getAttribute("tabindex"));
+            if (!isNaN(rootTabIndex) && (void 0 === tabIndex || rootTabIndex === tabIndex)) return el;
+        }
+        const focusableEl = "number" == typeof tabIndex ? el.querySelector(`[tabindex="${tabIndex}"]`) : el.querySelector("[tabindex]");
+        if (focusableEl) return focusableEl;
+    }
+};
+const getElementDataIndex = (el)=>{
+    if (el) {
+        const index = parseInt(el.dataset.index || "");
+        if (!isNaN(index)) return index;
+    }
+    return -1;
+};
+function queryClosest(el, cssQueryString, throwIfNotFound) {
+    if (el) {
+        const result = el.closest(cssQueryString);
+        if (result) return result;
+    }
+    if (!throwIfNotFound) return null;
+    throw Error(`no element found to match '${cssQueryString}'`);
+}
+const getClosest = (el, dataProperty)=>queryClosest(el, `[data-${dataProperty}]`);
+const getClosestIndexItem = (el)=>getClosest(el, "index");
+function getElementByDataIndex(container, index, throwIfNotFound = false) {
+    if (null == container && throwIfNotFound) throw Error("html-utils getElementByDataIndex, container is null");
+    const element = container?.querySelector(`[data-index="${index}"]`);
+    if (element) return element;
+    if (!throwIfNotFound) return;
+    throw Error("html-utils getElementByDataIndex, Item not found with data-index='${index}'");
+}
+const focusFirstFocusableElement = (el, tabIndex)=>{
+    requestAnimationFrame(()=>{
+        const focusableElement = getFocusableElement(el, tabIndex);
+        if (focusableElement) focusableElement.focus();
+    });
+};
+const isSelectableElement = (el)=>{
+    const item = el?.closest("[data-index]");
+    if (!item || item.ariaDisabled || "false" === item.dataset.selectable || item.querySelector('[data-selectable="false"],[aria-disabled="true"]')) return false;
+    return true;
+};
+const isInputElement = (el)=>{
+    if (null === el) return false;
+    return "INPUT" === el.tagName;
+};
+const isDateInput = (el)=>isInputElement(el) && el.classList.contains("saltDateInput-input");
+const hasOpenOptionList = (el)=>{
+    if (null !== el) return "true" === el.ariaExpanded;
+};
+let size;
+function getScrollbarSize() {
+    if (void 0 === size) {
+        let outer = document.createElement("div");
+        outer.className = "scrollable-content";
+        outer.style.width = "50px";
+        outer.style.height = "50px";
+        outer.style.overflowY = "scroll";
+        outer.style.position = "absolute";
+        outer.style.top = "-200px";
+        outer.style.left = "-200px";
+        const inner = document.createElement("div");
+        inner.style.height = "100px";
+        inner.style.width = "100%";
+        outer.appendChild(inner);
+        document.body.appendChild(outer);
+        const outerWidth = outer.offsetWidth;
+        const innerWidth = inner.offsetWidth;
+        document.body.removeChild(outer);
+        size = outerWidth - innerWidth;
+        outer = null;
+    }
+    return size;
+}
+const dispatchMouseEvent = (el, type)=>{
+    const evt = new MouseEvent(type, {
+        view: window,
+        bubbles: true,
+        cancelable: true
+    });
+    el.dispatchEvent(evt);
+};
+const dispatchKeyboardEvent = (el, type, key)=>{
+    const evt = new KeyboardEvent(type, {
+        key,
+        view: window,
+        bubbles: true,
+        cancelable: true
+    });
+    el.dispatchEvent(evt);
+};
+const dispatchCustomEvent = (el, type)=>{
+    const evt = new Event(type, {
+        bubbles: true,
+        cancelable: true
+    });
+    el.dispatchEvent(evt);
+};
+export { createEl, dispatchCustomEvent, dispatchKeyboardEvent, dispatchMouseEvent, focusFirstFocusableElement, getClosest, getClosestIndexItem, getElementByDataIndex, getElementDataIndex, getFocusableElement, getScrollbarSize, hasOpenOptionList, isDateInput, isInputElement, isSelectableElement, queryClosest };

package/src/index.js

@@ -0,0 +1,74 @@
+export * from "./array-utils.js";
+export * from "./box-utils.js";
+export * from "./broadcast-channel.js";
+export * from "./column-utils.js";
+export * from "./common-types.js";
+export * from "./component-registry.js";
+export * from "./cookie-utils.js";
+export * from "./css-utils.js";
+export * from "./data-utils.js";
+export * from "./datasource/BaseDataSource.js";
+export * from "./datasource/datasource-action-utils.js";
+export * from "./datasource/datasource-filter-utils.js";
+export * from "./datasource/datasource-utils.js";
+export * from "./date/index.js";
+export * from "./debug-utils.js";
+export * from "./event-emitter.js";
+export * from "./feature-utils.js";
+export * from "./filters/index.js";
+export * from "./form-utils.js";
+export * from "./formatting-utils.js";
+export * from "./getUniqueId.js";
+export * from "./group-utils.js";
+export * from "./html-utils.js";
+export * from "./input-utils.js";
+export * from "./invariant.js";
+export * from "./itemToString.js";
+export * from "./json-types.js";
+export * from "./json-utils.js";
+export * from "./keyboard-utils.js";
+export * from "./keyset.js";
+export * from "./layout-types.js";
+export * from "./list-utils.js";
+export * from "./local-storage-utils.js";
+export * from "./logging-utils.js";
+export * from "./module-utils.js";
+export * from "./nanoid/index.js";
+export * from "./perf-utils.js";
+export * from "./promise-utils.js";
+export * from "./protocol-message-utils.js";
+export * from "./range-utils.js";
+export * from "./react-utils.js";
+export * from "./round-decimal.js";
+export * from "./row-utils.js";
+export * from "./ScaledDecimal.js";
+export * from "./selection-utils.js";
+export * from "./shell-layout-types.js";
+export * from "./sort-utils.js";
+export * from "./table-schema-utils.js";
+export * from "./text-utils.js";
+export * from "./ThemeProvider.js";
+export * from "./tree-types.js";
+export * from "./tree-utils.js";
+export * from "./ts-utils.js";
+export * from "./typeahead-utils.js";
+export * from "./url-utils.js";
+export * from "./useId.js";
+export * from "./useLayoutEffectSkipFirst.js";
+export * from "./user-types.js";
+export * from "./useStateRef.js";
+export * from "./context-definitions/DataProvider.js";
+export * from "./context-definitions/WorkspaceContext.js";
+export * from "./ShellContext.js";
+export { RestrictToHorizontalAxis } from "@dnd-kit/abstract/modifiers";
+export { KeyboardSensor, PointerSensor } from "@dnd-kit/dom";
+export { DragDropProvider, DragOverlay, useInstance } from "@dnd-kit/react";
+export { useSortable } from "@dnd-kit/react/sortable";
+export { Clock } from "./Clock.js";
+export { isInlineEditingSession } from "./edit-utils.js";
+export { StaleUpdateError } from "./errors.js";
+export { WidthHeight, WidthOnly, useResizeObserver } from "./useResizeObserver.js";
+export { DataContext } from "./context-definitions/DataContext.js";
+export { DataSourceProvider, useDataSource } from "./context-definitions/DataSourceProvider.js";
+export { PageVisibilityObserver } from "./PageVisibilityObserver.js";
+export { ThemeLoadChecker } from "./theme-utils.js";

package/src/input-utils.js

@@ -0,0 +1,3 @@
+const isCharacterKey = (key)=>1 === key.length;
+const isQuoteKey = (evt)=>'"' === evt.key || "'" === evt.key;
+export { isCharacterKey, isQuoteKey };

package/src/invariant.js

@@ -0,0 +1,9 @@
+function invariant(condition, message) {
+    if (!condition) {
+        const error = new Error(message);
+        error.name = "Invariant Violation";
+        error.framesToPop = 1;
+        throw error;
+    }
+}
+export { invariant };

package/src/itemToString.js

@@ -0,0 +1,9 @@
+const isPlainObject = (obj)=>"[object Object]" === Object.prototype.toString.call(obj);
+function itemToString(item) {
+    if ("string" == typeof item) return item;
+    if (!isPlainObject(item)) return String(item);
+    if (Object.prototype.hasOwnProperty.call(item, "label")) return String(item.label);
+    console.warn("itemToString: you've likely forgotten to set the label prop on the item object.\nYou can also provide your own `itemToString` implementation.");
+    return "";
+}
+export { itemToString };

package/src/json-utils.js

@@ -0,0 +1,108 @@
+import { metadataKeys } from "./column-utils.js";
+const { COUNT: COUNT } = metadataKeys;
+const isJsonData = (value)=>"object" == typeof value && null !== value;
+const vuuRowDataItemTypes = [
+    "boolean",
+    "number",
+    "string"
+];
+const isVuuRowDataItem = (value)=>vuuRowDataItemTypes.includes(typeof value);
+const getCellValue = (attribute, attributeValue)=>{
+    if (Array.isArray(attributeValue)) return {
+        attribute: `${attribute}[`,
+        attributeValue: "",
+        isLeaf: false
+    };
+    if (isJsonData(attributeValue)) return {
+        attribute: `${attribute}{`,
+        attributeValue: "",
+        isLeaf: false
+    };
+    if (void 0 === attributeValue) return {
+        attribute,
+        attributeValue: "undefined",
+        isLeaf: true
+    };
+    if (isVuuRowDataItem(attributeValue)) return {
+        attribute,
+        attributeValue,
+        isLeaf: true
+    };
+    throw Error(`unsupported type ${typeof attributeValue} in JSON`);
+};
+const jsonColumnType = {
+    name: "json",
+    renderer: {
+        name: "json"
+    }
+};
+const jsonToDataSourceRows = (json)=>{
+    const cols = [];
+    cols.push({
+        className: "vuuJsonCell",
+        name: "Level 1",
+        type: jsonColumnType
+    }, {
+        className: "vuuJsonCell",
+        name: "Level 2",
+        type: jsonColumnType
+    });
+    const rows = [];
+    addChildValues(rows, json, cols);
+    return [
+        cols,
+        rows
+    ];
+};
+const addChildValues = (rows, json, cols, index = {
+    value: 0
+}, keyBase = "$root", depth = 0)=>{
+    let leafCount = 0;
+    let rowCount = 0;
+    if (depth === cols.length - 1) cols.push({
+        className: "vuuJsonCell",
+        name: `Level ${cols.length + 1}`,
+        hidden: true,
+        type: jsonColumnType
+    });
+    const columnEntries = Object.entries(json);
+    for(let i = 0; i < columnEntries.length; i++, index.value += 1){
+        const [key, value] = columnEntries[i];
+        const { attribute, attributeValue, isLeaf } = getCellValue(key, value);
+        const blanks = Array(depth).fill("");
+        const fullKey = `${keyBase}|${key}`;
+        const ts = 0;
+        const isNew = false;
+        const row = [
+            index.value,
+            index.value,
+            isLeaf,
+            false,
+            depth,
+            0,
+            fullKey,
+            0,
+            ts,
+            isNew,
+            ...blanks,
+            attribute,
+            attributeValue
+        ];
+        rows.push(row);
+        rowCount += 1;
+        if (isJsonData(value)) {
+            const [nestedLeafCount, nestedRowCount] = addChildValues(rows, value, cols, {
+                value: index.value + 1
+            }, fullKey, depth + 1);
+            row[COUNT] = nestedLeafCount;
+            leafCount += nestedLeafCount;
+            rowCount += nestedRowCount;
+            index.value += nestedRowCount;
+        } else leafCount += 1;
+    }
+    return [
+        leafCount,
+        rowCount
+    ];
+};
+export { jsonToDataSourceRows };

package/{esm/packages/vuu-utils/src → src}/keyboard-utils.js

@@ -10,7 +10,5 @@ const PageUp = "PageUp";
 const PageDown = "PageDown";
 const Space = " ";
 const Tab = "Tab";
-const isArrowKey = (key) => key === "ArrowUp" || key === "ArrowDown" || key === "ArrowLeft" || key === "ArrowRight";
-
+const isArrowKey = (key)=>"ArrowUp" === key || "ArrowDown" === key || "ArrowLeft" === key || "ArrowRight" === key;
 export { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Enter, Escape, Home, PageDown, PageUp, Space, Tab, isArrowKey };
-//# sourceMappingURL=keyboard-utils.js.map

package/src/keyset.js

@@ -0,0 +1,57 @@
+const EMPTY = [];
+class KeySet {
+    keys = new Map();
+    nextKeyValue = 0;
+    range;
+    constructor(range){
+        this.range = range;
+        this.init(range);
+    }
+    next(free = EMPTY) {
+        if (free.length > 0) return free.shift();
+        return this.nextKeyValue++;
+    }
+    init({ from, to }) {
+        this.keys.clear();
+        this.nextKeyValue = 0;
+        for(let rowIndex = from; rowIndex < to; rowIndex++){
+            const nextKeyValue = this.next();
+            this.keys.set(rowIndex, nextKeyValue);
+        }
+        return true;
+    }
+    reset(range) {
+        const { from, to } = range;
+        const newSize = to - from;
+        const currentSize = this.range.to - this.range.from;
+        this.range = range;
+        if (currentSize > newSize) return this.init(range);
+        const freeKeys = [];
+        this.keys.forEach((keyValue, rowIndex)=>{
+            if (rowIndex < from || rowIndex >= to) {
+                freeKeys.push(keyValue);
+                this.keys.delete(rowIndex);
+            }
+        });
+        for(let rowIndex = from; rowIndex < to; rowIndex++)if (!this.keys.has(rowIndex)) {
+            const nextKeyValue = this.next(freeKeys);
+            this.keys.set(rowIndex, nextKeyValue);
+        }
+        return false;
+    }
+    keyFor(rowIndex) {
+        const key = this.keys.get(rowIndex);
+        if (void 0 === key) {
+            console.log(`key not found
+        keys: ${this.toDebugString()}
+      `);
+            throw Error(`KeySet, no key found for rowIndex ${rowIndex}`);
+        }
+        return key;
+    }
+    toDebugString() {
+        return `${this.keys.size} keys
+${Array.from(this.keys.entries()).sort(([key1], [key2])=>key1 - key2).map(([k, v])=>`${k}=>${v}`).join(",")}]\n`;
+    }
+}
+export { KeySet };

package/src/list-utils.js

@@ -0,0 +1,5 @@
+const getSelectedOption = (values, selectedValue)=>{
+    if (void 0 === selectedValue) return;
+    return values.find((option)=>option.value === selectedValue);
+};
+export { getSelectedOption };

package/src/local-storage-utils.js

@@ -0,0 +1,23 @@
+const getLocalEntity = (key, deleteOnRead = false)=>{
+    const data = localStorage.getItem(key);
+    if (data) {
+        if (deleteOnRead) localStorage.removeItem(key);
+        return JSON.parse(data);
+    }
+};
+const clearLocalEntity = (key)=>{
+    const doomedItem = localStorage.getItem(key);
+    if (!doomedItem) return false;
+    localStorage.removeItem(key);
+    return true;
+};
+const getAllLocalEntity = (url)=>Object.entries(localStorage).filter(([key])=>key.includes(url)).map(([, value])=>JSON.parse(value));
+const saveLocalEntity = (key, data)=>{
+    try {
+        localStorage.setItem(key, JSON.stringify(data));
+        return data;
+    } catch  {
+        return;
+    }
+};
+export { clearLocalEntity, getAllLocalEntity, getLocalEntity, saveLocalEntity };

package/src/logging-utils.js

@@ -0,0 +1,52 @@
+import { getCookieValue } from "./cookie-utils.js";
+const logLevels = [
+    "error",
+    "warn",
+    "info",
+    "debug"
+];
+const isValidLogLevel = (value)=>"string" == typeof value && logLevels.includes(value);
+const DEFAULT_LOG_LEVEL = "error";
+const NO_OP = ()=>void 0;
+const DEFAULT_DEBUG_LEVEL = "production" === process.env.NODE_ENV ? "error" : "info";
+const { loggingLevel: loggingLevel = DEFAULT_DEBUG_LEVEL } = getLoggingSettings();
+const logger = (category)=>{
+    const debugEnabled = "debug" === loggingLevel;
+    const infoEnabled = debugEnabled || "info" === loggingLevel;
+    const warnEnabled = infoEnabled || "warn" === loggingLevel;
+    const errorEnabled = warnEnabled || "error" === loggingLevel;
+    const info = infoEnabled ? (message)=>console.info(`${Date.now()} [${category}] ${message}`) : NO_OP;
+    const warn = warnEnabled ? (message)=>console.warn(`[${category}] ${message}`) : NO_OP;
+    const debug = debugEnabled ? (message)=>console.debug(`${Date.now()} [${category}] ${message}`) : NO_OP;
+    const error = errorEnabled ? (message)=>console.error(`[${category}] ${message}`) : NO_OP;
+    if ("production" === process.env.NODE_ENV) return {
+        errorEnabled,
+        error
+    };
+    return {
+        debugEnabled,
+        infoEnabled,
+        warnEnabled,
+        errorEnabled,
+        info,
+        warn,
+        debug,
+        error
+    };
+};
+function getLoggingSettings() {
+    if ("u" > typeof loggingSettings) return loggingSettings;
+    return {
+        loggingLevel: getLoggingLevelFromCookie()
+    };
+}
+function getLoggingLevelFromCookie() {
+    const value = getCookieValue("vuu-logging-level");
+    if (isValidLogLevel(value)) return value;
+    return DEFAULT_LOG_LEVEL;
+}
+const getLoggingConfigForWorker = ()=>`const loggingSettings = { loggingLevel: "${getLoggingLevelFromCookie()}"};`;
+const logUnhandledMessage = (message, context = "[logUnhandledStruct]")=>{
+    console.log(`${context}  ${JSON.stringify(message)}`);
+};
+export { getLoggingConfigForWorker, logUnhandledMessage, logger };

package/src/module-utils.js

@@ -0,0 +1,2 @@
+const isModule = (entity)=>void 0 !== entity && "function" != typeof entity;
+export { isModule };

package/src/nanoid/index.js

@@ -0,0 +1,13 @@
+const uuid = (size = 21)=>{
+    let id = '';
+    const bytes = crypto.getRandomValues(new Uint8Array(size));
+    while(size--){
+        const byte = 63 & bytes[size];
+        if (byte < 36) id += byte.toString(36);
+        else if (byte < 62) id += (byte - 26).toString(36).toUpperCase();
+        else if (byte < 63) id += '_';
+        else id += '-';
+    }
+    return id;
+};
+export { uuid };

package/src/perf-utils.js

@@ -0,0 +1,28 @@
+function debounce(callback, timeInterval) {
+    let timeout;
+    return (...args)=>{
+        clearTimeout(timeout);
+        timeout = window.setTimeout(()=>callback(...args), timeInterval);
+    };
+}
+function throttle(callback, limit) {
+    let wait = false;
+    let lastArgs;
+    function checkLastArgs() {
+        if (void 0 == lastArgs) wait = false;
+        else {
+            callback(...lastArgs);
+            lastArgs = void 0;
+            setTimeout(checkLastArgs, limit);
+        }
+    }
+    return (...args)=>{
+        if (wait) lastArgs = args;
+        else {
+            callback(...args);
+            wait = true;
+            setTimeout(checkLastArgs, limit);
+        }
+    };
+}
+export { debounce, throttle };