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

package/src/common-types.js

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

package/src/component-registry.js

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,5 @@
+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-utils.js

@@ -0,0 +1,66 @@
+const UP1 = "up1";
+const UP2 = "up2";
+const DOWN1 = "down1";
+const DOWN2 = "down2";
+const decimalPattern = /^-?[0-9]*\.[0-9]*$/;
+const JAVA_LONG_MIN = BigInt("-9223372036854775808");
+const JAVA_LONG_MAX = BigInt("9223372036854775807");
+const stringIsValidInt = (val)=>parseInt(val, 10).toString() === val;
+const stringIsValidLong = (val)=>{
+    if ("" === val) return false;
+    try {
+        const n = BigInt(val);
+        return n <= JAVA_LONG_MAX && n >= JAVA_LONG_MIN;
+    } catch (e) {
+        return false;
+    }
+};
+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, stringIsValidLong, stringIsValidNumber };

package/src/datasource/BaseDataSource.js

@@ -0,0 +1,233 @@
+import { parseFilter } from "@vuu-ui/vuu-filter-parser";
+import { EventEmitter } from "../event-emitter.js";
+import { uuid } from "../nanoid/index.js";
+import { isConfigChanged, stripVisualLink, vanillaConfig, withConfigDefaults } from "./datasource-utils.js";
+import { Range } from "../range-utils.js";
+import { filterAsQuery } from "../filters/index.js";
+const defaultSuspenseProps = {
+    escalateToDisable: true
+};
+class BaseDataSource extends EventEmitter {
+    viewport;
+    _clientCallback;
+    _configWithVisualLink = vanillaConfig;
+    _impendingConfigWithVisualLink = void 0;
+    _range = Range(0, 0);
+    _size = 0;
+    _title;
+    _defaultSuspenseProps;
+    #freezeTimestamp = void 0;
+    #pageCount = 0;
+    awaitingConfirmationOfConfigChanges = false;
+    constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, sort, suspenseProps = defaultSuspenseProps, title, viewport }){
+        super();
+        this._configWithVisualLink = {
+            ...this._configWithVisualLink,
+            aggregations: aggregations || this._configWithVisualLink.aggregations,
+            baseFilterSpec: baseFilterSpec || this._configWithVisualLink.baseFilterSpec,
+            columns: columns || this._configWithVisualLink.columns,
+            filterSpec: filterSpec || this._configWithVisualLink.filterSpec,
+            groupBy: groupBy || this._configWithVisualLink.groupBy,
+            sort: sort || this._configWithVisualLink.sort
+        };
+        this._defaultSuspenseProps = suspenseProps;
+        this._title = title;
+        this.viewport = viewport ?? "";
+    }
+    subscribe({ baseFilterSpec, columns, aggregations, range, sort, groupBy, filterSpec, viewport = this.viewport || (this.viewport = uuid()) }, callback) {
+        this._clientCallback = callback;
+        this.viewport = viewport;
+        if (aggregations || baseFilterSpec || columns || filterSpec || groupBy || sort) this._configWithVisualLink = {
+            ...this._configWithVisualLink,
+            aggregations: aggregations || this._configWithVisualLink.aggregations,
+            baseFilterSpec: baseFilterSpec || this._configWithVisualLink.baseFilterSpec,
+            columns: columns || this._configWithVisualLink.columns,
+            filterSpec: filterSpec || this._configWithVisualLink.filterSpec,
+            groupBy: groupBy || this._configWithVisualLink.groupBy,
+            sort: sort || this._configWithVisualLink.sort
+        };
+        if (range) {
+            this._range = range;
+            this.emit("range", range);
+        }
+    }
+    get aggregations() {
+        return this._configWithVisualLink.aggregations;
+    }
+    set aggregations(aggregations) {
+        this.config = {
+            ...this._configWithVisualLink,
+            aggregations
+        };
+        this.emit("config", this._configWithVisualLink, this.range);
+    }
+    get baseFilter() {
+        return this._configWithVisualLink.baseFilterSpec;
+    }
+    set baseFilter(baseFilter) {
+        this.config = {
+            ...this._configWithVisualLink,
+            baseFilterSpec: baseFilter
+        };
+    }
+    get columns() {
+        return this._configWithVisualLink.columns;
+    }
+    set columns(columns) {
+        this.config = {
+            ...this._configWithVisualLink,
+            columns
+        };
+    }
+    get filter() {
+        return this._configWithVisualLink.filterSpec;
+    }
+    set filter(filter) {
+        this.config = {
+            ...this._configWithVisualLink,
+            filterSpec: filter
+        };
+    }
+    setFilter(filter) {
+        const dataSourceFilter = {
+            filter: filterAsQuery(filter),
+            filterStruct: filter
+        };
+        this.filter = dataSourceFilter;
+    }
+    clearFilter() {
+        this.filter = {
+            filter: ""
+        };
+    }
+    get isAwaitingConfirmationOfConfigChange() {
+        return void 0 !== this._impendingConfigWithVisualLink;
+    }
+    confirmConfigChange() {
+        if (this._impendingConfigWithVisualLink) {
+            this._configWithVisualLink = this._impendingConfigWithVisualLink;
+            this._impendingConfigWithVisualLink = void 0;
+            this.emit("config", this._configWithVisualLink, this.range, true);
+        } else throw Error("[BaseDataSource], unexpected call to confirmConfigChange, no changes pending");
+    }
+    get config() {
+        return stripVisualLink(this._impendingConfigWithVisualLink ?? this._configWithVisualLink);
+    }
+    set config(config) {
+        const confirmed = this.awaitingConfirmationOfConfigChanges ? true : void 0;
+        this.awaitingConfirmationOfConfigChanges = false;
+        const configChanges = this.applyConfig(config);
+        if (configChanges) requestAnimationFrame(()=>{
+            this.emit("config", this._configWithVisualLink, this.range, confirmed, configChanges);
+        });
+    }
+    get impendingConfig() {
+        return this._impendingConfigWithVisualLink;
+    }
+    set impendingConfig(config) {
+        if (config) {
+            this.awaitingConfirmationOfConfigChanges = true;
+            const configChanges = this.applyConfig(config);
+            if (configChanges) this.emit("config", this.config, this.range, false, configChanges);
+        } else throw Error("[BaseDataSource] ''unsetting impendingConfig is not currently supported");
+    }
+    get pageCount() {
+        return this.#pageCount;
+    }
+    set pageCount(pageCount) {
+        if (pageCount !== this.#pageCount) {
+            this.#pageCount = pageCount;
+            this.emit("page-count", pageCount);
+        }
+    }
+    get range() {
+        return this._range;
+    }
+    set range(range) {
+        if (range.from !== this._range.from || range.to !== this._range.to) {
+            this._range = range;
+            this.pageCount = Math.ceil(this._size / (range.to - range.from));
+            this.rangeRequest(range.withBuffer);
+            requestAnimationFrame(()=>{
+                this.emit("range", range);
+            });
+        }
+    }
+    get size() {
+        return this._size;
+    }
+    set size(size) {
+        this._size = size;
+        if (0 !== this.range.to) {
+            const pageCount = Math.ceil(size / (this.range.to - this.range.from));
+            this.pageCount = pageCount;
+        }
+    }
+    get sort() {
+        return this._configWithVisualLink.sort;
+    }
+    set sort(sort) {
+        this.config = {
+            ...this._configWithVisualLink,
+            sort
+        };
+        this.emit("config", this._configWithVisualLink, this.range);
+    }
+    get title() {
+        return this._title ?? "";
+    }
+    set title(title) {
+        this._title = title;
+        this.emit("title-changed", this.viewport ?? "", title);
+    }
+    applyConfig(config, preserveExistingConfigAttributes = false) {
+        const { noChanges, ...otherChanges } = isConfigChanged(this._configWithVisualLink, config);
+        if (true !== noChanges) {
+            if (config) {
+                const newConfig = config?.filterSpec?.filter && config?.filterSpec.filterStruct === void 0 ? {
+                    ...config,
+                    filterSpec: {
+                        filter: config.filterSpec.filter,
+                        filterStruct: parseFilter(config.filterSpec.filter)
+                    }
+                } : config;
+                if (preserveExistingConfigAttributes) if (this.awaitingConfirmationOfConfigChanges) this._impendingConfigWithVisualLink = {
+                    ...this._configWithVisualLink,
+                    ...config
+                };
+                else {
+                    this._impendingConfigWithVisualLink = void 0;
+                    this._configWithVisualLink = {
+                        ...this._configWithVisualLink,
+                        ...config
+                    };
+                }
+                else if (this.awaitingConfirmationOfConfigChanges) this._impendingConfigWithVisualLink = withConfigDefaults(newConfig);
+                else {
+                    this._impendingConfigWithVisualLink = void 0;
+                    this._configWithVisualLink = withConfigDefaults(newConfig);
+                }
+                return otherChanges;
+            }
+        }
+    }
+    freeze() {
+        if (this.isFrozen) throw Error("[BaseDataSource] cannot freeze, dataSource is already frozen");
+        this.#freezeTimestamp = new Date().getTime();
+        this.emit("freeze", true, this.#freezeTimestamp);
+    }
+    unfreeze() {
+        if (this.isFrozen) {
+            const freezeTimestamp = this.#freezeTimestamp;
+            this.#freezeTimestamp = void 0;
+            this.emit("freeze", false, freezeTimestamp);
+        } else throw Error("[BaseDataSource] cannot freeze, dataSource is already frozen");
+    }
+    get freezeTimestamp() {
+        return this.#freezeTimestamp;
+    }
+    get isFrozen() {
+        return "number" == typeof this.#freezeTimestamp;
+    }
+}
+export { BaseDataSource, defaultSuspenseProps };

package/src/datasource/datasource-action-utils.js

@@ -0,0 +1,6 @@
+const isVisualLinksAction = (action)=>"vuu-links" === action.type;
+const isVisualLinkCreatedAction = (action)=>"vuu-link-created" === action.type;
+const isVisualLinkRemovedAction = (action)=>"vuu-link-removed" === action.type;
+const isViewportMenusAction = (action)=>"vuu-menu" === action.type;
+const isVuuFeatureAction = (action)=>isViewportMenusAction(action) || isVisualLinksAction(action);
+export { isViewportMenusAction, isVisualLinkCreatedAction, isVisualLinkRemovedAction, isVisualLinksAction, isVuuFeatureAction };

package/src/datasource/datasource-filter-utils.js

@@ -0,0 +1,27 @@
+import { parseFilter } from "@vuu-ui/vuu-filter-parser";
+const combineFilters = ({ baseFilterSpec, filterSpec, ...config })=>{
+    if (void 0 === baseFilterSpec || "" === baseFilterSpec.filter) if (filterSpec.filterStruct || "" === filterSpec.filter) return {
+        ...config,
+        filterSpec
+    };
+    else return {
+        ...config,
+        filterSpec: {
+            filter: filterSpec.filter,
+            filterStruct: parseFilter(filterSpec.filter)
+        }
+    };
+    {
+        const baseFilterQuery = baseFilterSpec.filter;
+        const combinedFilter = filterSpec.filter.length > 0 && baseFilterQuery.length > 0 ? `${filterSpec.filter} and ${baseFilterQuery}` : filterSpec.filter || baseFilterQuery;
+        const newConfig = {
+            ...config,
+            filterSpec: {
+                filter: combinedFilter,
+                filterStruct: combinedFilter.length > 0 ? parseFilter(combinedFilter) : void 0
+            }
+        };
+        return newConfig;
+    }
+};
+export { combineFilters };

package/src/datasource/datasource-utils.js

@@ -0,0 +1,148 @@
+const NoFilter = {
+    filter: ""
+};
+const NoSort = {
+    sortDefs: []
+};
+const vanillaConfig = {
+    aggregations: [],
+    columns: [],
+    filterSpec: NoFilter,
+    groupBy: [],
+    sort: NoSort
+};
+const stripVisualLink = (configWithVisualLink)=>{
+    if (!configWithVisualLink.visualLink) return configWithVisualLink;
+    {
+        const { visualLink, ...config } = configWithVisualLink;
+        return config;
+    }
+};
+const equivalentAggregations = ({ aggregations: agg1 }, { aggregations: agg2 })=>void 0 === agg1 && agg2?.length === 0 || void 0 === agg2 && agg1?.length === 0;
+const equivalentColumns = ({ columns: cols1 }, { columns: cols2 })=>void 0 === cols1 && cols2?.length === 0 || void 0 === cols2 && cols1?.length === 0;
+const equivalentFilter = ({ filterSpec: f1 }, { filterSpec: f2 })=>void 0 === f1 && f2?.filter === "" || void 0 === f2 && f1?.filter === "";
+const equivalentGroupBy = ({ groupBy: val1 }, { groupBy: val2 })=>void 0 === val1 && val2?.length === 0 || void 0 === val2 && val1?.length === 0;
+const equivalentSort = ({ sort: s1 }, { sort: s2 })=>void 0 === s1 && s2?.sortDefs.length === 0 || void 0 === s2 && s1?.sortDefs.length === 0;
+const exactlyTheSame = (a, b)=>{
+    if (a === b) return true;
+    if (void 0 === a && void 0 === b) return true;
+    return false;
+};
+const isAggregationsChanged = (config, newConfig)=>{
+    const { aggregations: agg1 } = config;
+    const { aggregations: agg2 } = newConfig;
+    if (exactlyTheSame(agg1, agg2) || equivalentAggregations(config, newConfig)) return false;
+    if (void 0 === agg1 || void 0 === agg2) return true;
+    if (agg1.length !== agg2.length) return true;
+    return agg1.some(({ column, aggType }, i)=>column !== agg2[i].column || aggType !== agg2[i].aggType);
+};
+const isColumnsChanged = (config, newConfig)=>{
+    const { columns: cols1 } = config;
+    const { columns: cols2 } = newConfig;
+    if (exactlyTheSame(cols1, cols2) || equivalentColumns(config, newConfig)) return false;
+    if (void 0 === cols1 || void 0 === cols2) return true;
+    if (cols1?.length !== cols2?.length) return true;
+    return cols1.some((column, i)=>column !== cols2?.[i]);
+};
+const isBaseFilterChanged = (c1, c2)=>{
+    if (equivalentFilter(c1, c2)) return false;
+    return c1.baseFilterSpec?.filter !== c2.baseFilterSpec?.filter;
+};
+const isFilterChanged = (c1, c2)=>{
+    if (equivalentFilter(c1, c2)) return false;
+    return c1.filterSpec?.filter !== c2.filterSpec?.filter;
+};
+const isGroupByChanged = (config, newConfig)=>{
+    const { groupBy: g1 } = config;
+    const { groupBy: g2 } = newConfig;
+    if (exactlyTheSame(g1, g2) || equivalentGroupBy(config, newConfig)) return false;
+    if (void 0 === g1 || void 0 === g2) return true;
+    if (g1?.length !== g2?.length) return true;
+    return g1.some((column, i)=>column !== g2?.[i]);
+};
+const isSortChanged = (config, newConfig)=>{
+    const { sort: s1 } = config;
+    const { sort: s2 } = newConfig;
+    if (exactlyTheSame(s1, s2) || equivalentSort(config, newConfig)) return false;
+    if (void 0 === s1 || void 0 === s2) return true;
+    if (s1?.sortDefs.length !== s2?.sortDefs.length) return true;
+    return s1.sortDefs.some(({ column, sortType }, i)=>column !== s2.sortDefs[i].column || sortType !== s2.sortDefs[i].sortType);
+};
+const isVisualLinkChanged = ({ visualLink: v1 }, { visualLink: v2 })=>{
+    if (exactlyTheSame(v1, v2)) return false;
+    if (void 0 === v1 || void 0 === v2) return true;
+    return v1.label !== v2.label || v2.parentVpId !== v2.parentVpId;
+};
+const NO_CONFIG_CHANGES = {
+    aggregationsChanged: false,
+    baseFilterChanged: false,
+    columnsChanged: false,
+    filterChanged: false,
+    groupByChanged: false,
+    noChanges: true,
+    sortChanged: false,
+    visualLinkChanged: false
+};
+const isConfigChanged = (config, newConfig)=>{
+    if (exactlyTheSame(config, newConfig)) return NO_CONFIG_CHANGES;
+    if (void 0 === config && void 0 == newConfig) return NO_CONFIG_CHANGES;
+    if (void 0 === config) return isConfigChanged({}, newConfig);
+    if (void 0 === newConfig) return isConfigChanged(config, {});
+    const aggregationsChanged = isAggregationsChanged(config, newConfig);
+    const baseFilterChanged = isBaseFilterChanged(config, newConfig);
+    const columnsChanged = isColumnsChanged(config, newConfig);
+    const filterChanged = isFilterChanged(config, newConfig);
+    const groupByChanged = isGroupByChanged(config, newConfig);
+    const sortChanged = isSortChanged(config, newConfig);
+    const visualLinkChanged = isVisualLinkChanged(config, newConfig);
+    const noChanges = !(aggregationsChanged || baseFilterChanged || columnsChanged || filterChanged || groupByChanged || sortChanged || visualLinkChanged);
+    return {
+        aggregationsChanged,
+        baseFilterChanged,
+        columnsChanged,
+        filterChanged,
+        groupByChanged,
+        noChanges,
+        sortChanged,
+        visualLinkChanged
+    };
+};
+const hasGroupBy = (config)=>void 0 !== config && void 0 !== config.groupBy && config.groupBy.length > 0;
+const hasBaseFilter = (config)=>config?.baseFilterSpec !== void 0 && config.baseFilterSpec.filter.length > 0;
+const hasFilter = (config)=>config?.filterSpec !== void 0 && config.filterSpec.filter.length > 0;
+const hasSort = (config)=>config?.sort !== void 0 && Array.isArray(config.sort?.sortDefs) && config.sort.sortDefs.length > 0;
+const isTypeaheadSuggestionProvider = (source)=>"function" == typeof source["getTypeaheadSuggestions"];
+const isTableSchemaMessage = (message)=>"TABLE_META_RESP" === message.type;
+const isConnectionQualityMetrics = (msg)=>"connection-metrics" === msg.type;
+const messageHasResult = (msg)=>void 0 !== msg.result;
+const isVisualLinkMessage = (msg)=>msg.type.endsWith("_VISUAL_LINK");
+const isVisualLinksMessage = (msg)=>"vuu-links" === msg.type;
+const isViewportMessage = (msg)=>"viewport" in msg;
+const messageHasDataRows = (message)=>"viewport-update" === message.type && Array.isArray(message.rows);
+const messageHasSize = (message)=>"viewport-update" === message.type && "number" == typeof message.size;
+const withConfigDefaults = (config)=>{
+    if (config.aggregations && config.baseFilterSpec && config.columns && config.filterSpec && config.groupBy && config.sort) return config;
+    {
+        const { aggregations = [], baseFilterSpec: baseFilter = {
+            filter: ""
+        }, columns = [], filterSpec: filter = {
+            filter: ""
+        }, groupBy = [], sort = {
+            sortDefs: []
+        }, visualLink } = config;
+        return {
+            aggregations,
+            baseFilterSpec: baseFilter,
+            columns,
+            filterSpec: filter,
+            groupBy,
+            sort,
+            visualLink
+        };
+    }
+};
+const dataSourceRowToEntity = (row, columnMap)=>Object.entries(columnMap).reduce((entity, [name, index])=>({
+            ...entity,
+            [name]: row[index]
+        }), {});
+export { NO_CONFIG_CHANGES, NoFilter, NoSort, dataSourceRowToEntity, hasBaseFilter, hasFilter, hasGroupBy, hasSort, isBaseFilterChanged, isConfigChanged, isConnectionQualityMetrics, isFilterChanged, isGroupByChanged, isTableSchemaMessage, isTypeaheadSuggestionProvider, isViewportMessage, isVisualLinkMessage, isVisualLinksMessage, messageHasDataRows, messageHasResult, messageHasSize, stripVisualLink, vanillaConfig, withConfigDefaults };