@vuu-ui/vuu-utils 4.0.0-alpha.17 → 4.0.0-alpha.19

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.17",
+  "version": "4.0.0-alpha.19",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -16,14 +16,14 @@
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.17",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.17"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.19",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.19"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.17",
+    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.19",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"

package/src/column-utils.js

@@ -1,4 +1,5 @@
 import { moveItem } from "./array-utils.js";
+import { getTemporalInfo } from "./date/temporal.js";
 import { queryClosest } from "./html-utils.js";
 const NO_HEADINGS = [];
 const SORT_ASC = "asc";
@@ -77,22 +78,35 @@ const fromServerDataType = (serverDataType)=>{
             return "number";
         case "boolean":
             return "boolean";
+        case "epochtimestamp":
+        case "epochtimestampnano":
+            return "date/time";
         default:
             return "string";
     }
 };
 const isNanoTimestampColumn = ({ serverDataType })=>"epochtimestampnano" === serverDataType;
 const isTimestampColumn = (column)=>"epochtimestamp" === column.serverDataType || isNanoTimestampColumn(column);
-const isNumericColumn = ({ serverDataType, type })=>{
+const isTemporalColumn = (column)=>void 0 !== getTemporalInfo(column);
+const isNumericColumn = (column)=>{
+    const { serverDataType, type } = column;
+    if (isTemporalColumn(column)) return false;
     if ("int" === serverDataType || "long" === serverDataType || "double" === serverDataType) return true;
     if ("string" == typeof type) return "number" === type;
     if ("string" == typeof type?.name) return type?.name === "number";
     return false;
 };
-const isDateTimeDataType = (column)=>(isTypeDescriptor(column.type) ? column.type.name : column.type) === "date/time";
+const isDateTimeDataType = (column)=>{
+    const typeName = isTypeDescriptor(column.type) ? column.type.name : column.type;
+    return "date/time" === typeName || "date" === typeName;
+};
 const isTimeDataType = (column)=>(isTypeDescriptor(column.type) ? column.type.name : column.type) === "time";
-const isDateTimeDataValue = (column)=>isTimestampColumn(column) || isDateTimeDataType(column);
-const isTimeDataValue = (column)=>(isTypeDescriptor(column?.type) ? column.type.name : column?.type) === "time";
+const isDateTimeDataValue = (column)=>{
+    const kind = getTemporalInfo(column)?.kind;
+    return "datetime" === kind || "date" === kind;
+};
+const isTimeDataValue = (column)=>getTemporalInfo(column)?.kind === "time";
+const isTimeDataValueWithMilliseconds = (column)=>isTimeDataValue(column) && isTypeDescriptor(column.type) && column.type.formatting?.pattern?.time === "hh:mm:ss.ms";
 const isPinned = (column)=>"string" == typeof column.pin;
 const hasHeadings = (column)=>Array.isArray(column.heading) && column.heading.length > 0;
 const isResizing = (column)=>column.resizing;
@@ -538,6 +552,7 @@ const getDefaultColumnType = (serverDataType)=>{
         case "boolean":
             return "boolean";
         case "epochtimestamp":
+        case "epochtimestampnano":
             return "date/time";
         default:
             return "string";
@@ -596,7 +611,7 @@ const getTypeFormattingFromColumn = (column)=>{
 };
 const assertAllColumnsAreIncludedInSubscription = (columns, columnNames)=>{
     const unsubscribedColumns = [];
-    for (const column of columns)if ("client" !== column.source && 'vuuAction' !== column.name && !columnNames?.includes(column.name)) unsubscribedColumns.push(column.name);
+    for (const column of columns)if ("client" !== column.source && "vuuAction" !== column.name && !columnNames?.includes(column.name)) unsubscribedColumns.push(column.name);
     if (unsubscribedColumns.length > 0) throw Error(`[column-utils] assertAllColumnsAreIncludedInSubscription columns not included in subscription: ${unsubscribedColumns.join(", ")}`);
 };
 const subscribedOnly = (columnNames)=>(column)=>"client" === column.source || columnNames?.includes(column.name);
@@ -789,4 +804,4 @@ const columnByAriaIndex = (columns, ariaColIndex)=>{
     }
     throw Error(`no column with aria-colIndex ${ariaColIndex}`);
 };
-export { AggregationType, NO_HEADINGS, addColumnToSubscribedColumns, applyDefaultColumnConfig, applyGroupByToColumns, applyRuntimeColumnWidthsToConfig, applySortToColumns, applyWidthToColumns, assertAllColumnsAreIncludedInSubscription, buildColumnMap, checkConfirmationPending, columnByAriaIndex, dataAndColumnUnchanged, dataColumnAndKeyUnchanged, dataSourceRowToDataRowDto, existingSort, extractGroupColumn, findColumn, flattenColumnGroup, fromServerDataType, getAllCellsInColumn, getAriaColIndex, getAriaRowIndex, getCalculatedColumnDetails, getColumnLabel, getColumnName, getColumnStyle, getColumnsInViewport, getDefaultAlignment, getDefaultColumnType, getGroupIcon, getGroupValue, getPinStateFromElement, getRuntimeColumnWidth, getServerDataType, getTableHeadings, getTypeFormattingFromColumn, hasCustomRenderer, hasHeadings, hasValidationRules, isCalculatedColumn, isColumnTypeRenderer, isDataLoading, isDataValueEditable, isDateTimeDataType, isDateTimeDataValue, isGroupColumn, isJsonAttribute, isJsonColumn, isJsonGroup, isLookupRenderer, isMappedValueTypeRenderer, isNanoTimestampColumn, isNotHidden, isNumericColumn, isPinned, isResizing, isStringColumn, isTextColumn, isTimeDataType, isTimeDataValue, isTimestampColumn, isTypeDescriptor, isValidColumnAlignment, isValidPinLocation, isValueListRenderer, isVuuColumnDataType, mapSortCriteria, measurePinnedColumns, metadataKeys, moveColumnTo, projectUpdates, removeSort, replaceColumn, setAggregations, setCalculatedColumnExpression, setCalculatedColumnName, setCalculatedColumnType, sortPinnedColumns, subscribedOnly, toColumnDescriptor, toColumnName, toDataSourceColumns, updateColumn, updateColumnFormatting, updateColumnRenderProps, updateColumnType, visibleColumnAtIndex };
+export { AggregationType, NO_HEADINGS, addColumnToSubscribedColumns, applyDefaultColumnConfig, applyGroupByToColumns, applyRuntimeColumnWidthsToConfig, applySortToColumns, applyWidthToColumns, assertAllColumnsAreIncludedInSubscription, buildColumnMap, checkConfirmationPending, columnByAriaIndex, dataAndColumnUnchanged, dataColumnAndKeyUnchanged, dataSourceRowToDataRowDto, existingSort, extractGroupColumn, findColumn, flattenColumnGroup, fromServerDataType, getAllCellsInColumn, getAriaColIndex, getAriaRowIndex, getCalculatedColumnDetails, getColumnLabel, getColumnName, getColumnStyle, getColumnsInViewport, getDefaultAlignment, getDefaultColumnType, getGroupIcon, getGroupValue, getPinStateFromElement, getRuntimeColumnWidth, getServerDataType, getTableHeadings, getTypeFormattingFromColumn, hasCustomRenderer, hasHeadings, hasValidationRules, isCalculatedColumn, isColumnTypeRenderer, isDataLoading, isDataValueEditable, isDateTimeDataType, isDateTimeDataValue, isGroupColumn, isJsonAttribute, isJsonColumn, isJsonGroup, isLookupRenderer, isMappedValueTypeRenderer, isNanoTimestampColumn, isNotHidden, isNumericColumn, isPinned, isResizing, isStringColumn, isTemporalColumn, isTextColumn, isTimeDataType, isTimeDataValue, isTimeDataValueWithMilliseconds, isTimestampColumn, isTypeDescriptor, isValidColumnAlignment, isValidPinLocation, isValueListRenderer, isVuuColumnDataType, mapSortCriteria, measurePinnedColumns, metadataKeys, moveColumnTo, projectUpdates, removeSort, replaceColumn, setAggregations, setCalculatedColumnExpression, setCalculatedColumnName, setCalculatedColumnType, sortPinnedColumns, subscribedOnly, toColumnDescriptor, toColumnName, toDataSourceColumns, updateColumn, updateColumnFormatting, updateColumnRenderProps, updateColumnType, visibleColumnAtIndex };

package/src/component-registry.js

@@ -1,4 +1,4 @@
-import { hasCustomRenderer, isColumnTypeRenderer, isDataValueEditable, isTypeDescriptor } from "./column-utils.js";
+import { hasCustomRenderer, isColumnTypeRenderer, isDataValueEditable, isTemporalColumn, isTypeDescriptor } from "./column-utils.js";
 const containersSet = new Set();
 const viewsSet = new Set();
 const layoutComponentsMap = new Map();
@@ -76,6 +76,7 @@ function getEditRuleValidator(name) {
 }
 function dataCellRenderer(column) {
     if ("boolean" === column.serverDataType && !hasCustomRenderer(column.type)) return cellRenderersMap.get("checkbox-cell");
+    if (column.editable && !hasCustomRenderer(column.type) && isTemporalColumn(column) && cellRenderersMap.has("temporal-input-cell")) return cellRenderersMap.get("temporal-input-cell");
     if (isDataValueEditable(column, "update") && !hasCustomRenderer(column.type)) return cellRenderersMap.get("input-cell");
     if (isTypeDescriptor(column.type) && isColumnTypeRenderer(column.type.renderer)) return cellRenderersMap.get(column.type.renderer?.name);
     if ("boolean" === column.serverDataType) return cellRenderersMap.get("checkbox-cell");

package/src/data-utils.js

@@ -56,6 +56,7 @@ const dataDescriptorTypeToVuuRowDataItemType = ({ serverDataType = "string" })=>
         case "double":
         case "int":
         case "long":
+        case "epochtimestamp":
             return "number";
         case "boolean":
             return "boolean";

package/src/datasource/BaseDataSource.js

@@ -3,7 +3,7 @@ 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";
+import { filterAsQuery, getColumnsByNameForFilter } from "../filters/index.js";
 const defaultSuspenseProps = {
     escalateToDisable: true
 };
@@ -88,9 +88,11 @@ class BaseDataSource extends EventEmitter {
             filterSpec: filter
         };
     }
-    setFilter(filter) {
+    setFilter(filter, options) {
         const dataSourceFilter = {
-            filter: filterAsQuery(filter),
+            filter: filterAsQuery(filter, {
+                columnsByName: getColumnsByNameForFilter(this.tableSchema, options?.columnsByName)
+            }),
             filterStruct: filter
         };
         this.filter = dataSourceFilter;

package/src/date/EpochTimestamp.js

@@ -0,0 +1,85 @@
+import { fromDateTimeFields, getDateTimeFields } from "./time-zone.js";
+const NANOS_PER_MILLI = 1000000n;
+const integerPattern = /^-?\d+$/;
+const MAX_EPOCH_MILLIS = 8.64e15;
+class EpochTimestamp {
+    epochMillis;
+    subMilliNanos;
+    constructor(epochMillis, subMilliNanos = 0){
+        this.epochMillis = epochMillis;
+        this.subMilliNanos = subMilliNanos;
+    }
+    static fromMillis(epochMillis, subMilliNanos = 0) {
+        const millis = Math.floor(epochMillis);
+        return new EpochTimestamp(millis, subMilliNanos);
+    }
+    static fromNanos(epochNanos) {
+        const nanos = "bigint" == typeof epochNanos ? epochNanos : BigInt(epochNanos);
+        let millis = nanos / NANOS_PER_MILLI;
+        let remainder = nanos % NANOS_PER_MILLI;
+        if (remainder < 0n) {
+            millis -= 1n;
+            remainder += NANOS_PER_MILLI;
+        }
+        return new EpochTimestamp(Number(millis), Number(remainder));
+    }
+    static fromDate(date) {
+        return new EpochTimestamp(date.getTime());
+    }
+    static fromFields(fields, timeZone, subMilliNanos = 0) {
+        return new EpochTimestamp(fromDateTimeFields(fields, timeZone), subMilliNanos);
+    }
+    static isEmpty(value) {
+        return null == value || "" === value || 0 === value || "0" === value || 0n === value;
+    }
+    static fromWire(value, encoding) {
+        const ts = EpochTimestamp.decode(value, encoding);
+        return void 0 !== ts && Math.abs(ts.epochMillis) <= MAX_EPOCH_MILLIS ? ts : void 0;
+    }
+    static decode(value, encoding) {
+        if (EpochTimestamp.isEmpty(value)) return;
+        if (value instanceof EpochTimestamp) return value;
+        if ("epochNanos" === encoding) {
+            if ("bigint" == typeof value) return EpochTimestamp.fromNanos(value);
+            else if ("string" == typeof value && integerPattern.test(value)) return EpochTimestamp.fromNanos(value);
+            else if ("number" == typeof value && Number.isFinite(value)) return EpochTimestamp.fromNanos(BigInt(Math.trunc(value)));
+        } else if ("number" == typeof value && Number.isFinite(value)) return EpochTimestamp.fromMillis(value);
+        else if ("bigint" == typeof value) return EpochTimestamp.fromMillis(Number(value));
+        else if ("string" == typeof value && integerPattern.test(value)) return EpochTimestamp.fromMillis(Number(value));
+    }
+    get epochNanos() {
+        return BigInt(this.epochMillis) * NANOS_PER_MILLI + BigInt(this.subMilliNanos);
+    }
+    toDate() {
+        return new Date(this.epochMillis);
+    }
+    fractionalSecond(digits) {
+        if (digits <= 0) return "";
+        const millisOfSecond = (this.epochMillis % 1000 + 1000) % 1000;
+        const nineDigits = `${millisOfSecond}`.padStart(3, "0").concat(`${this.subMilliNanos}`.padStart(6, "0"));
+        return nineDigits.slice(0, Math.min(digits, 9));
+    }
+    getFields(timeZone) {
+        return getDateTimeFields(this.epochMillis, timeZone);
+    }
+    toWire(encoding) {
+        return "epochNanos" === encoding ? this.epochNanos.toString() : this.epochMillis;
+    }
+    toLiteral(encoding) {
+        return `${this.toWire(encoding)}`;
+    }
+    addUnits(units, encoding) {
+        return "epochNanos" === encoding ? EpochTimestamp.fromNanos(this.epochNanos + BigInt(units)) : EpochTimestamp.fromMillis(this.epochMillis + units, this.subMilliNanos);
+    }
+    compare(other) {
+        return this.epochMillis === other.epochMillis ? this.subMilliNanos - other.subMilliNanos : this.epochMillis - other.epochMillis;
+    }
+    equals(other) {
+        return void 0 !== other && 0 === this.compare(other);
+    }
+    toString() {
+        const fraction = this.subMilliNanos ? this.fractionalSecond(9) : this.fractionalSecond(3);
+        return this.toDate().toISOString().replace(/\.\d{3}Z$/, `.${fraction}Z`);
+    }
+}
+export { EpochTimestamp };

package/src/date/date-utils.js

@@ -3,50 +3,71 @@ function toCalendarDate(d) {
     return new CalendarDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
 }
 const zeroTime = "00:00:00";
+const zeroTimeMillis = "00:00:00.000";
 const zeroTimeUnit = "00";
+const unitMaxValue = {
+    hours: 23,
+    minutes: 59,
+    seconds: 59,
+    milliseconds: 999
+};
+const unitLength = (unit)=>"milliseconds" === unit ? 3 : 2;
 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;
+    const newValue = num >= unitMaxValue[unit] ? 0 : num + 1;
+    return `${newValue}`.padStart(unitLength(unit), "0");
 }
 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;
+    const newValue = num <= 0 ? unitMaxValue[unit] : num - 1;
+    return `${newValue}`.padStart(unitLength(unit), "0");
 }
 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;
+    const newTimeString = "hours" === unit ? value.concat(timeString.slice(2)) : "minutes" === unit ? timeString.slice(0, 3).concat(value).concat(timeString.slice(5)) : "seconds" === unit ? timeString.slice(0, 6).concat(value).concat(timeString.slice(8)) : timeString.slice(0, 9).concat(value);
+    if (isValidTimeString(newTimeString) || isValidTimeStringMillis(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 validTimePattern = /^(?:[0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/;
+const validTimeMillisPattern = /^(?:[0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]\.[0-9]{3}$/;
 const isValidTimeString = (value)=>"string" == typeof value && validTimePattern.test(value);
+const isValidTimeStringMillis = (value)=>"string" == typeof value && validTimeMillisPattern.test(value);
+function normaliseTimeString(value, milliseconds = false) {
+    if (isValidTimeString(value)) return milliseconds ? `${value}.000` : value;
+    if (isValidTimeStringMillis(value)) return milliseconds ? value : value.slice(0, 8);
+}
 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 (isValidTimeStringMillis(value)) return value.slice(0, 8);
     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`);
 }
+function asTimeStringMillis(value, allowUndefined = false) {
+    if (void 0 === value) if (allowUndefined) return value;
+    else throw Error("[date-utils] asTimeStringMillis, value cannot be undefined");
+    const timeString = normaliseTimeString(value, true);
+    if (timeString) return timeString;
+    if ("number" == typeof value) return Time.millisToTimeStringMillis(value);
+    if ("string" == typeof value && /^\d+$/.test(value)) return Time.millisToTimeStringMillis(parseInt(value));
+    throw Error(`[date-utils] asTimeStringMillis, value ${value} is not valid TimeStringMillis`);
+}
 const padZero = (val)=>`${val}`.padStart(2, "0");
 class TimeImpl {
     #hours;
     #minutes;
     #seconds;
+    #milliseconds;
     constructor(timeString){
-        const [hours, minutes, seconds] = timeString.split(":");
+        const [hours, minutes, secondsAndMillis] = timeString.split(":");
+        const [seconds, milliseconds] = secondsAndMillis.split(".");
         this.#hours = parseInt(hours);
         this.#minutes = parseInt(minutes);
         this.#seconds = parseInt(seconds);
+        this.#milliseconds = void 0 === milliseconds ? void 0 : parseInt(milliseconds);
     }
     get hours() {
         return this.#hours;
@@ -57,24 +78,35 @@ class TimeImpl {
     get seconds() {
         return this.#seconds;
     }
+    get milliseconds() {
+        return this.#milliseconds ?? 0;
+    }
     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);
+        dt.setMilliseconds(this.milliseconds);
         return dt;
     }
     toString() {
-        return Time.toString(this.#hours, this.#minutes, this.#seconds);
+        return Time.toString(this.#hours, this.#minutes, this.#seconds, this.#milliseconds);
     }
 }
 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.millisToTimeStringMillis = (timestamp)=>{
+    const date = new Date(timestamp);
+    return `${date.toTimeString().slice(0, 8)}.${`${date.getMilliseconds()}`.padStart(3, "0")}`;
+};
+function timeToString(hours, minutes, seconds, milliseconds) {
+    const timeString = `${padZero(hours)}:${padZero(minutes)}:${padZero(seconds)}`;
+    return void 0 === milliseconds ? timeString : `${timeString}.${`${milliseconds}`.padStart(3, "0")}`;
+}
+Time.toString = timeToString;
 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 };
+export { Time, asTimeString, asTimeStringMillis, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, isValidTimeStringMillis, normaliseTimeString, toCalendarDate, updateTimeString, zeroTime, zeroTimeMillis, zeroTimeUnit };

package/src/date/dateTimePattern.js

@@ -1,4 +1,4 @@
-import { isTypeDescriptor } from "../column-utils.js";
+import { getTemporalInfo } from "./temporal.js";
 import { isDateTimePattern } from "./types.js";
 const defaultPatternsByType = {
     time: "hh:mm:ss",
@@ -8,10 +8,38 @@ const fallbackDateTimePattern = {
     date: defaultPatternsByType["date"],
     time: defaultPatternsByType["time"]
 };
-function dateTimePattern(type) {
-    if (isTypeDescriptor(type)) {
+const defaultDateTimePatternByKind = {
+    date: {
+        date: defaultPatternsByType.date
+    },
+    datetime: fallbackDateTimePattern,
+    time: {
+        time: defaultPatternsByType.time
+    }
+};
+const kindFromType = (type)=>{
+    const typeName = "string" == typeof type ? type : type?.name;
+    return "time" === typeName ? "time" : "date" === typeName ? "date" : "date/time" === typeName ? "datetime" : void 0;
+};
+function dateTimePattern(type, kind = kindFromType(type)) {
+    if ("object" == typeof type && null !== type) {
         if (type.formatting && isDateTimePattern(type.formatting.pattern)) return type.formatting.pattern;
     }
-    return fallbackDateTimePattern;
+    return kind ? defaultDateTimePatternByKind[kind] : fallbackDateTimePattern;
 }
-export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern };
+const withDateTimePattern = (descriptor, pattern)=>{
+    if (void 0 === pattern || void 0 === getTemporalInfo(descriptor)) return descriptor;
+    const name = pattern.date && pattern.time ? "date/time" : pattern.date ? "date" : "time";
+    const formatting = "object" == typeof descriptor.type ? descriptor.type.formatting : void 0;
+    return {
+        ...descriptor,
+        type: {
+            name,
+            formatting: {
+                ...formatting,
+                pattern
+            }
+        }
+    };
+};
+export { dateTimePattern, defaultDateTimePatternByKind, defaultPatternsByType, fallbackDateTimePattern, withDateTimePattern };

package/src/date/formatter.js

@@ -1,4 +1,6 @@
 import { DateFormatter } from "@internationalized/date";
+import { EpochTimestamp } from "./EpochTimestamp.js";
+import { resolveTimeZone } from "./time-zone.js";
 const baseTimeFormatOptions = {
     hour: "2-digit",
     minute: "2-digit",
@@ -23,8 +25,7 @@ const formatConfigByTimePatterns = {
         locale: "en-GB",
         options: {
             ...baseTimeFormatOptions,
-            hour12: false,
-            fractionalSecondDigits: 3
+            hour12: false
         }
     }
 };
@@ -81,21 +82,58 @@ const formatConfigByDatePatterns = {
         }
     }
 };
-const dateFormatterISO = {
-    format: (date)=>new Date(date - 60000 * date.getTimezoneOffset()).toISOString().replace(/T.*/, "")
+const NARROW_NBSP = /\u202f/g;
+const intlFormatterCache = new Map();
+const getIntlFormatter = (locale, options)=>{
+    const key = `${locale}:${JSON.stringify(options)}`;
+    let formatter = intlFormatterCache.get(key);
+    if (void 0 === formatter) {
+        formatter = new Intl.DateTimeFormat(locale, options);
+        intlFormatterCache.set(key, formatter);
+    }
+    return formatter;
 };
-function getDateFormatter({ locale, options }) {
-    return new DateFormatter(locale, options);
+const isoDateFormatter = (timeZone)=>{
+    const formatter = getIntlFormatter("en-GB", {
+        ...baseDateFormatOptions,
+        month: "2-digit",
+        timeZone
+    });
+    return (ts)=>{
+        const parts = formatter.formatToParts(ts.toDate());
+        const get = (type)=>parts.find((p)=>p.type === type)?.value ?? "";
+        return `${get("year")}-${get("month")}-${get("day")}`;
+    };
+};
+const dateFormatter = (pattern, timeZone, localeOverride)=>{
+    const { locale, options } = formatConfigByDatePatterns[pattern];
+    const formatter = getIntlFormatter(localeOverride ?? locale, {
+        ...options,
+        timeZone
+    });
+    return (ts)=>formatter.format(ts.toDate());
+};
+const timeFormatter = (pattern, timeZone, fractionalSecondDigits, localeOverride)=>{
+    const { locale, options } = formatConfigByTimePatterns[pattern];
+    const formatter = getIntlFormatter(localeOverride ?? locale, {
+        ...options,
+        timeZone
+    });
+    return (ts)=>formatter.formatToParts(ts.toDate()).map(({ type, value })=>"second" === type && fractionalSecondDigits > 0 ? `${value}.${ts.fractionalSecond(fractionalSecondDigits)}` : value.replace(NARROW_NBSP, " ")).join("");
+};
+function formatTimestamp({ date, time }, { fractionalSecondDigits = "hh:mm:ss.ms" === time ? 3 : 0, locale, timeZone } = {}) {
+    const tz = resolveTimeZone(timeZone);
+    const formatters = [];
+    if ("yyyy-mm-dd" === date) formatters.push(isoDateFormatter(tz));
+    else if (date) formatters.push(dateFormatter(date, tz, locale));
+    if (time) formatters.push(timeFormatter(time, tz, fractionalSecondDigits, locale));
+    return (ts)=>formatters.map((f)=>f(ts)).join(" ");
 }
-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, options) {
+    const formatter = formatTimestamp(pattern, options);
+    return (d)=>formatter(EpochTimestamp.fromDate(d));
 }
-function formatDate(pattern) {
-    const formatters = getDateAndTimeFormatters(pattern);
-    return (d)=>formatters.map((f)=>f.format(d)).join(" ");
+function getDateFormatter({ locale, options }) {
+    return new DateFormatter(locale, options);
 }
-export { formatDate, getDateFormatter };
+export { formatDate, formatTimestamp, getDateFormatter };

package/src/date/index.js

@@ -1,4 +1,7 @@
 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 * from "./temporal.js";
+export * from "./time-zone.js";
+export { Time, asTimeString, asTimeStringMillis, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, isValidTimeStringMillis, normaliseTimeString, toCalendarDate, updateTimeString, zeroTime, zeroTimeMillis, zeroTimeUnit } from "./date-utils.js";
+export { dateTimePattern, defaultDateTimePatternByKind, defaultPatternsByType, fallbackDateTimePattern, withDateTimePattern } from "./dateTimePattern.js";
 export { dateTimeLabelByType, isDatePattern, isTimePattern, supportedDateTimePatterns } from "./types.js";
+export { EpochTimestamp } from "./EpochTimestamp.js";

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