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

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 };

package/src/date/date-utils.js

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

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

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

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

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

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