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

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

package/src/edit-utils.js

@@ -0,0 +1,2 @@
+const isInlineEditingSession = (editSessionMode)=>editSessionMode.startsWith("inline");
+export { isInlineEditingSession };

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

@@ -1,5 +1,3 @@
 class StaleUpdateError extends Error {
 }
-
 export { StaleUpdateError };
-//# sourceMappingURL=errors.js.map

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 || "bigint" == typeof value ? 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";