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

package/src/datasource/BaseDataSource.js

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

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

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

@@ -1,148 +0,0 @@
-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 };

package/src/date/date-utils.js

@@ -1,80 +0,0 @@
-import { CalendarDate } from "@internationalized/date";
-function toCalendarDate(d) {
-    return new CalendarDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
-}
-const zeroTime = "00:00:00";
-const zeroTimeUnit = "00";
-function incrementTimeUnitValue(unit, value) {
-    const num = parseInt(value);
-    if ("hours" === unit && num < 23) return `${num + 1}`.padStart(2, "0").slice(-2);
-    if ("hours" === unit && 23 === num) return "00";
-    if (num < 59) return `${num + 1}`.padStart(2, "0").slice(-2);
-    if (59 === num) return "00";
-    return value;
-}
-function decrementTimeUnitValue(unit, value) {
-    const num = parseInt(value);
-    if ("hours" === unit && num > 0) return `${num - 1}`.padStart(2, "0").slice(-2);
-    if ("hours" === unit && 0 === num) return "23";
-    if (num > 0) return `${num - 1}`.padStart(2, "0").slice(-2);
-    if (0 === num) return "59";
-    return value;
-}
-function updateTimeString(timeString, unit, value) {
-    const newTimeString = "hours" === unit ? value.concat(timeString.slice(2)) : "minutes" === unit ? timeString.slice(0, 3).concat(value).concat(timeString.slice(5)) : timeString.slice(0, 6).concat(value);
-    if (isValidTimeString(newTimeString)) return newTimeString;
-    throw Error(`[date-utils] udateTimeSting invalid result ${newTimeString}`);
-}
-const validTimePattern = /(?:[0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]/;
-const isValidTimeString = (value)=>"string" == typeof value && validTimePattern.test(value);
-function asTimeString(value, allowUndefined = false) {
-    if (void 0 === value) if (allowUndefined) return value;
-    else throw Error("[date-utils] asTimeString, value cannot be undefined");
-    if (isValidTimeString(value)) return value;
-    if ("number" == typeof value) return Time.millisToTimeString(value);
-    if ("string" == typeof value) {
-        const valueAsInt = parseInt(value);
-        if (!isNaN(valueAsInt)) return Time.millisToTimeString(valueAsInt);
-    } else throw Error(`[date-utils] asTimeString, value ${value} is not valid TimeString`);
-}
-const padZero = (val)=>`${val}`.padStart(2, "0");
-class TimeImpl {
-    #hours;
-    #minutes;
-    #seconds;
-    constructor(timeString){
-        const [hours, minutes, seconds] = timeString.split(":");
-        this.#hours = parseInt(hours);
-        this.#minutes = parseInt(minutes);
-        this.#seconds = parseInt(seconds);
-    }
-    get hours() {
-        return this.#hours;
-    }
-    get minutes() {
-        return this.#minutes;
-    }
-    get seconds() {
-        return this.#seconds;
-    }
-    asDate(date) {
-        const dt = void 0 === date ? new Date() : "string" == typeof date ? new Date(date) : date;
-        dt.setHours(this.#hours);
-        dt.setMinutes(this.#minutes);
-        dt.setSeconds(this.seconds);
-        dt.setMilliseconds(0);
-        return dt;
-    }
-    toString() {
-        return Time.toString(this.#hours, this.#minutes, this.#seconds);
-    }
-}
-const Time = (timeString)=>new TimeImpl(timeString);
-Time.millisToTimeString = (timestamp)=>new Date(timestamp).toTimeString().slice(0, 8);
-Time.toString = (hours, minutes, seconds)=>`${padZero(hours)}:${padZero(minutes)}:${padZero(seconds)}`;
-Time.isDateInMillis = (dtInMillis)=>{
-    const n = "number" == typeof dtInMillis ? dtInMillis : Number(dtInMillis);
-    if (!Number.isFinite(n) || !Number.isInteger(n)) return false;
-    return new Date(n).getTime() === n;
-};
-export { Time, asTimeString, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, toCalendarDate, updateTimeString, zeroTime, zeroTimeUnit };

package/src/date/dateTimePattern.js

@@ -1,17 +0,0 @@
-import { isTypeDescriptor } from "../column-utils.js";
-import { isDateTimePattern } from "./types.js";
-const defaultPatternsByType = {
-    time: "hh:mm:ss",
-    date: "dd.mm.yyyy"
-};
-const fallbackDateTimePattern = {
-    date: defaultPatternsByType["date"],
-    time: defaultPatternsByType["time"]
-};
-function dateTimePattern(type) {
-    if (isTypeDescriptor(type)) {
-        if (type.formatting && isDateTimePattern(type.formatting.pattern)) return type.formatting.pattern;
-    }
-    return fallbackDateTimePattern;
-}
-export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern };

package/src/date/formatter.js

@@ -1,101 +0,0 @@
-import { DateFormatter } from "@internationalized/date";
-const baseTimeFormatOptions = {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit"
-};
-const formatConfigByTimePatterns = {
-    "hh:mm:ss": {
-        locale: "en-GB",
-        options: {
-            ...baseTimeFormatOptions,
-            hour12: false
-        }
-    },
-    "hh:mm:ss a": {
-        locale: "en-GB",
-        options: {
-            ...baseTimeFormatOptions,
-            hour12: true
-        }
-    },
-    "hh:mm:ss.ms": {
-        locale: "en-GB",
-        options: {
-            ...baseTimeFormatOptions,
-            hour12: false,
-            fractionalSecondDigits: 3
-        }
-    }
-};
-const baseDateFormatOptions = {
-    day: "2-digit",
-    month: "2-digit",
-    year: "numeric"
-};
-const formatConfigByDatePatterns = {
-    "dd.mm.yyyy": {
-        locale: "de-De",
-        options: {
-            ...baseDateFormatOptions
-        }
-    },
-    "dd/mm/yyyy": {
-        locale: "en-GB",
-        options: {
-            ...baseDateFormatOptions
-        }
-    },
-    "dd MMM yyyy": {
-        locale: "en-GB",
-        options: {
-            ...baseDateFormatOptions,
-            month: "short"
-        }
-    },
-    "dd MMMM yyyy": {
-        locale: "en-GB",
-        options: {
-            ...baseDateFormatOptions,
-            month: "long"
-        }
-    },
-    "mm/dd/yyyy": {
-        locale: "en-US",
-        options: {
-            ...baseDateFormatOptions
-        }
-    },
-    "MMM dd, yyyy": {
-        locale: "en-US",
-        options: {
-            ...baseDateFormatOptions,
-            month: "short"
-        }
-    },
-    "MMMM dd, yyyy": {
-        locale: "en-US",
-        options: {
-            ...baseDateFormatOptions,
-            month: "long"
-        }
-    }
-};
-const dateFormatterISO = {
-    format: (date)=>new Date(date - 60000 * date.getTimezoneOffset()).toISOString().replace(/T.*/, "")
-};
-function getDateFormatter({ locale, options }) {
-    return new DateFormatter(locale, options);
-}
-function getDateAndTimeFormatters({ date, time }) {
-    const out = [];
-    if ("yyyy-mm-dd" === date) out.push(dateFormatterISO);
-    else if (date) out.push(getDateFormatter(formatConfigByDatePatterns[date]));
-    if (time) out.push(getDateFormatter(formatConfigByTimePatterns[time]));
-    return out;
-}
-function formatDate(pattern) {
-    const formatters = getDateAndTimeFormatters(pattern);
-    return (d)=>formatters.map((f)=>f.format(d)).join(" ");
-}
-export { formatDate, getDateFormatter };

package/src/date/index.js

@@ -1,4 +0,0 @@
-export * from "./formatter.js";
-export { Time, asTimeString, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, toCalendarDate, updateTimeString, zeroTime, zeroTimeUnit } from "./date-utils.js";
-export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern } from "./dateTimePattern.js";
-export { dateTimeLabelByType, isDatePattern, isTimePattern, supportedDateTimePatterns } from "./types.js";

package/src/date/types.js

@@ -1,27 +0,0 @@
-const supportedDatePatterns = [
-    "yyyy-mm-dd",
-    "dd.mm.yyyy",
-    "dd/mm/yyyy",
-    "dd MMM yyyy",
-    "dd MMMM yyyy",
-    "mm/dd/yyyy",
-    "MMM dd, yyyy",
-    "MMMM dd, yyyy"
-];
-const supportedTimePatterns = [
-    "hh:mm:ss",
-    "hh:mm:ss a",
-    "hh:mm:ss.ms"
-];
-const supportedDateTimePatterns = {
-    date: supportedDatePatterns,
-    time: supportedTimePatterns
-};
-const dateTimeLabelByType = {
-    date: "Date",
-    time: "Time"
-};
-const isDatePattern = (pattern)=>supportedDatePatterns.includes(pattern);
-const isTimePattern = (pattern)=>supportedTimePatterns.includes(pattern);
-const isDateTimePattern = (pattern)=>isDatePattern(pattern?.date) || isTimePattern(pattern?.time);
-export { dateTimeLabelByType, isDatePattern, isDateTimePattern, isTimePattern, supportedDateTimePatterns };

package/src/debug-utils.js

@@ -1,25 +0,0 @@
-import { logger } from "./logging-utils.js";
-const { debug: debug, debugEnabled: debugEnabled } = logger("range-monitor");
-class RangeMonitor {
-    source;
-    range = {
-        from: 0,
-        to: 0
-    };
-    timestamp = 0;
-    constructor(source){
-        this.source = source;
-    }
-    isSet() {
-        return 0 !== this.timestamp;
-    }
-    set({ from, to }) {
-        const { timestamp } = this;
-        this.range.from = from;
-        this.range.to = to;
-        this.timestamp = performance.now();
-        if (!timestamp) return 0;
-        debugEnabled && debug(`<${this.source}> [${from}-${to}], ${(this.timestamp - timestamp).toFixed(0)} ms elapsed`);
-    }
-}
-export { RangeMonitor };