@vuu-ui/vuu-filters 3.4.1 → 3.5.0-beta.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.4.1",
+  "version": "3.5.0-beta.1",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
@@ -10,19 +10,19 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.4.1",
-    "@vuu-ui/vuu-protocol-types": "3.4.1",
-    "@vuu-ui/vuu-table-types": "3.4.1",
-    "@vuu-ui/vuu-filter-types": "3.4.1"
+    "@vuu-ui/vuu-data-types": "3.5.0-beta.1",
+    "@vuu-ui/vuu-protocol-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"
   },
   "dependencies": {
-    "@vuu-ui/vuu-context-menu": "3.4.1",
-    "@vuu-ui/vuu-data-react": "3.4.1",
-    "@vuu-ui/vuu-filter-parser": "3.4.1",
-    "@vuu-ui/vuu-popups": "3.4.1",
-    "@vuu-ui/vuu-ui-controls": "3.4.1",
-    "@vuu-ui/vuu-table": "3.4.1",
-    "@vuu-ui/vuu-utils": "3.4.1",
+    "@vuu-ui/vuu-context-menu": "3.5.0-beta.1",
+    "@vuu-ui/vuu-data-react": "3.5.0-beta.1",
+    "@vuu-ui/vuu-filter-parser": "3.5.0-beta.1",
+    "@vuu-ui/vuu-popups": "3.5.0-beta.1",
+    "@vuu-ui/vuu-ui-controls": "3.5.0-beta.1",
+    "@vuu-ui/vuu-table": "3.5.0-beta.1",
+    "@vuu-ui/vuu-utils": "3.5.0-beta.1",
     "@salt-ds/core": "1.54.1",
     "@salt-ds/lab": "1.0.0-alpha.83",
     "@salt-ds/styles": "0.2.1",

package/src/FilterAggregator.js

@@ -1,4 +1,4 @@
-import { getTypedRange, getTypedValue, isAndFilter, isBetweenFilter, isExtendedFilter, isMultiClauseFilter, isSingleValueFilter, isTypeDescriptor } from "@vuu-ui/vuu-utils";
+import { EpochTimestamp, getTemporalInfo, getTypedValueForDescriptor, isAndFilter, isBetweenFilter, isExtendedFilter, isMultiClauseFilter, isSingleValueFilter } from "@vuu-ui/vuu-utils";
 import { ExtendedSingleValueFilterClause } from "./filter-container/ExtendedSingleValueFilterClause.js";
 function installExtendedFilters(filter, throwIfUndefined = false) {
     if (void 0 !== filter) if (isExtendedFilter(filter)) {
@@ -12,6 +12,47 @@ function installExtendedFilters(filter, throwIfUndefined = false) {
     else return filter;
     if (throwIfUndefined) throw Error("filter is undefined");
 }
+const getExtendedFilterOptions = (temporalInfo, extendedFilterOptions)=>{
+    if (temporalInfo?.kind === "time") return {
+        type: "TimeString",
+        date: "today",
+        encoding: temporalInfo.encoding,
+        timeZone: temporalInfo.timeZone,
+        ...extendedFilterOptions
+    };
+    return extendedFilterOptions;
+};
+const getFilterValue = (column, value, temporalInfo, options, throwIfInvalid)=>{
+    if ("" === value) {
+        if (throwIfInvalid && !temporalInfo) return getTypedValueForDescriptor(value, column, true);
+        return;
+    }
+    if (options?.type === "TimeString") return asFilterTimeString(value, temporalInfo, throwIfInvalid);
+    return getTypedValueForDescriptor(value, column, throwIfInvalid);
+};
+const timeOfDayPattern = /^\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+const asFilterTimeString = (value, temporalInfo, throwIfInvalid)=>{
+    if (timeOfDayPattern.test(value)) return 5 === value.length ? `${value}:00` : value;
+    const timestamp = EpochTimestamp.fromWire(value, temporalInfo?.encoding ?? "epochMillis");
+    if (timestamp && /^\d+$/.test(value)) {
+        const { hour, minute, second } = timestamp.getFields(temporalInfo?.timeZone);
+        const pad = (n)=>`${n}`.padStart(2, "0");
+        return `${pad(hour)}:${pad(minute)}:${pad(second)}`;
+    }
+    if (throwIfInvalid) throw Error(`[FilterAggregator] value ${value} is not a valid time`);
+};
+const singleValueOps = [
+    "=",
+    "!=",
+    ">",
+    ">=",
+    "<",
+    "<=",
+    "contains",
+    "starts",
+    "ends"
+];
+const asSingleValueOp = (op)=>singleValueOps.includes(op) ? op : "=";
 class FilterAggregator {
     #filters = new Map();
     constructor(filter){
@@ -24,51 +65,29 @@ class FilterAggregator {
         });
     }
     add(column, value, op = "=", extendedFilterOptions) {
-        const { serverDataType = "string", type } = column;
+        const temporalInfo = getTemporalInfo(column);
+        const options = getExtendedFilterOptions(temporalInfo, extendedFilterOptions);
         const isInclusive = "between-inclusive" === op;
-        const dataType = isTypeDescriptor(type) ? type.name : type ?? serverDataType;
-        if (Array.isArray(value)) {
-            const [value1, value2] = getTypedRange(value, dataType, extendedFilterOptions);
-            if (void 0 !== value1 && void 0 !== value2) {
-                const filter = extendedFilterOptions ? {
-                    op: "and",
-                    filters: [
-                        new ExtendedSingleValueFilterClause(column.name, isInclusive ? ">=" : ">", value1, extendedFilterOptions),
-                        new ExtendedSingleValueFilterClause(column.name, isInclusive ? "<=" : "<", value2, extendedFilterOptions)
-                    ]
-                } : {
-                    op: "and",
-                    filters: [
-                        {
-                            column: column.name,
-                            op: ">",
-                            value: value1
-                        },
-                        {
-                            column: column.name,
-                            op: "<",
-                            value: value2
-                        }
-                    ]
-                };
-                this.#filters.set(column.name, filter);
-            } else if (void 0 !== value1) this.#filters.set(column.name, {
+        const createClause = (op, value)=>options ? new ExtendedSingleValueFilterClause(column.name, op, value, options) : {
                 column: column.name,
-                op: "=",
-                value: value1
-            });
-            else if (void 0 !== value2) this.#filters.set(column.name, {
-                column: column.name,
-                op: "<",
-                value: value2
+                op,
+                value
+            };
+        if (Array.isArray(value)) {
+            const [value1, value2] = value.map((v)=>getFilterValue(column, v, temporalInfo, options, false));
+            if (void 0 !== value1 && void 0 !== value2) this.#filters.set(column.name, {
+                op: "and",
+                filters: [
+                    createClause(isInclusive ? ">=" : ">", value1),
+                    createClause(isInclusive ? "<=" : "<", value2)
+                ]
             });
+            else if (void 0 !== value1) this.#filters.set(column.name, createClause("=", value1));
+            else if (void 0 !== value2) this.#filters.set(column.name, createClause(isInclusive ? "<=" : "<", value2));
         } else {
-            const typedValue = getTypedValue(value.toString(), dataType, true);
-            this.#filters.set(column.name, {
-                column: column.name,
-                op: "=",
-                value: typedValue
-            });
+            const typedValue = getFilterValue(column, value.toString(), temporalInfo, options, true);
+            if (void 0 === typedValue) this.#filters.delete(column.name);
+            else this.#filters.set(column.name, createClause(temporalInfo ? asSingleValueOp(op) : "=", typedValue));
         }
     }
     has({ name }) {

package/src/filter-clause/operator-picker/operator-utils.js

@@ -1,4 +1,4 @@
-import { isNumericColumn, isTextColumn, isTimestampColumn } from "@vuu-ui/vuu-utils";
+import { isNumericColumn, isTemporalColumn, isTextColumn } from "@vuu-ui/vuu-utils";
 const textOperators = [
     "=",
     "in",
@@ -17,7 +17,7 @@ const numericOperators = [
 ];
 const getOperators = (column)=>{
     if (isTextColumn(column)) return textOperators;
-    if (isNumericColumn(column) || isTimestampColumn(column)) return numericOperators;
+    if (isNumericColumn(column) || isTemporalColumn(column)) return numericOperators;
     throw Error("getOperators only supports text and numeric columns");
 };
 export { getOperators, numericOperators, textOperators };

package/src/filter-clause/value-editors/FilterClauseValueEditor.js

@@ -2,26 +2,29 @@ import { jsx } from "react/jsx-runtime";
 import clsx from "clsx";
 import { FilterClauseValueEditorNumber } from "./FilterClauseValueEditorNumber.js";
 import { FilterClauseValueEditorText } from "./FilterClauseValueEditorText.js";
-import { isDateTimeDataValue, isTimeDataValue } from "@vuu-ui/vuu-utils";
+import { getTemporalInfo } from "@vuu-ui/vuu-utils";
 import { forwardRef } from "react";
 import { FilterClauseValueEditorDate } from "./FilterClauseValueEditorDate.js";
 import { FilterClauseValueEditorTime } from "./FilterClauseValueEditorTime.js";
 const classBase = "vuuFilterClause";
 const FilterClauseValueEditor_FilterClauseValueEditor = /*#__PURE__*/ forwardRef(function({ selectedColumn, operator, inputProps, onChangeValue, onDeselectValue, onOpenChange, table, value, dropdownOnAutofocus = true }, forwardedRef) {
     if (void 0 === selectedColumn || void 0 === operator) return null;
-    if (isDateTimeDataValue(selectedColumn)) return /*#__PURE__*/ jsx(FilterClauseValueEditorDate, {
+    const temporalInfo = getTemporalInfo(selectedColumn);
+    if (temporalInfo?.kind === "time") return /*#__PURE__*/ jsx(FilterClauseValueEditorTime, {
         inputProps: inputProps,
         className: clsx(`${classBase}Field`, `${classBase}Value`),
         value: value,
         operator: operator,
-        onChangeValue: onChangeValue
+        onChangeValue: onChangeValue,
+        temporalInfo: temporalInfo
     });
-    if (isTimeDataValue(selectedColumn)) return /*#__PURE__*/ jsx(FilterClauseValueEditorTime, {
+    if (temporalInfo) return /*#__PURE__*/ jsx(FilterClauseValueEditorDate, {
         inputProps: inputProps,
         className: clsx(`${classBase}Field`, `${classBase}Value`),
         value: value,
         operator: operator,
-        onChangeValue: onChangeValue
+        onChangeValue: onChangeValue,
+        temporalInfo: temporalInfo
     });
     switch(selectedColumn.serverDataType){
         case "string":

package/src/filter-clause/value-editors/FilterClauseValueEditorDate.js

@@ -1,55 +1,23 @@
 import { jsx } from "react/jsx-runtime";
-import { useCallback, useState } from "react";
-import { getLocalTimeZone } from "@internationalized/date";
-import { toCalendarDate } from "@vuu-ui/vuu-utils";
+import { useCallback } from "react";
+import { EpochTimestamp } from "@vuu-ui/vuu-utils";
 import { VuuDatePicker } from "@vuu-ui/vuu-ui-controls";
-const FilterClauseValueEditorDate = (props)=>{
-    const { inputProps, className, onChangeValue, operator, value } = props;
-    const toEpochMilliS = getEpochMillisConverter(operator);
-    const [date, setDate] = useState(()=>getInitialState(value));
-    const handleCommit = useCallback((e, selectedDateInputValue)=>{
-        console.log("change date");
-        if (selectedDateInputValue) {
-            const dateValue = toCalendarDate(new Date(selectedDateInputValue));
-            setDate(dateValue);
-            if (selectedDateInputValue) onChangeValue(toEpochMilliS(dateValue));
-        }
+const FilterClauseValueEditorDate = ({ className, inputProps, onChangeValue, temporalInfo, value })=>{
+    const { encoding, timeZone } = temporalInfo;
+    const handleCommit = useCallback((_e, startOfDayMillis)=>{
+        const timestamp = EpochTimestamp.fromMillis(startOfDayMillis);
+        onChangeValue("epochNanos" === encoding ? timestamp.toWire("epochNanos") : timestamp.toWire("epochMillis"));
     }, [
-        onChangeValue,
-        toEpochMilliS
-    ]);
-    const onBlur = useCallback(()=>{
-        date && onChangeValue(toEpochMilliS(date));
-    }, [
-        date,
-        onChangeValue,
-        toEpochMilliS
+        encoding,
+        onChangeValue
     ]);
     return /*#__PURE__*/ jsx(VuuDatePicker, {
         "data-field": "value",
         inputProps: inputProps,
         className: className,
-        onBlur: onBlur,
         onCommit: handleCommit,
-        selectedDate: date
+        timeZone: timeZone,
+        value: EpochTimestamp.fromWire(value, encoding)
     });
 };
-function getInitialState(value) {
-    return value ? toCalendarDate(new Date(value)) : void 0;
-}
-const getEpochMillisConverter = (op)=>(date, timezone = getLocalTimeZone())=>{
-        const d = date.toDate(timezone);
-        switch(op){
-            case ">":
-            case "<=":
-                d.setHours(23, 59, 59, 999);
-                return d.getTime();
-            case ">=":
-            case "<":
-            case "=":
-            case "!=":
-                d.setHours(0, 0, 0, 0);
-                return d.getTime();
-        }
-    };
 export { FilterClauseValueEditorDate };

package/src/filter-clause/value-editors/FilterClauseValueEditorTime.js

@@ -1,53 +1,27 @@
 import { jsx } from "react/jsx-runtime";
-import { useCallback, useState } from "react";
-import { getLocalTimeZone } from "@internationalized/date";
-import { toCalendarDate } from "@vuu-ui/vuu-utils";
+import { useCallback } from "react";
+import { EpochTimestamp, isValidTimeString } from "@vuu-ui/vuu-utils";
 import { VuuTimePicker } from "@vuu-ui/vuu-ui-controls";
-const FilterClauseValueEditorTime = (props)=>{
-    const { className, onChangeValue, operator, value } = props;
-    const toEpochMilliS = getEpochMillisConverter(operator);
-    const [date, setDate] = useState(()=>getInitialState(value));
-    const handleCommit = useCallback((e, selectedDateInputValue)=>{
-        console.log("change time");
-        if (selectedDateInputValue) {
-            const dateValue = toCalendarDate(new Date(selectedDateInputValue));
-            setDate(dateValue);
-            if (selectedDateInputValue) onChangeValue(toEpochMilliS(dateValue));
-        }
-    }, [
-        onChangeValue,
-        toEpochMilliS
-    ]);
-    const onBlur = useCallback(()=>{
-        date && onChangeValue(toEpochMilliS(date));
+const pad = (n)=>`${n}`.padStart(2, "0");
+const toTimeString = (value, { encoding, timeZone })=>{
+    if (isValidTimeString(value)) return value;
+    const timestamp = EpochTimestamp.fromWire(value, encoding);
+    if (timestamp) {
+        const { hour, minute, second } = timestamp.getFields(timeZone);
+        return `${pad(hour)}:${pad(minute)}:${pad(second)}`;
+    }
+};
+const FilterClauseValueEditorTime = ({ className, onChangeValue, temporalInfo, value })=>{
+    const handleCommit = useCallback((_e, timeString)=>{
+        if (isValidTimeString(timeString)) onChangeValue(timeString);
     }, [
-        date,
-        onChangeValue,
-        toEpochMilliS
+        onChangeValue
     ]);
     return /*#__PURE__*/ jsx(VuuTimePicker, {
         "data-field": "value",
         className: className,
-        onBlur: onBlur,
+        defaultValue: toTimeString(value, temporalInfo),
         onCommit: handleCommit
     });
 };
-function getInitialState(value) {
-    return value ? toCalendarDate(new Date(value)) : void 0;
-}
-const getEpochMillisConverter = (op)=>(date, timezone = getLocalTimeZone())=>{
-        const d = date.toDate(timezone);
-        switch(op){
-            case ">":
-            case "<=":
-                d.setHours(23, 59, 59, 999);
-                return d.getTime();
-            case ">=":
-            case "<":
-            case "=":
-            case "!=":
-                d.setHours(0, 0, 0, 0);
-                return d.getTime();
-        }
-    };
 export { FilterClauseValueEditorTime };

package/src/filter-container/ExtendedSingleValueFilterClause.js

@@ -1,5 +1,6 @@
-import { Time, isValidTimeString } from "@vuu-ui/vuu-utils";
+import { getDefaultTimeZone, isValidTimeString, temporalFilterAsQuery } from "@vuu-ui/vuu-utils";
 const isTimeToday = (options)=>"TimeString" === options.type && "today" === options.date;
+const timeStringWithFraction = /^\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?$/;
 class ExtendedSingleValueFilterClause {
     column;
     op;
@@ -12,14 +13,27 @@ class ExtendedSingleValueFilterClause {
         this.#options = extendedOptions;
     }
     name;
+    get extendedOptions() {
+        return this.#options;
+    }
     asQuery() {
         const { column, op, value } = this;
-        if (isTimeToday(this.#options)) if (isValidTimeString(value)) {
-            const timeValue = +Time(value).asDate();
-            if (">=" === op) return `${column} > ${timeValue - 1}`;
-            if ("<=" === op) return `${column} < ${timeValue + 1}`;
-            return `${column} ${op} ${timeValue}`;
-        } else throw Error(`[ExtendedSingleValueFilterClause] invalid TimeStrong ${value}`);
+        const { date, encoding = "epochMillis", timeZone } = this.#options;
+        if ("TimeString" === this.#options.type) if ("string" == typeof value && (isValidTimeString(value) || timeStringWithFraction.test(value))) {
+            const temporalInfo = {
+                kind: "time",
+                encoding,
+                precision: "epochNanos" === encoding ? "ns" : "ms",
+                timeZone: timeZone ?? getDefaultTimeZone()
+            };
+            return temporalFilterAsQuery({
+                column,
+                op,
+                value
+            }, temporalInfo, {
+                date: date
+            });
+        } else throw Error(`[ExtendedSingleValueFilterClause] invalid TimeString ${value}`);
         throw Error("[ExtendedSingleValueFilterClause] unhandled extended filter type");
     }
     toJSON() {

package/src/filter-container/FilterContainer.js

@@ -4,7 +4,7 @@ import { useCallback, useMemo, useRef, useState } from "react";
 import { ColumnFilterContext, useFilterContainer, useFilterContext } from "./useFilterContainer.js";
 import { ColumnFilter } from "../column-filter/ColumnFilter.js";
 import { filterDescriptorHasFilter, isNullFilter, useSavedFilters } from "../filter-provider/FilterContext.js";
-import { filtersAreEqual, getColumnValueFromFilter, isBetweenOperator } from "@vuu-ui/vuu-utils";
+import { filtersAreEqual, getColumnValueFromFilter, getDefaultTimeRange, isBetweenOperator, isTimeDataValue } from "@vuu-ui/vuu-utils";
 import { useComponentCssInjection } from "@salt-ds/styles";
 import { useWindow } from "@salt-ds/window";
 import FilterContainer from "./FilterContainer.css";
@@ -25,10 +25,7 @@ const FilterContainerColumnFilter = ({ column, operator = "=", variant, ...props
         if (currentFilterRef.current.id !== currentFilter.id || !filtersAreEqual(currentFilterRef.current.filter, currentFilter.filter)) {
             currentFilterRef.current = currentFilter;
             if (isNullFilter(currentFilter) && notEmpty(valueRef.current)) {
-                if (Array.isArray(valueRef.current)) if ("time" === column.type) valueRef.current = [
-                    "00:00:00",
-                    "23:59:59"
-                ];
+                if (Array.isArray(valueRef.current)) if (isTimeDataValue(column)) valueRef.current = getDefaultTimeRange(column);
                 else valueRef.current = [
                     "",
                     ""

package/src/filter-pill/getFilterTooltipText.js

@@ -1,4 +1,4 @@
-import { dateTimePattern, defaultPatternsByType, filterAsQuery, formatDate, isDateTimeDataValue, isMultiClauseFilter } from "@vuu-ui/vuu-utils";
+import { filterAsQuery, formatTemporalFilterValue, isMultiClauseFilter, isTemporal } from "@vuu-ui/vuu-utils";
 import { filterClauses } from "../filter-utils.js";
 function applyFormatter(filter, formatter) {
     if ("value" in filter) return {
@@ -12,13 +12,7 @@ function applyFormatter(filter, formatter) {
 }
 function formatFilterValue(filter, columnsByName) {
     const column = columnsByName?.[filter.column];
-    if (column && isDateTimeDataValue(column)) {
-        const pattern = dateTimePattern(column.type);
-        const formatter = (n)=>formatDate({
-                date: pattern.date ?? defaultPatternsByType.date
-            })(new Date(n));
-        return applyFormatter(filter, formatter);
-    }
+    if (column && isTemporal(column)) return applyFormatter(filter, (value)=>formatTemporalFilterValue(value, column));
     return filter;
 }
 const getFilterAsFormattedText = (columnsByName)=>(filter)=>{

package/src/filter-utils.js

@@ -1,4 +1,4 @@
-import { Time, extractFilterForColumn, filtersAreEqual, isAndFilter, isBetweenFilter, isInFilter, isMultiClauseFilter, isMultiValueFilter, isOrFilter, isSingleValueFilter, isTimeDataValue, partition } from "@vuu-ui/vuu-utils";
+import { extractFilterForColumn, filtersAreEqual, formatTemporalFilterValue, isAndFilter, isBetweenFilter, isInFilter, isMultiClauseFilter, isMultiValueFilter, isOrFilter, isSingleValueFilter, isTemporal, partition } from "@vuu-ui/vuu-utils";
 const AND = "and";
 const EQUALS = "=";
 const GREATER_THAN = ">";
@@ -260,6 +260,7 @@ const getNumericFilter = (column, op, value)=>{
         value
     };
 };
+const formatValueForDisplay = (value, column)=>isTemporal(column) ? formatTemporalFilterValue(value, column) : value.toString();
 const getFilterClausesForDisplay = (filter, columns = [], clauses = [])=>{
     if (void 0 === filter) ;
     else if (isSingleValueFilter(filter)) {
@@ -268,7 +269,7 @@ const getFilterClausesForDisplay = (filter, columns = [], clauses = [])=>{
             const { name, label = name } = column;
             clauses.push([
                 label,
-                filter.value.toString()
+                formatValueForDisplay(filter.value, column)
             ]);
         } else clauses.push([
             filter.column,
@@ -277,17 +278,11 @@ const getFilterClausesForDisplay = (filter, columns = [], clauses = [])=>{
     } else if (isBetweenFilter(filter)) {
         const [f1, f2] = filter.filters;
         const column = columns.find((c)=>c.name === f1.column);
-        if (isTimeDataValue(column) && "number" == typeof f1.value && "number" == typeof f2.value) {
-            const { name, label = name } = column;
-            clauses.push([
-                label,
-                `${Time.millisToTimeString(f1.value)} - ${Time.millisToTimeString(f2.value)}`
-            ]);
-        } else if (column) {
+        if (column) {
             const { name, label = name } = column;
             clauses.push([
                 label,
-                `${f1.value} - ${f2.value}`
+                `${formatValueForDisplay(f1.value, column)} - ${formatValueForDisplay(f2.value, column)}`
             ]);
         } else clauses.push([
             f1.column,

package/src/quick-filters/useQuickFilters.js

@@ -1,4 +1,4 @@
-import { isNumericColumn, queryClosest } from "@vuu-ui/vuu-utils";
+import { getTypedValueForDescriptor, isNumericColumn, isTemporalColumn, queryClosest } from "@vuu-ui/vuu-utils";
 import { useCallback, useMemo, useRef } from "react";
 const findColumn = (columns, name)=>{
     const column = columns?.find((col)=>col.name === name);
@@ -38,6 +38,11 @@ const createFilterClause = ([identifier, value], availableColumns)=>{
     } else throw Error("columns must be provided for find operation");
     {
         const column = findColumn(availableColumns, identifier);
+        if (isTemporalColumn(column)) return {
+            column: identifier,
+            op: "=",
+            value: getTypedValueForDescriptor(value, column, true)
+        };
         if (!isNumericColumn(column)) return {
             column: identifier,
             op: "contains",

package/types/filter-clause/value-editors/FilterClauseValueEditorDate.d.ts

@@ -1,9 +1,20 @@
+import { type TemporalInfo } from "@vuu-ui/vuu-utils";
 import type { NumericFilterClauseOp } from "@vuu-ui/vuu-filter-types";
 import type { FilterClauseValueEditor } from "../filterClauseTypes";
 interface FilterClauseValueEditorDateProps extends Pick<FilterClauseValueEditor, "onChangeValue" | "inputProps"> {
     className?: string;
-    value: number | undefined;
     operator: NumericFilterClauseOp;
+    temporalInfo: TemporalInfo;
+    /**
+     * epoch value in the column encoding (millis number or nanos string)
+     */
+    value: number | string | undefined;
 }
-export declare const FilterClauseValueEditorDate: (props: FilterClauseValueEditorDateProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Date filter value editor. The value emitted is the start of the selected day
+ * (in the column time zone), in the column encoding. When the filter query is
+ * created, the clause is applied to the whole day e.g. '=' selects all values
+ * on that day, '>' selects all values after that day (see temporalFilterAsQuery).
+ */
+export declare const FilterClauseValueEditorDate: ({ className, inputProps, onChangeValue, temporalInfo, value, }: FilterClauseValueEditorDateProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/types/filter-clause/value-editors/FilterClauseValueEditorTime.d.ts

@@ -1,9 +1,20 @@
-import { NumericFilterClauseOp } from "@vuu-ui/vuu-filter-types";
-import { FilterClauseValueEditor } from "../filterClauseTypes";
+import { type TemporalInfo } from "@vuu-ui/vuu-utils";
+import type { NumericFilterClauseOp } from "@vuu-ui/vuu-filter-types";
+import type { FilterClauseValueEditor } from "../filterClauseTypes";
 interface FilterClauseValueEditorTimeProps extends Pick<FilterClauseValueEditor, "onChangeValue" | "inputProps"> {
     className?: string;
-    value: number | undefined;
     operator: NumericFilterClauseOp;
+    temporalInfo: TemporalInfo;
+    /**
+     * A TimeString (hh:mm:ss) or, for filters created by an earlier version,
+     * an epoch value.
+     */
+    value: number | string | undefined;
 }
-export declare const FilterClauseValueEditorTime: (props: FilterClauseValueEditorTimeProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Time filter value editor. Emits a TimeString value. When the filter query
+ * is created, the time is resolved against today's date (in the column time
+ * zone), so a saved filter always applies to the current day.
+ */
+export declare const FilterClauseValueEditorTime: ({ className, onChangeValue, temporalInfo, value, }: FilterClauseValueEditorTimeProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/types/filter-container/ExtendedSingleValueFilterClause.d.ts

@@ -4,6 +4,11 @@ export declare const isTimeToday: (options: ExtendedFilterOptions) => options is
 export interface SerializableFilter {
     asQuery: () => string;
 }
+/**
+ * A filter clause on a time of day value (TimeString). The time is resolved
+ * against a date ('today' by default) only when the query is created, so a
+ * persisted filter remains relative.
+ */
 export declare class ExtendedSingleValueFilterClause implements SerializableSingleValueFilterClause {
     #private;
     column: string;
@@ -11,6 +16,7 @@ export declare class ExtendedSingleValueFilterClause implements SerializableSing
     value: VuuRowDataItemType;
     constructor(column: string, op: SingleValueFilterClauseOp, value: VuuRowDataItemType, extendedOptions: ExtendedFilterOptions);
     name?: string | undefined;
+    get extendedOptions(): ExtendedFilterOptions;
     asQuery(): string;
     toJSON(): {
         column: string;

package/types/src/FilterAggregator.d.ts

@@ -1,28 +0,0 @@
-import { ColumnFilterValue, ExtendedFilterOptions, FilterClauseOp, FilterContainerFilter } from "@vuu-ui/vuu-filter-types";
-import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
-/**
- * Manages a filter that can be updated one clause at a time.
- * Works with FilterContainer to aggregate multiple filter
- * clauses edited via individual controls. It is just a wrapper
- * around a Map, does not support switching filters - create a
- * new FilterAggregator for a new filter.
- *
- */
-export declare class FilterAggregator {
-    #private;
-    constructor(filter?: FilterContainerFilter);
-    add(column: ColumnDescriptor, value: ColumnFilterValue, op?: FilterClauseOp | "between" | "between-inclusive", extendedFilterOptions?: ExtendedFilterOptions): void;
-    has({ name }: ColumnDescriptor): boolean;
-    get({ name }: ColumnDescriptor): FilterContainerFilter | undefined;
-    clear(): void;
-    /**
-     * Remove filter for this column. Return false if no filter found, otw true
-     */
-    remove(column: ColumnDescriptor): boolean;
-    get isEmpty(): boolean;
-    /**
-     * Count of the number of columns for which filters are stored
-     */
-    get count(): number;
-    get filter(): FilterContainerFilter | undefined;
-}

package/types/src/FilterModel.d.ts

@@ -1,44 +0,0 @@
-import { Filter, FilterClause, FilterClauseOp, FilterCombinatorOp } from "@vuu-ui/vuu-filter-types";
-import { EventEmitter } from "@vuu-ui/vuu-utils";
-export type FilterStatusChangeHandler = (isValid: boolean) => void;
-export type FilterChangeHandler = (filter: Partial<Filter>, isValid: boolean) => void;
-export type FilterClauseChangeHandler = (filter: Partial<FilterClause>, isValid: boolean) => void;
-export type FilterClauseModelEvents = {
-    filterClause: FilterClauseChangeHandler;
-    isValid: FilterStatusChangeHandler;
-};
-export type FilterModelEvents = {
-    filter: FilterChangeHandler;
-    isValid: FilterStatusChangeHandler;
-};
-export declare class FilterClauseModel extends EventEmitter<FilterClauseModelEvents> {
-    #private;
-    constructor(filterClause: Partial<FilterClause>);
-    get isValid(): boolean;
-    private setIsValid;
-    get column(): undefined | string;
-    set column(column: undefined | string);
-    get op(): "in" | import("@vuu-ui/vuu-filter-types").SingleValueFilterClauseOp | undefined;
-    setOp(op: undefined | FilterClauseOp): void;
-    setValue(value: undefined | string | string[] | number | number[] | boolean | boolean[], isFinal?: boolean): void;
-    asFilter(throwIfInvalid?: boolean): FilterClause;
-    commit(): void;
-}
-export declare class FilterModel extends EventEmitter<FilterModelEvents> {
-    #private;
-    constructor(filter?: Filter);
-    get isValid(): boolean;
-    private setIsValid;
-    addNewFilterClause(operator?: FilterCombinatorOp): void;
-    addFilterClause(filterClause?: Partial<FilterClause>): void;
-    removeFilterClause(filterClause: FilterClauseModel): void;
-    checkValidStatus(): void;
-    onFilterClauseChange: FilterChangeHandler;
-    onFilterClauseStatusChange: (isValid: boolean) => void;
-    getFilterClause(index: number): FilterClauseModel;
-    get op(): FilterCombinatorOp | undefined;
-    setOp(op: FilterCombinatorOp): void;
-    get filterClauses(): FilterClauseModel[];
-    get isMultiClauseFilter(): boolean;
-    asFilter(throwIfInvalid?: boolean): Filter;
-}