@vuu-ui/vuu-utils 4.0.0-alpha.8 → 4.0.0-beta.1

package/package.json

@@ -1,10 +1,9 @@
 {
-  "version": "4.0.0-alpha.8",
+  "version": "4.0.0-beta.1",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
   "types": "types/index.d.ts",
-  "type": "module",
   "scripts": {
     "build:dev": "node ../../scripts/run-build.mjs",
     "build": "node ../../scripts/run-build-rslib.ts",
@@ -12,18 +11,18 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@salt-ds/core": "1.67.0"
+    "@salt-ds/core": "1.72.0"
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.8"
+    "@vuu-ui/vuu-data-types": "4.0.0-beta.1",
+    "@vuu-ui/vuu-table-types": "4.0.0-beta.1",
+    "@vuu-ui/vuu-filter-types": "4.0.0-beta.1",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-beta.1"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.8",
+    "@vuu-ui/vuu-filter-parser": "4.0.0-beta.1",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"
@@ -38,9 +37,11 @@
   "exports": {
     ".": {
       "import": "./src/index.js",
+      "default": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },
   "module": "./src/index.js",
-  "name": "@vuu-ui/vuu-utils"
+  "name": "@vuu-ui/vuu-utils",
+  "type": "module"
 }

package/src/array-utils.js

@@ -1,3 +1,4 @@
+const simpleIdentity = (a, b)=>a === b;
 function partition(array, test, pass = [], fail = []) {
     for(let i = 0, len = array.length; i < len; i++)(test(array[i], i) ? pass : fail).push(array[i]);
     return [
@@ -41,15 +42,15 @@ const moveItem = (items, fromIndex, toIndex)=>{
         }
     }
 };
-const getAddedItems = (currentItems, newItems)=>{
-    const isNew = (i)=>!currentItems?.includes(i);
+const getAddedItems = (currentItems, newItems, compareItems = simpleIdentity)=>{
     if (void 0 === currentItems) return newItems;
+    const isNew = (item)=>currentItems.every((currentItem)=>false === compareItems(item, currentItem));
     if (newItems.some(isNew)) return newItems.filter(isNew);
     return [];
 };
-const getRemovedItems = (currentItems, newItems)=>{
-    const isRemoved = (i)=>!newItems?.includes(i);
+const getRemovedItems = (currentItems, newItems, compareItems = simpleIdentity)=>{
     if (void 0 === newItems) return currentItems;
+    const isRemoved = (item)=>newItems.every((newItem)=>false === compareItems(item, newItem));
     if (currentItems.some(isRemoved)) return currentItems.filter(isRemoved);
     return [];
 };

package/src/column-utils.js

@@ -1,7 +1,8 @@
 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";
+const NO_HEADINGS = [];
 const DEFAULT_COL_WIDTH = 100;
 const DEFAULT_MAX_WIDTH = 250;
 const DEFAULT_MIN_WIDTH = 50;
@@ -44,14 +45,17 @@ const getRuntimeColumnWidth = (col, runtimeColumns)=>{
     if (runtimeColumn) return runtimeColumn.width;
     return DEFAULT_COL_WIDTH;
 };
-const applyRuntimeColumnWidthsToConfig = (tableConfig, columns)=>({
+const applyRuntimeColumnWidthsToConfig = (tableConfig, columns)=>{
+    const runtimeColumns = columns.flatMap((column)=>isGroupColumn(column) ? column.columns : column);
+    return {
         ...tableConfig,
-        columns: columns.map((column)=>({
+        columns: tableConfig.columns.map((column)=>({
                 ...column,
-                width: column.width ?? getRuntimeColumnWidth(column, columns)
+                width: runtimeColumns.find(({ name })=>name === column.name)?.width ?? column.width ?? DEFAULT_COL_WIDTH
             })),
         columnLayout: "manual"
-    });
+    };
+};
 const isValidColumnAlignment = (v)=>"left" === v || "right" === v;
 const isValidPinLocation = (v)=>isValidColumnAlignment(v) || "floating" === v || "" === v;
 const VUU_COLUMN_DATA_TYPES = [
@@ -77,22 +81,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;
@@ -297,7 +314,7 @@ const measurePinnedColumns = (columns, selectionEndSize)=>{
         unpinnedWidth
     };
 };
-const getTableHeadings = (columns, selectionBookendWidth = 0)=>{
+const getTableHeadings = (columns)=>{
     if (columns.some(hasHeadings)) {
         const maxHeadingDepth = columns.reduce((max, { heading })=>Math.max(max, heading?.length ?? 0), 0);
         let heading;
@@ -305,9 +322,8 @@ const getTableHeadings = (columns, selectionBookendWidth = 0)=>{
         let tableHeadingsRow;
         for(let level = 0; level < maxHeadingDepth; level++){
             tableHeadingsRow = [];
-            columns.forEach(({ heading: columnHeading = NO_HEADINGS, hidden, width })=>{
+            columns.forEach(({ heading: columnHeading = NO_HEADINGS, width })=>{
                 const label = columnHeading[level] ?? "";
-                if (hidden) return;
                 if (heading && heading.label === label) heading.width += width;
                 else {
                     heading = {
@@ -319,10 +335,6 @@ const getTableHeadings = (columns, selectionBookendWidth = 0)=>{
             });
             tableHeadings.push(tableHeadingsRow);
         }
-        if (selectionBookendWidth > 0) tableHeadings.forEach((tableHeading)=>{
-            tableHeading[0].width += selectionBookendWidth;
-            tableHeading[tableHeading.length - 1].width += selectionBookendWidth;
-        });
         return tableHeadings;
     }
     return NO_HEADINGS;
@@ -538,6 +550,7 @@ const getDefaultColumnType = (serverDataType)=>{
         case "boolean":
             return "boolean";
         case "epochtimestamp":
+        case "epochtimestampnano":
             return "date/time";
         default:
             return "string";
@@ -596,7 +609,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);
@@ -631,7 +644,7 @@ const getCalculatedColumnDetails = (column)=>{
             serverDataType: isVuuColumnDataType(serverDataType) ? serverDataType : void 0
         };
     }
-    throw Error('column.name is not a calculated column');
+    throw Error("column.name is nor a calculated column");
 };
 const setCalculatedColumnName = (column, name)=>{
     const [, type, expression] = column.name.split(":");
@@ -778,7 +791,7 @@ const stretchColumnsToFillAvailableSpace = (columns, availableWidth, totalWidth,
     return adjustedColumns;
 };
 const dataAndColumnUnchanged = (p, p1)=>p.column === p1.column && p.column.valueFormatter(p.dataRow[p.column.name]) === p1.column.valueFormatter(p1.dataRow[p1.column.name]);
-const dataColumnAndKeyUnchanged = (p, p1)=>p.column === p1.column && p.dataRow.key === p1.dataRow.key && p.dataRow.vuu_action === p1.dataRow.vuu_action && p.column.valueFormatter(p.dataRow[p.column.name]) === p1.column.valueFormatter(p1.dataRow[p1.column.name]);
+const dataColumnAndKeyUnchanged = (p, p1)=>p.column === p1.column && p.dataRow.key === p1.dataRow.key && p.column.valueFormatter(p.dataRow[p.column.name]) === p1.column.valueFormatter(p1.dataRow[p1.column.name]);
 const toColumnName = (column)=>column.name;
 const isStringColumn = (column)=>"string" === column.serverDataType;
 const columnByAriaIndex = (columns, ariaColIndex)=>{
@@ -789,4 +802,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, 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, isTemporalColumn, isTypeDescriptor } from "./column-utils.js";
 const containersSet = new Set();
 const viewsSet = new Set();
 const layoutComponentsMap = new Map();
@@ -76,7 +76,8 @@ function getEditRuleValidator(name) {
 }
 function dataCellRenderer(column) {
     if ("boolean" === column.serverDataType && !hasCustomRenderer(column.type)) return cellRenderersMap.get("checkbox-cell");
-    if (isDataValueEditable(column, "update") && !hasCustomRenderer(column.type)) return cellRenderersMap.get("input-cell");
+    if (column.editable && !hasCustomRenderer(column.type) && isTemporalColumn(column) && cellRenderersMap.has("temporal-input-cell")) return cellRenderersMap.get("temporal-input-cell");
+    if (column.editable && !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";