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

package/package.json

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

package/src/date/dateTimePattern.js

@@ -1,3 +1,4 @@
+import { getTemporalInfo } from "./temporal.js";
 import { isDateTimePattern } from "./types.js";
 const defaultPatternsByType = {
     time: "hh:mm:ss",
@@ -26,4 +27,19 @@ function dateTimePattern(type, kind = kindFromType(type)) {
     }
     return kind ? defaultDateTimePatternByKind[kind] : fallbackDateTimePattern;
 }
-export { dateTimePattern, defaultDateTimePatternByKind, 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/index.js

@@ -2,6 +2,6 @@ export * from "./formatter.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 } from "./dateTimePattern.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/filters/filterAsQuery.js

@@ -51,15 +51,19 @@ function singleValueFilterAsQuery(f, opts) {
 }
 const ONE_DAY_IN_MILLIS = 86400000;
 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 / 1000000), "epochNanos" === encoding ? nanos % 1000000 : 0);
+        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,
-            fraction ? "exact" : "second"
+            period > unit ? period : "exact"
         ];
     }
     const ts = EpochTimestamp.fromWire(value instanceof ScaledDecimal ? value.asLong : value, encoding);
@@ -74,7 +78,7 @@ const resolveTemporalFilterValue = (value, { encoding, kind, timeZone }, date =
     ];
     if ("time" === kind && 0 === ts.subMilliNanos && ts.epochMillis % 1000 === 0) return [
         ts,
-        "second"
+        NANOS_PER_SECOND
     ];
     return [
         ts,
@@ -92,7 +96,7 @@ function temporalFilterAsQuery(f, temporalInfo, options) {
         EpochTimestamp.fromMillis(startOfNextDay(ts.epochMillis, timeZone))
     ] : [
         ts,
-        EpochTimestamp.fromMillis(ts.epochMillis + 1000)
+        EpochTimestamp.fromNanos(ts.epochNanos + BigInt(granularity))
     ];
     const from = start.toLiteral(encoding);
     const to = end.toLiteral(encoding);

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,60 @@
+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, dateOnly = 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 || dateOnly && "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 = 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 = 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/formatting-utils.js

@@ -8,12 +8,18 @@ import { roundDecimal, roundScaledDecimal } from "./round-decimal.js";
 import { isNumericType } from "./protocol-message-utils.js";
 const DEFAULT_NUMERIC_FORMAT = {};
 const defaultValueFormatter = (value)=>null == value ? "" : "string" == typeof value ? value : value.toString();
+const getFractionalSecondDigits = (column, temporalInfo = getTemporalInfo(column))=>{
+    if (void 0 === temporalInfo) return 0;
+    const pattern = dateTimePattern(column.type, temporalInfo.kind);
+    const formatting = isTypeDescriptor(column.type) ? column.type.formatting : void 0;
+    return formatting?.fractionalSecondDigits ?? ("hh:mm:ss.ms" === pattern.time ? 3 : "ns" === temporalInfo.precision && pattern.time ? 9 : 0);
+};
 const temporalFormatter = (column, temporalInfo = getTemporalInfo(column))=>{
     if (void 0 === temporalInfo) return defaultValueFormatter;
-    const { encoding, kind, precision, timeZone } = temporalInfo;
+    const { encoding, kind, timeZone } = temporalInfo;
     const formatting = isTypeDescriptor(column.type) ? column.type.formatting ?? DEFAULT_NUMERIC_FORMAT : DEFAULT_NUMERIC_FORMAT;
     const pattern = dateTimePattern(column.type, kind);
-    const fractionalSecondDigits = formatting.fractionalSecondDigits ?? ("hh:mm:ss.ms" === pattern.time ? 3 : "ns" === precision && pattern.time ? 9 : 0);
+    const fractionalSecondDigits = getFractionalSecondDigits(column, temporalInfo);
     const formatter = formatTimestamp(pattern, {
         fractionalSecondDigits,
         locale: formatting.locale,
@@ -70,4 +76,4 @@ const getValueFormatter = (column)=>{
     return defaultValueFormatter;
 };
 const lowerCase = (str)=>str.toLowerCase();
-export { defaultValueFormatter, formatTemporalFilterValue, getValueFormatter, lowerCase, numericFormatter, temporalFormatter };
+export { defaultValueFormatter, formatTemporalFilterValue, getFractionalSecondDigits, getValueFormatter, lowerCase, numericFormatter, temporalFormatter };

package/types/date/dateTimePattern.d.ts

@@ -1,5 +1,5 @@
-import type { DataValueType, DateTimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
-import type { TemporalKind } from "./temporal";
+import type { DataValueDescriptor, DataValueType, DateTimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
+import { type TemporalKind } from "./temporal";
 import { DateTimePattern } from "./types";
 export declare const defaultPatternsByType: {
     readonly time: "hh:mm:ss";
@@ -13,3 +13,14 @@ export declare const defaultDateTimePatternByKind: Record<TemporalKind, DateTime
  * is not provided, it is inferred from type name.
  */
 export declare function dateTimePattern(type?: DataValueType | DateTimeDataValueDescriptor["type"], kind?: TemporalKind | undefined): DateTimePattern;
+/**
+ * Returns a copy of a temporal descriptor, with its type replaced so that the
+ * value is displayed (or edited) using the given pattern. The type name follows
+ * the pattern: 'date/time' if both date and time are specified, else 'date' or
+ * 'time'. Other formatting (e.g. timeZone, locale) is preserved. The descriptor
+ * is returned unchanged if no pattern is provided or the descriptor is not
+ * temporal.
+ * Use this to present a column differently in different contexts, e.g. a
+ * ColumnFilter using a different pattern to the Table.
+ */
+export declare const withDateTimePattern: <T extends DataValueDescriptor>(descriptor: T, pattern?: DateTimePattern) => T;

package/types/date/index.d.ts

@@ -1,5 +1,5 @@
 export { asTimeString, asTimeStringMillis, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, isValidTimeStringMillis, normaliseTimeString, Time, toCalendarDate, type DateStringISO, type Hours, type Milliseconds, type Minutes, type Seconds, type TimeString, type TimeStringMillis, type TimeUnit, type TimeUnitValue, updateTimeString, zeroTime, zeroTimeMillis, zeroTimeUnit, } from "./date-utils";
-export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern, } from "./dateTimePattern";
+export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern, withDateTimePattern, } from "./dateTimePattern";
 export * from "./formatter";
 export { dateTimeLabelByType, isDatePattern, isTimePattern, supportedDateTimePatterns, type DatePattern, type DateTimePattern, type TimePattern, } from "./types";
 export { defaultDateTimePatternByKind } from "./dateTimePattern";

package/types/filters/filterAsQuery.d.ts

@@ -21,7 +21,10 @@ export interface TemporalFilterAsQueryOptions {
  *   day (in the column time zone), e.g as selected from a DatePicker. The clause
  *   applies to the whole day: '=' becomes a [startOfDay, startOfNextDay) range,
  *   '>' becomes '>= startOfNextDay' etc. Day boundaries are DST safe.
- * - second: time of day values (TimeString or whole second 'time' values)
+ * - period: time of day values (TimeString or whole second 'time' values). A
+ *   TimeString represents the period implied by its precision, e.g hh:mm:ss is
+ *   the whole second, hh:mm:ss.fff the whole millisecond (on a nanosecond
+ *   column), and is treated like the day granularity above.
  * - exact: all other values
  * Values are encoded according to the column encoding (millis or nanos).
  */

package/types/filters/index.d.ts

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

package/types/filters/temporal-cell-filter.d.ts

@@ -0,0 +1,24 @@
+import type { DataValueDescriptor } from "@vuu-ui/vuu-data-types";
+export interface TemporalCellFilter {
+    /** The value, formatted as displayed */
+    label: string;
+    op: "=" | "between-inclusive";
+    value: string | [string, string];
+}
+/**
+ * Describes a filter that matches a temporal value at the precision with which
+ * it is displayed by the given column descriptor, e.g. where the descriptor
+ * displays milliseconds, the filter matches the whole millisecond.
+ * - date (or dateOnly) => the whole day, as a start of day value
+ * - time => a time of day (TimeString), truncated to the displayed precision
+ * - datetime => a range, unless the displayed precision is that of the encoding
+ * The filter is suitable for FilterAggregator.add (with the same descriptor) and
+ * matches the value a ColumnFilter with this descriptor would commit.
+ *
+ * @param column the descriptor of the filter (or table cell) displaying the value
+ * @param value a value as received from the server
+ * @param dateOnly a 'datetime' value is displayed as a date (e.g. by a
+ * DatePicker). Ignored for 'time' descriptors.
+ * @returns undefined if value is empty or column is not temporal
+ */
+export declare const getTemporalCellFilter: (column: DataValueDescriptor, value: unknown, dateOnly?: boolean) => TemporalCellFilter | undefined;

package/types/formatting-utils.d.ts

@@ -1,9 +1,16 @@
 import { DataValueDescriptor } from "@vuu-ui/vuu-data-types";
-import { ColumnDescriptor, ValueFormatter } from "@vuu-ui/vuu-table-types";
+import { ColumnDescriptor, FractionalSecondDigits, ValueFormatter } from "@vuu-ui/vuu-table-types";
 export type ValueFormatters = {
     [key: string]: ValueFormatter;
 };
 export declare const defaultValueFormatter: (value: unknown) => string;
+/**
+ * The number of fractional second digits displayed for a temporal value:
+ * type.formatting.fractionalSecondDigits if set, otherwise 3 for an
+ * 'hh:mm:ss.ms' time pattern, 9 for a nanosecond column with any other time
+ * pattern, else 0.
+ */
+export declare const getFractionalSecondDigits: (column: DataValueDescriptor, temporalInfo?: import("./date/temporal").TemporalInfo | undefined) => FractionalSecondDigits;
 /**
  * Creates a formatter for a temporal value (see getTemporalInfo). Handles
  * millisecond and nanosecond encodings, the configured (or default) pattern,