@vuu-ui/vuu-utils 4.0.0-alpha.2 → 4.0.0-alpha.21

package/src/date/temporal.js

@@ -0,0 +1,131 @@
+import { EpochTimestamp } from "./EpochTimestamp.js";
+import { getDefaultTimeZone, resolveRelativeDate } from "./time-zone.js";
+const temporalKindByTypeName = {
+    "date/time": "datetime",
+    date: "date",
+    time: "time"
+};
+const isTemporalTypeName = (typeName)=>"date/time" === typeName || "date" === typeName || "time" === typeName;
+const getTypeName = ({ type })=>"string" == typeof type ? type : type?.name;
+const getTemporalInfo = (descriptor)=>{
+    if (void 0 === descriptor) return;
+    const { serverDataType, type } = descriptor;
+    const typeName = getTypeName(descriptor);
+    const kindFromType = isTemporalTypeName(typeName) ? temporalKindByTypeName[typeName] : void 0;
+    let encoding;
+    switch(serverDataType){
+        case "epochtimestamp":
+            encoding = "number" === typeName ? void 0 : "epochMillis";
+            break;
+        case "epochtimestampnano":
+            encoding = "number" === typeName ? void 0 : "epochNanos";
+            break;
+        case void 0:
+        case "long":
+        case "int":
+        case "double":
+            encoding = kindFromType ? "epochMillis" : void 0;
+            break;
+    }
+    if (void 0 === encoding) return;
+    const timeZone = ("object" == typeof type ? type.formatting?.timeZone : void 0) ?? getDefaultTimeZone();
+    return {
+        kind: kindFromType ?? "datetime",
+        encoding,
+        precision: "epochNanos" === encoding ? "ns" : "ms",
+        timeZone
+    };
+};
+const isTemporal = (descriptor)=>void 0 !== getTemporalInfo(descriptor);
+const defaultFractionalSecondDigits = (info)=>"ns" === info.precision ? 9 : 3;
+const pad2 = (n)=>`${n}`.padStart(2, "0");
+const formatTemporalInput = (value, { kind, precision, timeZone })=>{
+    if (void 0 === value) return "";
+    const { year, month, day, hour, minute, second } = value.getFields(timeZone);
+    const date = `${year}-${pad2(month)}-${pad2(day)}`;
+    if ("date" === kind) return date;
+    const fraction = value.fractionalSecond("ns" === precision ? 9 : 3).replace(/0+$/, "");
+    const time = `${pad2(hour)}:${pad2(minute)}:${pad2(second)}${fraction ? `.${fraction}` : ""}`;
+    return "time" === kind ? time : `${date} ${time}`;
+};
+const dateTimeInputPattern = /^\s*(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?)?\s*$/;
+const timeInputPattern = /^\s*(\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?\s*$/;
+const epochDigitsPattern = /^\s*-?\d{9,}\s*$/;
+const daysInMonth = (year, month)=>new Date(Date.UTC(year, month, 0)).getUTCDate();
+const fractionToMillisAndNanos = (fraction = "")=>{
+    const nine = fraction.padEnd(9, "0");
+    return [
+        parseInt(nine.slice(0, 3), 10),
+        parseInt(nine.slice(3), 10)
+    ];
+};
+const parseTemporalInput = (input, { kind, encoding, precision, timeZone }, baseValue)=>{
+    if (epochDigitsPattern.test(input)) return EpochTimestamp.fromWire(input.trim(), encoding);
+    const base = baseValue?.getFields(timeZone);
+    const keepNanos = "ns" === precision;
+    if ("time" === kind) {
+        const match = timeInputPattern.exec(input);
+        if (match) {
+            const [, h, m, s = "0", fraction] = match;
+            const hour = parseInt(h, 10);
+            const minute = parseInt(m, 10);
+            const second = parseInt(s, 10);
+            if (hour > 23 || minute > 59 || second > 59) return;
+            const [millisecond, nanos] = fractionToMillisAndNanos(fraction);
+            const { year, month, day } = base ?? resolveRelativeDate("today", timeZone);
+            return EpochTimestamp.fromFields({
+                year,
+                month,
+                day,
+                hour,
+                minute,
+                second,
+                millisecond
+            }, timeZone, keepNanos ? nanos : 0);
+        }
+        return;
+    }
+    const match = dateTimeInputPattern.exec(input);
+    if (match) {
+        const [, y, mo, d, h, mi, s = "0", fraction] = match;
+        const year = parseInt(y, 10);
+        const month = parseInt(mo, 10);
+        const day = parseInt(d, 10);
+        if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return;
+        if (void 0 === h) {
+            if ("date" === kind && base && baseValue) {
+                const { hour, minute, second, millisecond } = base;
+                return EpochTimestamp.fromFields({
+                    year,
+                    month,
+                    day,
+                    hour,
+                    minute,
+                    second,
+                    millisecond
+                }, timeZone, baseValue.subMilliNanos);
+            }
+            return EpochTimestamp.fromFields({
+                year,
+                month,
+                day
+            }, timeZone);
+        }
+        const hour = parseInt(h, 10);
+        const minute = parseInt(mi, 10);
+        const second = parseInt(s, 10);
+        if (hour > 23 || minute > 59 || second > 59) return;
+        const [millisecond, nanos] = fractionToMillisAndNanos(fraction);
+        return EpochTimestamp.fromFields({
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            millisecond
+        }, timeZone, keepNanos ? nanos : 0);
+    }
+};
+const temporalInputPlaceholder = (kind)=>"date" === kind ? "yyyy-mm-dd" : "time" === kind ? "hh:mm:ss" : "yyyy-mm-dd hh:mm:ss";
+export { defaultFractionalSecondDigits, formatTemporalInput, getTemporalInfo, isTemporal, isTemporalTypeName, parseTemporalInput, temporalInputPlaceholder };

package/src/date/time-zone.js

@@ -0,0 +1,56 @@
+import { CalendarDate, CalendarDateTime, fromAbsolute, getLocalTimeZone, toCalendarDate, toZoned } from "@internationalized/date";
+let defaultTimeZone = "local";
+const setDefaultTimeZone = (timeZone)=>{
+    defaultTimeZone = timeZone;
+};
+const getDefaultTimeZone = ()=>defaultTimeZone;
+const resolveTimeZone = (timeZone = defaultTimeZone)=>"local" === timeZone ? getLocalTimeZone() : timeZone;
+const getDateTimeFields = (epochMillis, timeZone)=>{
+    const { year, month, day, hour, minute, second, millisecond } = fromAbsolute(epochMillis, resolveTimeZone(timeZone));
+    return {
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        millisecond
+    };
+};
+const fromDateTimeFields = ({ year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0 }, timeZone)=>toZoned(new CalendarDateTime(year, month, day, hour, minute, second, millisecond), resolveTimeZone(timeZone), "compatible").toDate().getTime();
+const calendarDateOf = (epochMillis, timeZone)=>toCalendarDate(fromAbsolute(epochMillis, resolveTimeZone(timeZone)));
+const startOfCalendarDay = (date, timeZone)=>toZoned(date, resolveTimeZone(timeZone)).toDate().getTime();
+const startOfDay = (epochMillis, timeZone)=>startOfCalendarDay(calendarDateOf(epochMillis, timeZone), timeZone);
+const startOfNextDay = (epochMillis, timeZone)=>startOfCalendarDay(calendarDateOf(epochMillis, timeZone).add({
+        days: 1
+    }), timeZone);
+const isStartOfDay = (epochMillis, timeZone)=>startOfDay(epochMillis, timeZone) === epochMillis;
+const isoDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+const resolveRelativeDate = (date = "today", timeZone)=>{
+    if (date instanceof Date) return calendarDateOf(date.getTime(), timeZone);
+    {
+        if ("today" === date) return calendarDateOf(Date.now(), timeZone);
+        if ("yesterday" === date) return calendarDateOf(Date.now(), timeZone).subtract({
+            days: 1
+        });
+        const match = isoDatePattern.exec(date);
+        if (match) return new CalendarDate(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
+        throw Error(`[time-zone] invalid date ${date}`);
+    }
+};
+const timeOfDayToEpochMillis = (timeString, date = "today", timeZone)=>{
+    const { year, month, day } = resolveRelativeDate(date, timeZone);
+    const [hms, fraction = ""] = timeString.split(".");
+    const [hour, minute, second] = hms.split(":").map((v)=>parseInt(v, 10));
+    const millisecond = parseInt(fraction.padEnd(3, "0").slice(0, 3), 10);
+    return fromDateTimeFields({
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        millisecond
+    }, timeZone);
+};
+export { fromDateTimeFields, getDateTimeFields, getDefaultTimeZone, isStartOfDay, resolveRelativeDate, resolveTimeZone, setDefaultTimeZone, startOfDay, startOfNextDay, timeOfDayToEpochMillis };

package/src/feature-utils.js

@@ -3,6 +3,12 @@ import { partition } from "./array-utils.js";
 import { getLayoutComponent } from "./component-registry.js";
 import { wordify } from "./text-utils.js";
 const env = process.env.NODE_ENV;
+const importFeatureByUrl = (url)=>import(/* @vite-ignore */ url);
+let featureImporter = importFeatureByUrl;
+const setFeatureImporter = (importer)=>{
+    featureImporter = importer;
+};
+const importFeature = (url)=>featureImporter(url);
 const isStaticFeature = (feature)=>null !== feature && "object" == typeof feature && "type" in feature;
 const isStaticFeatures = (features)=>Array.isArray(features) && features.every(isStaticFeature);
 function featureFromJson({ type }) {
@@ -83,4 +89,4 @@ const getCustomAndTableFeatures = (dynamicFeatures, tableSchemas)=>{
         tableFeatures: tableFeatures
     };
 };
-export { assertComponentRegistered, assertComponentsRegistered, byModule, env, featureFromJson, getCustomAndTableFeatures, getFilterTableFeatures, hasFilterTableFeatureProps, isCustomFeature, isSameTable, isStaticFeatures, isVuuTables, isWildcardSchema };
+export { assertComponentRegistered, assertComponentsRegistered, byModule, env, featureFromJson, getCustomAndTableFeatures, getFilterTableFeatures, hasFilterTableFeatureProps, importFeature, importFeatureByUrl, isCustomFeature, isSameTable, isStaticFeatures, isVuuTables, isWildcardSchema, setFeatureImporter };

package/src/filters/filter-utils.js

@@ -1,4 +1,6 @@
 import { ScaledDecimal } from "../ScaledDecimal.js";
+import { isTimeDataValueWithMilliseconds } from "../column-utils.js";
+import { getTemporalInfo } from "../date/temporal.js";
 const singleValueFilterOps = new Set([
     "=",
     "!=",
@@ -63,7 +65,14 @@ const collectFiltersForColumn = (filter, columnName)=>{
         filters: results
     };
 };
-const stringifyBoolean = (value)=>"boolean" == typeof value ? "${filter.value}" : value;
+const stringifyBoolean = (value)=>"boolean" == typeof value ? `${value}` : value;
+const getDefaultTimeRange = (column)=>isTimeDataValueWithMilliseconds(column) ? [
+        "00:00:00.000",
+        "23:59:59.999"
+    ] : [
+        "00:00:00",
+        "23:59:59"
+    ];
 const getColumnValueFromFilter = (column, operator, filter)=>{
     if (isSingleValueFilter(filter)) {
         if (filter.column === column.name) {
@@ -72,7 +81,7 @@ const getColumnValueFromFilter = (column, operator, filter)=>{
                 `${filter.value}`,
                 ""
             ];
-            else if ("<" === filter.op) return [
+            else if ("<" === filter.op || "<=" === filter.op) return [
                 "",
                 `${filter.value}`
             ];
@@ -97,10 +106,7 @@ const getColumnValueFromFilter = (column, operator, filter)=>{
         }
     }
     if (!operator.startsWith("between")) return "";
-    if ("time" === column.type) return [
-        "00:00:00",
-        "23:59:59"
-    ];
+    if (getTemporalInfo(column)?.kind === "time") return getDefaultTimeRange(column);
     return [
         "",
         ""
@@ -133,4 +139,4 @@ const filtersAreEqual = (f1, f2)=>{
     }
     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 };
+export { applyFilterToColumns, extractFilterForColumn, filtersAreEqual, getColumnValueFromFilter, getDefaultTimeRange, isAndFilter, isBetweenFilter, isBetweenOperator, isCompleteFilter, isExtendedFilter, isFilter, isFilterClause, isFilteredColumn, isInFilter, isMultiClauseFilter, isMultiValueFilter, isNamedFilter, isOrFilter, isScaledDecimalFilterClause, isSerializableFilter, isSingleValueFilter, isValidFilterClauseOp, stripFilterFromColumns };

package/src/filters/filterAsQuery.js

@@ -1,4 +1,6 @@
-import { isDateTimeDataValue } from "../column-utils.js";
+import { EpochTimestamp } from "../date/EpochTimestamp.js";
+import { getTemporalInfo } from "../date/temporal.js";
+import { isStartOfDay, startOfDay, startOfNextDay, timeOfDayToEpochMillis } from "../date/time-zone.js";
 import { stringIsValidLong } from "../data-utils.js";
 import { isMultiClauseFilter, isMultiValueFilter, isSerializableFilter } from "./filter-utils.js";
 import { ScaledDecimal } from "../ScaledDecimal.js";
@@ -8,7 +10,9 @@ const filterValue = (value, columnType)=>{
             const isNumericType = [
                 "int",
                 "long",
-                "double"
+                "double",
+                "epochtimestamp",
+                "epochtimestampnano"
             ].includes(columnType);
             return isNumericType ? value : `"${value}"`;
         }
@@ -24,64 +28,122 @@ const filterAsQueryCore = (f, opts)=>{
         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);
+    if (!isMultiValueFilter(f)) return singleValueFilterAsQuery(f, opts);
+    {
+        const column = opts?.columnsByName?.[f.column];
+        const temporalInfo = getTemporalInfo(column);
+        const values = f.values;
+        if (temporalInfo) {
+            const literals = values.map((v)=>EpochTimestamp.fromWire(v, temporalInfo.encoding)?.toLiteral(temporalInfo.encoding) ?? quotedStrings(v));
+            return `${f.column} ${f.op} [${literals.join(",")}]`;
+        }
+        return `${f.column} ${f.op} [${values.map(quotedStrings).join(",")}]`;
+    }
 };
 function singleValueFilterAsQuery(f, opts) {
     if (isSerializableFilter(f)) return f.asQuery();
     {
         const column = opts?.columnsByName?.[f.column];
-        if (column && isDateTimeDataValue(column)) return dateFilterAsQuery(f, opts);
+        const temporalInfo = getTemporalInfo(column);
+        if (temporalInfo) return temporalFilterAsQuery(f, temporalInfo);
         return defaultSingleValueFilterAsQuery(f, opts);
     }
 }
 const ONE_DAY_IN_MILLIS = 86400000;
-function dateFilterAsQuery(f, opts) {
-    switch(f.op){
+const timeOfDayPattern = /^\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?$/;
+const NANOS_PER_SECOND = 1000000000;
+const NANOS_PER_MILLI = 1000000;
+const resolveTemporalFilterValue = (value, { encoding, kind, timeZone }, date = "today")=>{
+    if ("string" == typeof value && timeOfDayPattern.test(value)) {
+        const [hms, fraction = ""] = value.split(".");
+        const millis = timeOfDayToEpochMillis(hms, date, timeZone);
+        const nanos = parseInt(fraction.padEnd(9, "0"), 10);
+        const ts = EpochTimestamp.fromMillis(millis + Math.floor(nanos / NANOS_PER_MILLI), "epochNanos" === encoding ? nanos % NANOS_PER_MILLI : 0);
+        const period = 10 ** (9 - Math.min(fraction.length, 9));
+        const unit = "epochNanos" === encoding ? 1 : NANOS_PER_MILLI;
+        return [
+            ts,
+            period > unit ? period : "exact"
+        ];
+    }
+    const ts = EpochTimestamp.fromWire(value instanceof ScaledDecimal ? value.asLong : value, encoding);
+    if (void 0 === ts) return [
+        void 0,
+        "exact"
+    ];
+    const isWholeDay = 0 === ts.subMilliNanos && isStartOfDay(ts.epochMillis, timeZone);
+    if ("date" === kind || "datetime" === kind && isWholeDay) return [
+        ts,
+        "day"
+    ];
+    if ("time" === kind && 0 === ts.subMilliNanos && ts.epochMillis % 1000 === 0) return [
+        ts,
+        NANOS_PER_SECOND
+    ];
+    return [
+        ts,
+        "exact"
+    ];
+};
+function temporalFilterAsQuery(f, temporalInfo, options) {
+    const { column, op } = f;
+    const { encoding, timeZone } = temporalInfo;
+    const [ts, granularity] = resolveTemporalFilterValue(f.value, temporalInfo, options?.date);
+    if (void 0 === ts) return `${column} ${op} ${filterValue(f.value, "long")}`;
+    if ("exact" === granularity) return `${column} ${op} ${ts.toLiteral(encoding)}`;
+    const [start, end] = "day" === granularity ? [
+        EpochTimestamp.fromMillis(startOfDay(ts.epochMillis, timeZone)),
+        EpochTimestamp.fromMillis(startOfNextDay(ts.epochMillis, timeZone))
+    ] : [
+        ts,
+        EpochTimestamp.fromNanos(ts.epochNanos + BigInt(granularity))
+    ];
+    const from = start.toLiteral(encoding);
+    const to = end.toLiteral(encoding);
+    switch(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
-                }, opts);
-            }
+            return `(${column} >= ${from} and ${column} < ${to})`;
         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
-                }, opts);
-            }
+            return `(${column} < ${from} or ${column} >= ${to})`;
+        case ">":
+            return `${column} >= ${to}`;
+        case ">=":
+            return `${column} >= ${from}`;
+        case "<":
+            return `${column} < ${from}`;
+        case "<=":
+            return `${column} < ${to}`;
         default:
-            return defaultSingleValueFilterAsQuery(f, opts);
+            return `${column} ${op} ${ts.toLiteral(encoding)}`;
     }
 }
+function dateFilterAsQuery(f, opts) {
+    const temporalInfo = getTemporalInfo(opts?.columnsByName?.[f.column] ?? {
+        type: "date/time"
+    });
+    return temporalFilterAsQuery(f, temporalInfo);
+}
 const defaultSingleValueFilterAsQuery = (f, opts)=>{
     const columnType = opts?.columnsByName?.[f.column]?.serverDataType;
     return `${f.column} ${f.op} ${filterValue(f.value, columnType)}`;
 };
-export { ONE_DAY_IN_MILLIS, dateFilterAsQuery, filterAsQuery };
+const getColumnsByName = (columns)=>columns.reduce((map, column)=>{
+        map[column.name] = column;
+        return map;
+    }, {});
+const getColumnsByNameForFilter = (tableSchema, columnsByName)=>{
+    if (void 0 === tableSchema) return columnsByName;
+    const result = {};
+    for (const column of tableSchema.columns)result[column.name] = {
+        ...column,
+        ...columnsByName?.[column.name]
+    };
+    if (columnsByName) for (const [name, column] of Object.entries(columnsByName))result[name] ??= column;
+    return result;
+};
+const filterRequiresResolution = (filter, columnsByName)=>{
+    if (isMultiClauseFilter(filter)) return filter.filters.some((f)=>filterRequiresResolution(f, columnsByName));
+    if (isSerializableFilter(filter)) return true;
+    return void 0 !== getTemporalInfo(columnsByName?.[filter.column]);
+};
+export { ONE_DAY_IN_MILLIS, dateFilterAsQuery, filterAsQuery, filterRequiresResolution, getColumnsByName, getColumnsByNameForFilter, temporalFilterAsQuery };

package/src/filters/index.js

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

package/src/filters/temporal-cell-filter.js

@@ -0,0 +1,63 @@
+import { dateTimePattern, defaultPatternsByType } from "../date/dateTimePattern.js";
+import { EpochTimestamp } from "../date/EpochTimestamp.js";
+import { formatTimestamp } from "../date/formatter.js";
+import { getTemporalInfo } from "../date/temporal.js";
+import { startOfDay } from "../date/time-zone.js";
+import { getFractionalSecondDigits, temporalFormatter } from "../formatting-utils.js";
+const pad2 = (n)=>`${n}`.padStart(2, "0");
+const getTemporalCellFilter = (column, value, columnFilter = false)=>{
+    const temporalInfo = getTemporalInfo(column);
+    if (void 0 === temporalInfo) return;
+    const { encoding, kind, timeZone } = temporalInfo;
+    const ts = EpochTimestamp.fromWire(value, encoding);
+    if (void 0 === ts) return;
+    const pattern = dateTimePattern(column.type, kind);
+    if ("date" === kind || columnFilter && "datetime" === kind || void 0 === pattern.time) {
+        const { date = defaultPatternsByType.date } = pattern;
+        const start = EpochTimestamp.fromMillis(startOfDay(ts.epochMillis, timeZone));
+        return {
+            label: formatTimestamp({
+                date
+            }, {
+                timeZone
+            })(ts),
+            op: "=",
+            value: `${start.toWire(encoding)}`
+        };
+    }
+    const digits = columnFilter ? "hh:mm:ss.ms" === pattern.time ? 3 : 0 : Math.max(0, Math.min(9, getFractionalSecondDigits(column, temporalInfo)));
+    const unit = "epochNanos" === encoding ? 1n : 1000000n;
+    const period = 10n ** BigInt(9 - digits);
+    const startNanos = ts.epochNanos - ts.epochNanos % period;
+    const start = EpochTimestamp.fromNanos(startNanos);
+    const label = columnFilter ? formatTimestamp(pattern, {
+        fractionalSecondDigits: digits,
+        timeZone
+    })(start) : temporalFormatter(column, temporalInfo)(start.toWire(encoding));
+    if ("time" === kind) {
+        const { hour, minute, second } = ts.getFields(timeZone);
+        const fraction = ts.fractionalSecond(digits);
+        return {
+            label,
+            op: "=",
+            value: `${pad2(hour)}:${pad2(minute)}:${pad2(second)}${fraction ? `.${fraction}` : ""}`
+        };
+    }
+    {
+        if (period <= unit) return {
+            label,
+            op: "=",
+            value: `${ts.toWire(encoding)}`
+        };
+        const end = EpochTimestamp.fromNanos(startNanos + period - unit);
+        return {
+            label,
+            op: "between-inclusive",
+            value: [
+                `${start.toWire(encoding)}`,
+                `${end.toWire(encoding)}`
+            ]
+        };
+    }
+};
+export { getTemporalCellFilter };

package/src/form-utils.js

@@ -1,5 +1,8 @@
 import { stringIsValidDecimal, stringIsValidInt, stringIsValidLong } from "./data-utils.js";
-import { Time, isValidTimeString } from "./date/index.js";
+import { Time, isValidTimeString, isValidTimeStringMillis, normaliseTimeString } from "./date/date-utils.js";
+import { getTemporalInfo, parseTemporalInput } from "./date/temporal.js";
+import { getDefaultTimeZone } from "./date/time-zone.js";
+import { isTypeDescriptor } from "./column-utils.js";
 import { queryClosest } from "./html-utils.js";
 import { ScaledDecimal2, ScaledDecimal4, ScaledDecimal6, ScaledDecimal8 } from "./ScaledDecimal.js";
 class DataValidationError extends Error {
@@ -19,7 +22,9 @@ const getFieldName = (target)=>{
 };
 const isNumber = (type, value)=>"number" === type;
 const isValidRange = ([val1, val2])=>{
-    if (isValidTimeString(val1) && isValidTimeString(val2)) return val2 > val1;
+    const time1 = normaliseTimeString(val1, true);
+    const time2 = normaliseTimeString(val2, true);
+    if (time1 && time2) return time2 > time1;
     return true;
 };
 function getTypedRange([value1, value2], dataType, options) {
@@ -38,11 +43,15 @@ function getTypedValue(value, type, throwIfInvalid = false, options) {
         case "int":
             if (stringIsValidInt(value)) return parseInt(value, 10);
             if (!throwIfInvalid) return;
-            throw Error(`value ${value} is not a valid ${type}`);
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "whole number", getActualType(value));
         case "long":
             if (stringIsValidLong(value)) return value;
             if (!throwIfInvalid) return;
-            throw Error(`value ${value} is not a valid ${type}`);
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "whole number", getActualType(value));
+        case "char":
+            if (1 === value.length) return value;
+            if (!throwIfInvalid) return;
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "single character", getActualType(value));
         case "scaleddecimal2":
             return ScaledDecimal2(value);
         case "scaleddecimal4":
@@ -58,8 +67,24 @@ function getTypedValue(value, type, throwIfInvalid = false, options) {
             throw new DataValidationError(`value ${value} is not a valid ${type}`, "decimal", getActualType(value));
         case "boolean":
             return "true" === value;
+        case "epochtimestamp":
+        case "epochtimestampnano":
+        case "date/time":
+        case "date":
+            {
+                const encoding = "epochtimestampnano" === type ? "epochNanos" : "epochMillis";
+                const timestamp = parseTemporalInput(value, {
+                    kind: "date" === type ? "date" : "datetime",
+                    encoding,
+                    precision: "epochNanos" === encoding ? "ns" : "ms",
+                    timeZone: getDefaultTimeZone()
+                });
+                if (timestamp) return timestamp.toWire(encoding);
+                if (!throwIfInvalid) return;
+                throw new DataValidationError(`value ${value} is not a valid ${type}`, "date/time", getActualType(value));
+            }
         case "time":
-            if (isValidTimeString(value)) if (options?.type === "TimeString") return value;
+            if (isValidTimeString(value) || isValidTimeStringMillis(value)) if (options?.type === "TimeString") return value;
             else return +Time(value).asDate();
             if (value.length > 0 && Time.isDateInMillis(value)) return Number(value);
             if (!throwIfInvalid) return;
@@ -68,4 +93,17 @@ function getTypedValue(value, type, throwIfInvalid = false, options) {
             return value;
     }
 }
-export { DataValidationError, getFieldName, getTypedRange, getTypedValue, isNumber, isValidRange };
+function getTypedTemporalValue(value, temporalInfo, throwIfInvalid = false, baseValue) {
+    if ("" === value) return;
+    const timestamp = parseTemporalInput(value, temporalInfo, baseValue);
+    if (timestamp) return timestamp.toWire(temporalInfo.encoding);
+    if (throwIfInvalid) throw new DataValidationError(`value ${value} is not a valid ${temporalInfo.kind}`, temporalInfo.kind, getActualType(value));
+}
+function getTypedValueForDescriptor(value, descriptor, throwIfInvalid = false) {
+    const temporalInfo = getTemporalInfo(descriptor);
+    if (temporalInfo) return getTypedTemporalValue(value, temporalInfo, throwIfInvalid);
+    const { serverDataType = "string", type } = descriptor;
+    const dataType = isTypeDescriptor(type) ? type.name : type ?? serverDataType;
+    return throwIfInvalid ? getTypedValue(value, dataType, true) : getTypedValue(value, dataType, false);
+}
+export { DataValidationError, getFieldName, getTypedRange, getTypedTemporalValue, getTypedValue, getTypedValueForDescriptor, isNumber, isValidRange };