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

package/src/filter-provider/FilterProvider.js

@@ -1,5 +1,5 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
 import { FilterNamePrompt } from "../saved-filters/FilterNamePrompt.js";
 import { DeleteFilterPrompt } from "../saved-filters/DeleteFilterPrompt.js";
 import { activateFilter, findFilter, insertOrReplaceFilter, renameFilter } from "./filter-descriptor-utils.js";
@@ -20,6 +20,17 @@ const FilterProvider = ({ children, onFiltersSaved, savedFilters: savedFiltersPr
         savedFiltersProp
     ]);
     const [dialog, setDialog] = useState(null);
+    const columnFilterColumnsRef = useRef(new Map());
+    const registerColumnFilterColumn = useCallback((key, column)=>{
+        const { current: columnsByKey } = columnFilterColumnsRef;
+        let columns = columnsByKey.get(key);
+        if (void 0 === columns) columnsByKey.set(key, columns = new Map());
+        columns.set(column.name, column);
+        return ()=>{
+            if (columns.get(column.name) === column) columns.delete(column.name);
+        };
+    }, []);
+    const getColumnFilterColumn = useCallback((key, columnName)=>columnFilterColumnsRef.current.get(key)?.get(columnName), []);
     const deleteFilter = useCallback((key, filterId)=>{
         const filterDescriptors = savedFilters.get(key);
         if (void 0 === filterDescriptors) throw Error(`[FilterProvider] deleteFilter, key ${key} not found`);
@@ -171,6 +182,8 @@ const FilterProvider = ({ children, onFiltersSaved, savedFilters: savedFiltersPr
     ]);
     return /*#__PURE__*/ jsxs(FilterContext.Provider, {
         value: {
+            getColumnFilterColumn,
+            registerColumnFilterColumn,
             onFilterMenuAction: handleFilterMenuAction,
             deleteFilter,
             saveFilter: handleSaveFilter,

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/index.js

@@ -13,7 +13,7 @@ export { useFilterContextMenu } from "./filter-context-menu/useFilterContextMenu
 export { FilterDisplay } from "./filter-display/FilterDisplay.js";
 export { FilterPanel } from "./filter-panel/FilterPanel.js";
 export { FilterPillNext } from "./filter-pill/FilterPillNext.js";
-export { NULL_FILTER, useSavedFilters } from "./filter-provider/FilterContext.js";
+export { NULL_FILTER, useColumnFilterRegistry, useSavedFilters } from "./filter-provider/FilterContext.js";
 export { FilterProvider } from "./filter-provider/FilterProvider.js";
 export { FilterNamePrompt as SaveFilterConfirmPrompt } from "./saved-filters/FilterNamePrompt.js";
 export { SavedFilterPanel } from "./saved-filters/SavedFilterPanel.js";

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/column-filter/ColumnFilter.d.ts

@@ -1,6 +1,19 @@
 import { type SegmentedButtonGroupProps } from "@salt-ds/core";
 import { DataItemEditControlProps } from "@vuu-ui/vuu-data-react";
 import { ColumnFilterHookProps } from "./useColumnFilter";
+import { type DateTimePattern } from "@vuu-ui/vuu-utils";
 export interface ColumnFilterProps extends ColumnFilterHookProps, Omit<SegmentedButtonGroupProps, "defaultValue">, Pick<DataItemEditControlProps, "TypeaheadProps" | "table" | "values" | "variant"> {
+    /**
+     * Temporal columns only. The date/time pattern used by the filter control,
+     * overriding any pattern configured on the column type. The pattern also
+     * determines the control rendered: a time picker for a time only pattern
+     * (with milliseconds if time is 'hh:mm:ss.ms'), otherwise a date picker.
+     * This allows a filter to use different formatting to the Table, e.g.
+     * the Table might display nanoseconds whilst the filter accepts a time
+     * of day with milliseconds. The column passed to change and commit
+     * handlers is the column with this pattern applied (see withDateTimePattern),
+     * so that filter values are interpreted consistently with the control.
+     */
+    pattern?: DateTimePattern;
 }
 export declare const ColumnFilter: import("react").ForwardRefExoticComponent<ColumnFilterProps & import("react").RefAttributes<HTMLDivElement>>;

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/filter-container/FilterContainer.d.ts

@@ -9,7 +9,7 @@ export interface FilterContainerProps extends HTMLAttributes<HTMLDivElement>, Co
 export interface FilterContainerColumnFilterProps extends Omit<ColumnFilterProps, "defaultValue" | "onCommit" | "value"> {
     defaultValue?: ColumnFilterValue;
 }
-export declare const FilterContainerColumnFilter: ({ column, operator, variant, ...props }: FilterContainerColumnFilterProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FilterContainerColumnFilter: ({ column: columnProp, operator, pattern, variant, ...props }: FilterContainerColumnFilterProps) => import("react/jsx-runtime").JSX.Element;
 /**
  * FilterContainer is a generic UI container for a collection of Filter
  * controls. Each control manages a single filter clause and the Filter

package/types/filter-context-menu/useFilterContextMenu.d.ts

@@ -1,6 +1,16 @@
 import type { TableContextMenuDef } from "@vuu-ui/vuu-table-types";
+import { type DateTimePattern } from "@vuu-ui/vuu-utils";
 export interface FilterContextMenuHookProps {
     filterColumns: string[] | "*";
+    /**
+     * The date/time pattern of the ColumnFilter for a temporal column, keyed by
+     * column name. A filter created from a cell value matches the value at the
+     * precision displayed by the ColumnFilter, e.g a ColumnFilter with time
+     * pattern 'hh:mm:ss.ms' filters the whole millisecond. Where no pattern is
+     * provided, the column descriptor registered by a FilterContainerColumnFilter
+     * for the column is used, if there is one, otherwise the Table column.
+     */
+    filterPatterns?: Record<string, DateTimePattern>;
     filterProviderKey?: string;
 }
-export declare const useFilterContextMenu: ({ filterColumns, filterProviderKey, }?: FilterContextMenuHookProps) => TableContextMenuDef;
+export declare const useFilterContextMenu: ({ filterColumns, filterPatterns, filterProviderKey, }?: FilterContextMenuHookProps) => TableContextMenuDef;

package/types/filter-provider/FilterContext.d.ts

@@ -8,6 +8,17 @@ export type FilterContextFilterMenuActionHandler = <T extends FilterAction = Fil
  */
 columns?: ColumnDescriptor[]) => void;
 export interface FilterContextProps {
+    /**
+     * Returns the column descriptor used by a ColumnFilter (within a
+     * FilterContainer) for the named column, if one is registered.
+     */
+    getColumnFilterColumn?: (key: string, columnName: string) => ColumnDescriptor | undefined;
+    /**
+     * Register the column descriptor used by a ColumnFilter, which may differ
+     * from the Table column descriptor, e.g. a different date/time pattern.
+     * Returns a function to unregister.
+     */
+    registerColumnFilterColumn?: (key: string, column: ColumnDescriptor) => () => void;
     deleteFilter: (key: string, filterId: string) => void;
     saveFilter: (key: string, name: string) => void;
     filterDescriptors: Map<string, FilterContainerFilterDescriptor[]>;
@@ -24,6 +35,14 @@ export declare const isNullFilter: (f?: FilterContainerFilterDescriptor) => bool
 export declare const NullFilterDescriptor: FilterContainerFilterDescriptor;
 export declare const EmptyFilterDescriptor: FilterContainerFilterDescriptor;
 export declare const FilterContext: import("react").Context<FilterContextProps>;
+/**
+ * Access the column descriptors registered by ColumnFilters
+ * (see FilterContainerColumnFilter).
+ */
+export declare function useColumnFilterRegistry(key?: string): {
+    getColumnFilterColumn: (columnName: string) => ColumnDescriptor | undefined;
+    registerColumnFilterColumn: (column: ColumnDescriptor) => (() => void) | undefined;
+};
 interface SavedFilterHookProps {
     availableColumns?: ColumnDescriptor[];
 }

package/types/index.d.ts

@@ -4,14 +4,14 @@ export * from "./filter-clause";
 export { ExtendedSingleValueFilterClause } from "./filter-container/ExtendedSingleValueFilterClause";
 export { FilterContainer, FilterContainerColumnFilter, type FilterContainerColumnFilterProps, type FilterContainerProps, } from "./filter-container/FilterContainer";
 export type { FilterAppliedHandler } from "./filter-container/useFilterContainer";
-export { useFilterContextMenu } from "./filter-context-menu/useFilterContextMenu";
+export { type FilterContextMenuHookProps, useFilterContextMenu, } from "./filter-context-menu/useFilterContextMenu";
 export { FilterDisplay } from "./filter-display/FilterDisplay";
 export * from "./filter-editor";
 export { FilterPanel } from "./filter-panel/FilterPanel";
 export * from "./filter-pill";
 export { type FilterPermissions } from "./filter-pill/FilterMenu";
 export { FilterPillNext, type FilterPillNextProps, } from "./filter-pill/FilterPillNext";
-export { NULL_FILTER, useSavedFilters } from "./filter-provider/FilterContext";
+export { NULL_FILTER, useColumnFilterRegistry, useSavedFilters, } from "./filter-provider/FilterContext";
 export { FilterProvider } from "./filter-provider/FilterProvider";
 export * from "./filter-utils";
 export * from "./FilterModel";

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

package/types/src/column-filter/ColumnFilter.d.ts

@@ -1,6 +0,0 @@
-import { type SegmentedButtonGroupProps } from "@salt-ds/core";
-import { DataItemEditControlProps } from "@vuu-ui/vuu-data-react";
-import { ColumnFilterHookProps } from "./useColumnFilter";
-export interface ColumnFilterProps extends ColumnFilterHookProps, Omit<SegmentedButtonGroupProps, "defaultValue">, Pick<DataItemEditControlProps, "TypeaheadProps" | "table" | "values" | "variant"> {
-}
-export declare const ColumnFilter: import("react").ForwardRefExoticComponent<ColumnFilterProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/column-filter/useColumnFilter.d.ts

@@ -1,43 +0,0 @@
-import { ColumnFilterChangeHandler, ColumnFilterCommitHandler, ColumnFilterOp, ColumnFilterValue, ExtendedFilterOptions } from "@vuu-ui/vuu-filter-types";
-import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
-import { InputProps } from "@salt-ds/core";
-import { CommitHandler } from "@vuu-ui/vuu-utils";
-import { DataItemEditControlProps } from "@vuu-ui/vuu-data-react";
-export interface ColumnFilterHookProps extends Pick<DataItemEditControlProps, "InputProps"> {
-    column: ColumnDescriptor;
-    /**
-     * Filter defaultValue. Pair of values expected when operator is
-     * 'between'. If provided, component is uncontrolled
-     */
-    defaultValue?: ColumnFilterValue;
-    /**
-     * Provides for custom filters.
-     */
-    extendedFilterOptions?: ExtendedFilterOptions;
-    /**
-     * Filter change events.
-     */
-    onColumnFilterChange?: ColumnFilterChangeHandler;
-    /**
-     * Filter change events on second control in range filter
-     */
-    onColumnRangeFilterChange?: ColumnFilterChangeHandler;
-    /**
-     * Called when user 'commits' filter value, either by pressing enter,
-     * tabbing away from control or making selection from list
-     */
-    onCommit: ColumnFilterCommitHandler;
-    operator?: ColumnFilterOp;
-    /**
-     * Filter value. Pair of values expected when operator is
-     * 'between'. If provided, component is controlled.
-     */
-    value?: ColumnFilterValue;
-}
-export declare const useColumnFilter: ({ InputProps: InputPropsProp, column, defaultValue, extendedFilterOptions, onColumnFilterChange, onColumnRangeFilterChange, onCommit, operator, value: valueProp, }: ColumnFilterHookProps) => {
-    InputProps: InputProps;
-    InputPropsRange: InputProps;
-    isInvalid: boolean;
-    onCommit: CommitHandler<HTMLElement>;
-    onCommitRange: CommitHandler<HTMLElement>;
-};

package/types/src/column-filter/utils.d.ts

@@ -1,4 +0,0 @@
-import { Filter } from "@vuu-ui/vuu-filter-types";
-export declare const isStartsWithValue: (value: string) => boolean;
-export declare const getTypeaheadFilter: (column: string, filterValues: string[], isStartsWithFilter?: boolean) => Filter | undefined;
-export declare const getRangeFilter: (column: string, startValue?: number, endValue?: number) => Filter | undefined;

package/types/src/custom-filters/CustomFilters.d.ts

@@ -1,7 +0,0 @@
-import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
-import { HTMLAttributes } from "react";
-import { type FilterBarProps } from "../filter-bar";
-export interface CustomFilterProps extends HTMLAttributes<HTMLDivElement>, Pick<FilterBarProps, "defaultFilterState" | "filterState" | "onApplyFilter" | "onClearFilter" | "onFilterDeleted" | "onFilterRenamed" | "onFilterStateChanged" | "vuuTable"> {
-    columnDescriptors: readonly ColumnDescriptor[];
-}
-export declare const CustomFilters: ({ columnDescriptors, defaultFilterState, filterState, onApplyFilter, onClearFilter, onFilterDeleted, onFilterRenamed, onFilterStateChanged, vuuTable, }: CustomFilterProps) => import("react").JSX.Element;

package/types/src/custom-filters/filterBarFocusManagement.d.ts

@@ -1 +0,0 @@
-export declare const navigateToNextItem: (el: HTMLElement | EventTarget, direction?: "bwd" | "fwd") => void;

package/types/src/custom-filters/index.d.ts

@@ -1 +0,0 @@
-export * from "./CustomFilters";

package/types/src/custom-filters/useCustomFilters.d.ts

@@ -1,33 +0,0 @@
-import { ColumnDescriptorsByName, Filter } from "@vuu-ui/vuu-filter-types";
-import { PromptProps } from "@vuu-ui/vuu-ui-controls";
-import { KeyboardEventHandler, RefObject } from "react";
-import { FilterBarProps } from "../filter-bar";
-import { FilterEditCancelHandler, FilterEditSaveHandler } from "../filter-editor";
-import { FilterPillProps } from "../filter-pill";
-export type EditFilterState = "create" | "edit";
-export type FilterState = EditFilterState | "rename";
-export declare const isEditFilterState: (filterState?: string) => filterState is EditFilterState;
-type InteractedFilterState = {
-    filter?: Filter;
-    index: number;
-    state: FilterState;
-};
-export interface CustomFilterHookProps extends Pick<FilterBarProps, "columnDescriptors" | "defaultFilterState" | "filterState" | "onApplyFilter" | "onClearFilter" | "onFilterDeleted" | "onFilterRenamed" | "onFilterStateChanged"> {
-    containerRef: RefObject<HTMLDivElement | null>;
-}
-export declare const useCustomFilters: ({ columnDescriptors, containerRef, defaultFilterState, filterState, onApplyFilter, onClearFilter, onFilterDeleted, onFilterRenamed, onFilterStateChanged, }: CustomFilterHookProps) => {
-    FilterPillProps: Omit<FilterPillProps, "filter" | "selected">;
-    activeFilterIndex: number[];
-    addButtonProps: {
-        ref: RefObject<HTMLButtonElement | null>;
-        onClick: () => void;
-        onKeyDown: KeyboardEventHandler;
-    };
-    columnsByName: ColumnDescriptorsByName;
-    filters: Filter[];
-    interactedFilterState: InteractedFilterState | undefined;
-    onCancelEdit: FilterEditCancelHandler;
-    onSave: FilterEditSaveHandler;
-    promptProps: PromptProps | null;
-};
-export {};

package/types/src/custom-filters/useFilterState.d.ts

@@ -1,17 +0,0 @@
-import { Filter, FilterState } from "@vuu-ui/vuu-filter-types";
-export interface FiltersHookProps {
-    defaultFilterState?: FilterState;
-    filterState?: FilterState;
-    onFilterDeleted?: (filter: Filter) => void;
-    onFilterRenamed?: (filter: Filter, name: string) => void;
-    onFilterStateChanged?: (s: FilterState) => void;
-}
-export declare const useFilterState: ({ defaultFilterState, onFilterDeleted, onFilterRenamed, onFilterStateChanged, filterState: filterStateProp, }: FiltersHookProps) => {
-    activeFilterIndex: number[];
-    filters: Filter[];
-    onToggleFilterActive: (filterIndex: number, preserveRemainingFilters?: boolean) => void;
-    onAddFilter: (filter: Filter) => number;
-    onChangeFilter: (oldFilter: Filter, newFilter: Filter) => number;
-    onDeleteFilter: (filter: Filter) => number;
-    onRenameFilter: (filter: Filter, name: string) => number;
-};

package/types/src/filter-bar/FilterBar.d.ts

@@ -1,33 +0,0 @@
-import { Filter, FilterHandler, FilterState } from "@vuu-ui/vuu-filter-types";
-import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
-import { HTMLAttributes } from "react";
-import { QuickFilterProps } from "../quick-filters";
-import { FilterMode } from "./useFilterBar";
-import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
-export type FilterBarVariant = "custom-filters-only" | "quick-filters-only" | "full-filters";
-export interface FilterBarProps extends HTMLAttributes<HTMLDivElement> {
-    QuickFilterProps?: Pick<QuickFilterProps, "quickFilterColumns" | "onChangeQuickFilterColumns">;
-    /**
-     * Used to ensure we present filter editors appropriate to the data type of column.
-     * NOTE: Always make sure that these are passed with proper re-render optimization (i.e make
-     * sure its a stable reference, in React terminology), otherwise might end up with infinite
-     * state updates.
-     */
-    columnDescriptors: readonly ColumnDescriptor[];
-    defaultFilterMode?: FilterMode;
-    defaultFilterState?: FilterState;
-    filterMode?: FilterMode;
-    filterState?: FilterState;
-    onApplyFilter: FilterHandler;
-    onChangeFilterMode?: (filterMode: FilterMode) => void;
-    onClearFilter: () => void;
-    onFilterDeleted?: FilterHandler;
-    onFilterRenamed?: (filter: Filter, name: string) => void;
-    onFilterStateChanged?: (state: FilterState) => void;
-    /**
-     * Defines table used in call to Vuu Typeahead service
-     */
-    vuuTable?: VuuTable;
-    variant?: FilterBarVariant;
-}
-export declare const FilterBar: ({ QuickFilterProps, className: classNameProp, columnDescriptors, defaultFilterMode, defaultFilterState, filterMode: filterModeProp, filterState, onApplyFilter, onChangeFilterMode: onChangeFilterModeProp, onClearFilter, onFilterDeleted, onFilterRenamed, onFilterStateChanged, vuuTable, variant, ...htmlAttributes }: FilterBarProps) => import("react").JSX.Element;

package/types/src/filter-bar/FilterBarMenu.d.ts

@@ -1 +0,0 @@
-export declare const FilterBarMenu: () => import("react").JSX.Element;

package/types/src/filter-bar/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./FilterBar";
-export type { FilterMode } from "./useFilterBar";

package/types/src/filter-bar/useFilterBar.d.ts

@@ -1,7 +0,0 @@
-import { SyntheticEvent } from "react";
-import { FilterBarProps } from "./FilterBar";
-export type FilterMode = "custom-filter" | "quick-filter";
-export declare const useFilterBar: ({ defaultFilterMode, filterMode: filterModeProp, onChangeFilterMode, }: Pick<FilterBarProps, "defaultFilterMode" | "filterMode" | "onChangeFilterMode">) => {
-    filterMode: FilterMode;
-    onChangeFilterMode: (e: SyntheticEvent<HTMLButtonElement>) => void;
-};

package/types/src/filter-clause/ExpandoCombobox.d.ts

@@ -1,10 +0,0 @@
-import { ComboBoxProps } from "@salt-ds/core";
-import { ReactElement, Ref } from "react";
-export interface ExpandoComboboxProps<Item = string> extends Omit<ComboBoxProps<Item>, "onOpenChange"> {
-    itemToString?: (item: Item) => string;
-    dropdownOnAutofocus?: boolean;
-    onOpenChange?: (open: boolean, reason?: "manual" | "input" | "focus") => void;
-}
-export declare const ExpandoCombobox: <Item = string>(props: ExpandoComboboxProps<Item> & {
-    ref?: Ref<HTMLDivElement>;
-}) => ReactElement;

package/types/src/filter-clause/FilterClause.d.ts

@@ -1,16 +0,0 @@
-import { ColumnDescriptorsByName } from "@vuu-ui/vuu-filter-types";
-import { HTMLAttributes } from "react";
-import { FilterClauseModel } from "../FilterModel";
-import { VuuTable } from "@vuu-ui/vuu-protocol-types";
-export type FilterClauseCancelType = "Backspace" | "Escape";
-export type FilterClauseCancelHandler = (filterClause: FilterClauseModel, reason: FilterClauseCancelType) => void;
-export interface FilterClauseProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
-    columnsByName: ColumnDescriptorsByName;
-    filterClauseModel: FilterClauseModel;
-    onCancel?: FilterClauseCancelHandler;
-    onDropdownOpen?: () => void;
-    onFocusSave?: () => void;
-    dropdownOnAutofocus?: boolean;
-    vuuTable: VuuTable;
-}
-export declare const FilterClause: ({ className, columnsByName, onCancel, onDropdownOpen, onFocusSave, filterClauseModel, vuuTable, dropdownOnAutofocus, ...htmlAttributes }: FilterClauseProps) => import("react").JSX.Element;

package/types/src/filter-clause/column-picker/ColumnPicker.d.ts

@@ -1,13 +0,0 @@
-import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
-import { ComboBoxProps } from "@salt-ds/core";
-import { SyntheticEvent } from "react";
-export type ColumnPickerProps = Pick<ComboBoxProps, "className" | "inputProps" | "value"> & {
-    columns: readonly ColumnDescriptor[];
-    onSelect: (evt: SyntheticEvent, columnName: string) => void;
-    dropdownOnAutofocus?: boolean;
-};
-export declare const ColumnPicker: import("react").ForwardRefExoticComponent<Pick<ComboBoxProps<string>, "className" | "inputProps" | "value"> & {
-    columns: readonly ColumnDescriptor[];
-    onSelect: (evt: SyntheticEvent, columnName: string) => void;
-    dropdownOnAutofocus?: boolean;
-} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/filter-clause/column-picker/useColumnPicker.d.ts

@@ -1,11 +0,0 @@
-import { ChangeEvent, SyntheticEvent } from "react";
-export declare const useColumnPicker: ({ onSelect, value: valueProp, }: {
-    onSelect: (evt: SyntheticEvent, columnName: string) => void;
-    value: string;
-}) => {
-    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
-    onOpenChange: (isOpen: boolean, reason?: "manual" | "input" | "focus") => void;
-    onSelectionChange: (evt: SyntheticEvent, [newSelected]: string[]) => void;
-    ref: import("react").RefObject<HTMLDivElement | null>;
-    value: string;
-};

package/types/src/filter-clause/filterClauseFocusManagement.d.ts

@@ -1,15 +0,0 @@
-import { KeyboardEvent } from "react";
-type FilterClauseFieldName = "column" | "operator" | "value";
-export declare const getFocusedFieldDetails: () => [number, string] | [];
-export declare const elementIsFilterCombinator: (element: Element | null) => element is HTMLElement;
-export declare const elementIsFilterClause: (element: Element | null) => element is HTMLElement;
-export declare const focusFilterClauseField: (filterEditor: HTMLElement, filterClauseIndex: number, fieldName?: FilterClauseFieldName) => void;
-export declare const focusLastClauseValue: (filterEditor: HTMLElement) => void;
-export declare const focusNextFocusableElement: (direction?: "fwd" | "bwd") => void;
-export declare const focusNextElement: () => void;
-export declare const clauseIsNotFirst: (el: HTMLElement) => boolean | undefined;
-export declare const tabToPreviousFilterCombinator: (currentElement: HTMLElement) => void;
-export declare const navigateToNextFilterClause: (currentElement: HTMLElement, direction?: "bwd" | "fwd") => void;
-export declare const navigateToNextItemIfAtBoundary: (evt: KeyboardEvent<HTMLInputElement>) => void;
-export declare const focusFirstClauseIfAllClausesValid: (filterEditor: HTMLElement) => void;
-export {};

package/types/src/filter-clause/filterClauseTypes.d.ts

@@ -1,12 +0,0 @@
-import type { TableSchemaTable } from "@vuu-ui/vuu-data-types";
-import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
-import type { InputProps } from "@salt-ds/core";
-import type { FilterClauseValueChangeHandler } from "./useFilterClause";
-export interface FilterClauseValueEditor {
-    inputProps?: InputProps["inputProps"];
-    column: ColumnDescriptor;
-    onDeselect?: () => void;
-    onChangeValue: FilterClauseValueChangeHandler;
-    onOpenChange?: (open: boolean, reason?: "input" | "manual" | "focus") => void;
-    table?: TableSchemaTable;
-}

package/types/src/filter-clause/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./column-picker/ColumnPicker";
-export { OperatorPicker } from "./operator-picker/OperatorPicker";
-export * from "./ExpandoCombobox";
-export * from "./FilterClause";
-export * from "./value-editors/FilterClauseValueEditorText";