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

package/src/event-emitter.js

@@ -0,0 +1,78 @@
+function isArrayOfListeners(listeners) {
+    return Array.isArray(listeners);
+}
+function isOnlyListener(listeners) {
+    return !Array.isArray(listeners);
+}
+class EventEmitter {
+    #events = new Map();
+    addListener(event, listener) {
+        const listeners = this.#events.get(event);
+        if (listeners) {
+            if (isArrayOfListeners(listeners)) listeners.push(listener);
+            else if (isOnlyListener(listeners)) this.#events.set(event, [
+                listeners,
+                listener
+            ]);
+        } else this.#events.set(event, listener);
+    }
+    removeListener(event, listener) {
+        if (!this.#events.has(event)) return;
+        const listenerOrListeners = this.#events.get(event);
+        let position = -1;
+        if (listenerOrListeners === listener) this.#events.delete(event);
+        else if (Array.isArray(listenerOrListeners)) {
+            for(let i = listenerOrListeners.length; i-- > 0;)if (listenerOrListeners[i] === listener) {
+                position = i;
+                break;
+            }
+            if (position < 0) return;
+            if (1 === listenerOrListeners.length) {
+                listenerOrListeners.length = 0;
+                this.#events.delete(event);
+            } else listenerOrListeners.splice(position, 1);
+        }
+    }
+    removeAllListeners(event) {
+        if (event && this.#events.has(event)) this.#events.delete(event);
+        else if (void 0 === event) this.#events.clear();
+    }
+    emit(event, ...args) {
+        if (this.#events) {
+            const handler = this.#events.get(event);
+            if (handler) this.invokeHandler(handler, args);
+        }
+    }
+    once(event, listener) {
+        const handler = (...args)=>{
+            this.removeListener(event, handler);
+            listener(...args);
+        };
+        this.on(event, handler);
+    }
+    on(event, listener) {
+        this.addListener(event, listener);
+    }
+    hasListener(event, listener) {
+        const listeners = this.#events.get(event);
+        if (Array.isArray(listeners)) return listeners.includes(listener);
+        return listeners === listener;
+    }
+    invokeHandler(handler, args) {
+        if (isArrayOfListeners(handler)) handler.slice().forEach((listener)=>this.invokeHandler(listener, args));
+        else switch(args.length){
+            case 0:
+                handler();
+                break;
+            case 1:
+                handler(args[0]);
+                break;
+            case 2:
+                handler(args[0], args[1]);
+                break;
+            default:
+                handler.call(null, ...args);
+        }
+    }
+}
+export { EventEmitter };

package/src/feature-utils.js

@@ -0,0 +1,86 @@
+import { partition } from "./array-utils.js";
+import { wordify } from "./text-utils.js";
+import react from "react";
+import { getLayoutComponent } from "./component-registry.js";
+const env = process.env.NODE_ENV;
+const isStaticFeature = (feature)=>null !== feature && "object" == typeof feature && "type" in feature;
+const isStaticFeatures = (features)=>Array.isArray(features) && features.every(isStaticFeature);
+function featureFromJson({ type }) {
+    const componentType = type.match(/^[a-z]/) ? type : getLayoutComponent(type);
+    if (void 0 === componentType) throw Error(`layoutUtils unable to create feature component from JSON, unknown type ${type}`);
+    return react.createElement(componentType);
+}
+const isCustomFeature = (feature)=>"vuu-features" === feature.leftNavLocation;
+const isWildcardSchema = (vuuTables)=>"*" === vuuTables;
+const isVuuTables = (vuuTables)=>Array.isArray(vuuTables);
+const hasFilterTableFeatureProps = (props)=>"object" == typeof props.ComponentProps && null !== props.ComponentProps && "tableSchema" in props.ComponentProps;
+const isSameTable = (t1, t2)=>{
+    t1.module === t2.module && (t1.table, t2.table);
+};
+const byModule = (schema1, schema2)=>{
+    const m1 = schema1.table.module.toLowerCase();
+    const m2 = schema2.table.module.toLowerCase();
+    if (m1 < m2) return -1;
+    if (m1 > m2) return 1;
+    if (schema1.table.table < schema2.table.table) return -1;
+    if (schema1.table.table > schema2.table.table) return 1;
+    return 0;
+};
+const getFilterTableFeatures = (schemas, getFeaturePath)=>schemas.sort(byModule).map((schema)=>({
+            ...getFeaturePath({
+                env: env,
+                fileName: "FilterTable"
+            }),
+            ComponentProps: {
+                tableSchema: schema
+            },
+            ViewProps: {
+                allowRename: true
+            },
+            title: `${schema.table.module} ${schema.table.table}`
+        }));
+const assertComponentRegistered = (componentName, component)=>{
+    if ("function" != typeof component) console.warn(`${componentName} module not loaded, will be unabale to deserialize from layout JSON`);
+};
+const assertComponentsRegistered = (componentList)=>{
+    for (const { componentName, component } of componentList)assertComponentRegistered(componentName, component);
+};
+const getCustomAndTableFeatures = (dynamicFeatures, tableSchemas)=>{
+    const [customFeatureConfig, tableFeaturesConfig] = partition(dynamicFeatures, isCustomFeature);
+    const customFeatures = [];
+    const tableFeatures = [];
+    for (const { featureProps = {}, viewProps, ...feature } of tableFeaturesConfig){
+        const { vuuTables } = featureProps;
+        if (isWildcardSchema(vuuTables)) {
+            if (tableSchemas) for (const tableSchema of tableSchemas)tableFeatures.push({
+                ...feature,
+                ComponentProps: {
+                    tableSchema
+                },
+                title: `${tableSchema.table.module} ${wordify(tableSchema.table.table)}`,
+                ViewProps: {
+                    ...viewProps,
+                    allowRename: true
+                }
+            });
+        }
+    }
+    for (const { featureProps = {}, viewProps, ...feature } of customFeatureConfig){
+        const { vuuTables } = featureProps;
+        if (isVuuTables(vuuTables)) {
+            if (tableSchemas) customFeatures.push({
+                ...feature,
+                ComponentProps: vuuTables.reduce((map, vuuTable)=>{
+                    map[`${vuuTable.table}Schema`] = tableSchemas.find((tableSchema)=>isSameTable(vuuTable, tableSchema.table));
+                    return map;
+                }, {}),
+                ViewProps: viewProps
+            });
+        } else customFeatures.push(feature);
+    }
+    return {
+        dynamicFeatures: customFeatures,
+        tableFeatures: tableFeatures
+    };
+};
+export { assertComponentRegistered, assertComponentsRegistered, byModule, env, featureFromJson, getCustomAndTableFeatures, getFilterTableFeatures, hasFilterTableFeatureProps, isCustomFeature, isSameTable, isStaticFeatures, isVuuTables, isWildcardSchema };

package/src/filters/filter-utils.js

@@ -0,0 +1,136 @@
+import { ScaledDecimal } from "../ScaledDecimal.js";
+const singleValueFilterOps = new Set([
+    "=",
+    "!=",
+    ">",
+    ">=",
+    "<",
+    "<=",
+    "contains",
+    "starts",
+    "ends"
+]);
+const isBetweenOperator = (op)=>"between" === op || "between-inclusive" === op;
+const isValidFilterClauseOp = (op)=>"in" === op || singleValueFilterOps.has(op);
+const isNamedFilter = (f)=>void 0 !== f && void 0 !== f.name;
+const isSingleValueFilter = (f)=>void 0 !== f && singleValueFilterOps.has(f.op);
+const isScaledDecimalFilterClause = (f)=>f.value instanceof ScaledDecimal;
+const isSerializableFilter = (f)=>isSingleValueFilter(f) && "asQuery" in f && "function" == typeof f["asQuery"];
+const isFilter = (f)=>"object" == typeof f && null !== f && (isFilterClause(f) || isMultiClauseFilter(f));
+const isFilterClause = (f)=>void 0 !== f && (isSingleValueFilter(f) || isMultiValueFilter(f));
+const isMultiValueFilter = (f)=>void 0 !== f && "in" === f.op;
+const isInFilter = (f)=>"in" === f.op;
+const isAndFilter = (f)=>f?.op === "and";
+const isBetweenFilter = (f)=>isAndFilter(f) && 2 === f.filters.length && f.filters[0].column === f.filters[1].column && (">" === f.filters[0].op && "<" === f.filters[1].op || ">=" === f.filters[0].op && "<=" === f.filters[1].op);
+const isOrFilter = (f)=>f?.op === "or";
+const isCompleteFilter = (filter)=>isSingleValueFilter(filter) && void 0 !== filter.column && void 0 !== filter.op && void 0 !== filter.value;
+function isMultiClauseFilter(f) {
+    return void 0 !== f && ("and" === f.op || "or" === f.op);
+}
+const isExtendedFilter = (f)=>"object" == typeof f.extendedOptions;
+const applyFilterToColumns = (columns, { filterStruct })=>columns.map((column)=>{
+        const filter = extractFilterForColumn(filterStruct, column.name);
+        if (void 0 !== filter) return {
+            ...column,
+            filter
+        };
+        if (column.filter) return {
+            ...column,
+            filter: void 0
+        };
+        return column;
+    });
+const isFilteredColumn = (column)=>void 0 !== column.filter;
+const stripFilterFromColumns = (columns)=>columns.map((col)=>{
+        const { filter, ...rest } = col;
+        return filter ? rest : col;
+    });
+const extractFilterForColumn = (filter, columnName)=>{
+    if (isMultiClauseFilter(filter)) return collectFiltersForColumn(filter, columnName);
+    if (isFilterClause(filter)) return filter.column === columnName ? filter : void 0;
+};
+const collectFiltersForColumn = (filter, columnName)=>{
+    const { filters, op } = filter;
+    const results = [];
+    filters.forEach((filter)=>{
+        const ffc = extractFilterForColumn(filter, columnName);
+        if (ffc) results.push(ffc);
+    });
+    if (0 === results.length) return;
+    if (1 === results.length) return results[0];
+    return {
+        op,
+        filters: results
+    };
+};
+const stringifyBoolean = (value)=>"boolean" == typeof value ? "${filter.value}" : value;
+const getColumnValueFromFilter = (column, operator, filter)=>{
+    if (isSingleValueFilter(filter)) {
+        if (filter.column === column.name) {
+            if (!operator.startsWith("between")) return stringifyBoolean(filter.value);
+            else if ("=" === filter.op) return [
+                `${filter.value}`,
+                ""
+            ];
+            else if ("<" === filter.op) return [
+                "",
+                `${filter.value}`
+            ];
+        }
+    } else if (isBetweenFilter(filter)) {
+        if (filter.filters[0].column === column.name) {
+            const [{ value: v1 }, { value: v2 }] = filter.filters;
+            return [
+                `${v1}`,
+                `${v2}`
+            ];
+        }
+    } else if (isAndFilter(filter)) {
+        const filterForColumn = filter.filters.find((f)=>isBetweenFilter(f) ? f.filters[0].column === column.name : f.column === column.name);
+        if (isSingleValueFilter(filterForColumn)) return stringifyBoolean(filterForColumn.value);
+        if (operator.startsWith("between") && isBetweenFilter(filterForColumn)) {
+            const [{ value: v1 }, { value: v2 }] = filterForColumn.filters;
+            return [
+                `${v1}`,
+                `${v2}`
+            ];
+        }
+    }
+    if (!operator.startsWith("between")) return "";
+    if ("time" === column.type) return [
+        "00:00:00",
+        "23:59:59"
+    ];
+    return [
+        "",
+        ""
+    ];
+};
+const betweenFiltersAreEqual = (f1, f2)=>{
+    const [from1, to1] = f1.filters;
+    const [from2, to2] = f2.filters;
+    return filtersAreEqual(from1, from2) && filtersAreEqual(to1, to2);
+};
+const singleValueFilterClausesAreEqual = (f1, f2)=>f1.column === f2.column && f1.op === f2.op && f1.value === f2.value;
+const findEqualFilter = (filters)=>(filter)=>{
+        if (isBetweenFilter(filter)) {
+            const target = filters.find((f)=>isBetweenFilter(f) && betweenFiltersAreEqual(f, filter));
+            return void 0 !== target;
+        }
+        {
+            const target = filters.find((f)=>f.column === filter.column);
+            if (target) return target.op === filter.op && target.value === filter.value;
+        }
+        return false;
+    };
+const filtersAreEqual = (f1, f2)=>{
+    if (null == f1 && null == f2) return true;
+    if (null == f1 || null == f2) ;
+    else if (isSingleValueFilter(f1) && isSingleValueFilter(f2)) return singleValueFilterClausesAreEqual(f1, f2);
+    else if (isBetweenFilter(f1) && isBetweenFilter(f2)) return betweenFiltersAreEqual(f1, f2);
+    else if (isAndFilter(f1) && isAndFilter(f2)) {
+        if (f1.filters.length === f2.filters.length) return f1.filters.every(findEqualFilter(f2.filters));
+    }
+    return false;
+};
+export { applyFilterToColumns, extractFilterForColumn, filtersAreEqual, getColumnValueFromFilter, isAndFilter, isBetweenFilter, isBetweenOperator, isCompleteFilter, isExtendedFilter, isFilter, isFilterClause, isFilteredColumn, isInFilter, isMultiClauseFilter, isMultiValueFilter, isNamedFilter, isOrFilter, isScaledDecimalFilterClause, isSerializableFilter, isSingleValueFilter, isValidFilterClauseOp, stripFilterFromColumns };

package/src/filters/filterAsQuery.js

@@ -0,0 +1,70 @@
+import { isDateTimeDataValue } from "../column-utils.js";
+import { isMultiClauseFilter, isMultiValueFilter, isSerializableFilter } from "./filter-utils.js";
+import { ScaledDecimal } from "../ScaledDecimal.js";
+const filterValue = (value)=>"string" == typeof value ? `"${value}"` : value instanceof ScaledDecimal ? value.toString() : value;
+const quotedStrings = (value)=>"string" == typeof value ? `"${value}"` : value;
+const removeOuterMostParentheses = (s)=>s.replace(/^\((.*)\)$/, "$1");
+const filterAsQuery = (f, opts)=>removeOuterMostParentheses(filterAsQueryCore(f, opts));
+const filterAsQueryCore = (f, opts)=>{
+    if (isMultiClauseFilter(f)) {
+        const multiClauseFilter = f.filters.map((filter)=>filterAsQueryCore(filter, opts)).join(` ${f.op} `);
+        return `(${multiClauseFilter})`;
+    }
+    if (isMultiValueFilter(f)) return `${f.column} ${f.op} [${f.values.map(quotedStrings).join(",")}]`;
+    return singleValueFilterAsQuery(f, opts);
+};
+function singleValueFilterAsQuery(f, opts) {
+    if (isSerializableFilter(f)) return f.asQuery();
+    {
+        const column = opts?.columnsByName?.[f.column];
+        if (column && isDateTimeDataValue(column)) return dateFilterAsQuery(f);
+        return defaultSingleValueFilterAsQuery(f);
+    }
+}
+const ONE_DAY_IN_MILLIS = 86400000;
+function dateFilterAsQuery(f) {
+    switch(f.op){
+        case "=":
+            {
+                const filters = [
+                    {
+                        op: ">=",
+                        column: f.column,
+                        value: f.value
+                    },
+                    {
+                        op: "<",
+                        column: f.column,
+                        value: f.value + ONE_DAY_IN_MILLIS
+                    }
+                ];
+                return filterAsQueryCore({
+                    op: "and",
+                    filters
+                });
+            }
+        case "!=":
+            {
+                const filters = [
+                    {
+                        op: "<",
+                        column: f.column,
+                        value: f.value
+                    },
+                    {
+                        op: ">=",
+                        column: f.column,
+                        value: f.value + ONE_DAY_IN_MILLIS
+                    }
+                ];
+                return filterAsQueryCore({
+                    op: "or",
+                    filters
+                });
+            }
+        default:
+            return defaultSingleValueFilterAsQuery(f);
+    }
+}
+const defaultSingleValueFilterAsQuery = (f)=>`${f.column} ${f.op} ${filterValue(f.value)}`;
+export { ONE_DAY_IN_MILLIS, dateFilterAsQuery, filterAsQuery };

package/src/filters/index.js

@@ -0,0 +1,2 @@
+export * from "./filter-utils.js";
+export * from "./filterAsQuery.js";

package/src/form-utils.js

@@ -0,0 +1,69 @@
+import { stringIsValidDecimal, stringIsValidInt } 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":
+        case "long":
+            if (stringIsValidInt(value)) return parseInt(value, 10);
+            if (isValidTimeString(value)) return value;
+            if (!throwIfInvalid) return;
+            else 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,42 @@
+import { isDateTimeDataValue, isMappedValueTypeRenderer, 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)=>{
+    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, serverDataType = column.serverDataType)=>{
+    if (isDateTimeDataValue(column, serverDataType) || 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 };