@vuu-ui/vuu-utils 3.3.9 → 3.3.10

package/types/src/datasource/BaseDataSource.d.ts

@@ -0,0 +1,63 @@
+import type { DataSource, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceSuspenseProps, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
+import { LinkDescriptorWithLabel, VuuAggregation, VuuRange, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import { EventEmitter } from "../event-emitter";
+import { Range } from "../range-utils";
+import { Filter } from "@vuu-ui/vuu-filter-types";
+export type ConfigWithVisualLink = WithBaseFilter<WithFullConfig> & {
+    visualLink?: LinkDescriptorWithLabel;
+};
+export declare const defaultSuspenseProps: DataSourceSuspenseProps;
+export declare abstract class BaseDataSource extends EventEmitter<DataSourceEvents> implements Pick<DataSource, "config"> {
+    #private;
+    viewport: string;
+    protected _clientCallback: DataSourceSubscribeCallback | undefined;
+    protected _configWithVisualLink: ConfigWithVisualLink;
+    protected _impendingConfigWithVisualLink: ConfigWithVisualLink | undefined;
+    protected _range: Range;
+    protected _size: number;
+    protected _title: string | undefined;
+    protected _defaultSuspenseProps: DataSourceSuspenseProps;
+    private awaitingConfirmationOfConfigChanges;
+    constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, sort, suspenseProps, title, viewport, }: Omit<DataSourceConstructorProps, "table">);
+    subscribe({ baseFilterSpec, columns, aggregations, range, sort, groupBy, filterSpec, viewport, }: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): void;
+    get aggregations(): VuuAggregation[];
+    set aggregations(aggregations: VuuAggregation[]);
+    get baseFilter(): DataSourceFilter | undefined;
+    set baseFilter(baseFilter: DataSourceFilter | undefined);
+    get columns(): string[];
+    set columns(columns: string[]);
+    get filter(): DataSourceFilter;
+    set filter(filter: DataSourceFilter);
+    setFilter(filter: Filter): void;
+    clearFilter(): void;
+    get isAwaitingConfirmationOfConfigChange(): boolean;
+    protected confirmConfigChange(): void;
+    get config(): WithBaseFilter<WithFullConfig>;
+    set config(config: WithBaseFilter<WithFullConfig>);
+    get impendingConfig(): undefined | WithBaseFilter<WithFullConfig>;
+    /**
+     * This can be set by subclass in cases where we want to await ACK of async request
+     * before we go ahead and apply change to config.
+     * It is set in place of 'config' itself and it is then the responsibility of the client
+     * to call 'confirmConfigChange' once confirmation of the change is received.
+     * Client can check 'isAwaitingConfirmationOfConfigChange' to see if a change is pending
+     * confirmation.
+     */
+    set impendingConfig(config: undefined | WithBaseFilter<WithFullConfig>);
+    get pageCount(): number;
+    set pageCount(pageCount: number);
+    get range(): Range;
+    set range(range: Range);
+    get size(): number;
+    set size(size: number);
+    get sort(): VuuSort;
+    set sort(sort: VuuSort);
+    get title(): string;
+    set title(title: string);
+    private applyConfig;
+    freeze(): void;
+    unfreeze(): void;
+    get freezeTimestamp(): number | undefined;
+    get isFrozen(): boolean;
+    abstract rangeRequest(range: VuuRange): void;
+}

package/types/src/datasource/datasource-action-utils.d.ts

@@ -0,0 +1,7 @@
+import { DataSourceMenusMessage, DataSourceVisualLinkCreatedMessage, DataSourceVisualLinkRemovedMessage, DataSourceVisualLinksMessage, VuuFeatureMessage } from "@vuu-ui/vuu-data-types";
+import { GridAction } from "@vuu-ui/vuu-table-types";
+export declare const isVisualLinksAction: (action: GridAction) => action is DataSourceVisualLinksMessage;
+export declare const isVisualLinkCreatedAction: (action: GridAction) => action is DataSourceVisualLinkCreatedMessage;
+export declare const isVisualLinkRemovedAction: (action: GridAction) => action is DataSourceVisualLinkRemovedMessage;
+export declare const isViewportMenusAction: (action: GridAction) => action is DataSourceMenusMessage;
+export declare const isVuuFeatureAction: (action: GridAction) => action is VuuFeatureMessage;

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

@@ -0,0 +1,2 @@
+import { WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
+export declare const combineFilters: ({ baseFilterSpec, filterSpec, ...config }: WithBaseFilter<WithFullConfig>) => WithFullConfig;

package/types/src/datasource/datasource-utils.d.ts

@@ -0,0 +1,61 @@
+import type { ConnectionQualityMetrics, DataSourceCallbackMessage, DataSourceConfig, DataSourceDataMessage, DataSourceRow, DataSourceVisualLinksMessage, TypeaheadSuggestionProvider, VuuUIMessageIn, VuuUIMessageInRPC, VuuUIMessageInTableMeta, VuuUIMessageOutViewport, WithBaseFilter, WithFilter, WithFullConfig, WithGroupBy, WithSort } from "@vuu-ui/vuu-data-types";
+import type { LinkDescriptorWithLabel, VuuColumns, VuuCreateVisualLink, VuuFilter, VuuRemoveVisualLink, VuuRowDataItemType, VuuSort, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import type { ColumnMap } from "../column-utils";
+import type { ConfigWithVisualLink } from "./BaseDataSource";
+export declare const NoFilter: VuuFilter;
+export declare const NoSort: VuuSort;
+export declare const vanillaConfig: WithFullConfig;
+/**
+ * Derive the config for a session (edit) datasource from the source (view) datasource config.
+ * When the edit table declares its own columns, the view config's filter, groupBy, sort and
+ * aggregations are discarded rather than inherited - they may reference view-only columns.
+ */
+export declare const sessionDataSourceConfig: (sourceConfig: WithFullConfig, overrideColumns?: VuuColumns) => WithFullConfig;
+/**
+ * The session table name is server generated, so only the module is compared.
+ */
+export declare const assertExpectedSessionTable: (sessionTable: VuuTable, expectedTable?: VuuTable) => void;
+export declare const stripVisualLink: (configWithVisualLink: ConfigWithVisualLink) => WithBaseFilter<WithFullConfig>;
+export type DataSourceConfigChanges = {
+    aggregationsChanged: boolean;
+    baseFilterChanged: boolean;
+    columnsChanged: boolean;
+    filterChanged: boolean;
+    groupByChanged: boolean;
+    sortChanged: boolean;
+    visualLinkChanged: boolean;
+};
+export type MaybeDataSourceConfigChanges = DataSourceConfigChanges & {
+    noChanges: boolean;
+};
+type DataConfigPredicate = (config: WithBaseFilter<DataSourceConfig>, newConfig: WithBaseFilter<DataSourceConfig>) => boolean;
+export declare const isBaseFilterChanged: DataConfigPredicate;
+export declare const isFilterChanged: DataConfigPredicate;
+export declare const isGroupByChanged: DataConfigPredicate;
+export declare const NO_CONFIG_CHANGES: MaybeDataSourceConfigChanges;
+export declare const isConfigChanged: (config: DataSourceConfig | undefined, newConfig: DataSourceConfig | undefined) => MaybeDataSourceConfigChanges;
+export declare const hasGroupBy: (config?: WithBaseFilter<DataSourceConfig>) => config is WithGroupBy;
+export declare const hasBaseFilter: (config?: WithBaseFilter<DataSourceConfig>) => config is WithFilter;
+export declare const hasFilter: (config?: DataSourceConfig) => config is WithFilter;
+export declare const hasSort: (config?: DataSourceConfig) => config is WithSort;
+export declare const isTypeaheadSuggestionProvider: (source: unknown) => source is TypeaheadSuggestionProvider;
+export declare const isTableSchemaMessage: (message: VuuUIMessageIn) => message is VuuUIMessageInTableMeta;
+export declare const isConnectionQualityMetrics: (msg: object) => msg is ConnectionQualityMetrics;
+export declare const messageHasResult: (msg: object) => msg is VuuUIMessageInRPC;
+export declare const isVisualLinkMessage: (msg: unknown) => msg is VuuCreateVisualLink | VuuRemoveVisualLink;
+export declare const isVisualLinksMessage: (msg: unknown) => msg is DataSourceVisualLinksMessage;
+export declare const isViewportMessage: (msg: object) => msg is VuuUIMessageOutViewport;
+export type DataSourceDataMessageWithRows = Omit<DataSourceDataMessage, "rows"> & {
+    rows: DataSourceRow[];
+};
+export type DataSourceDataMessageWithSize = Omit<DataSourceDataMessage, "size"> & {
+    size: number;
+};
+export declare const messageHasDataRows: (message: DataSourceCallbackMessage) => message is DataSourceDataMessageWithRows;
+export declare const messageHasSize: (message: DataSourceCallbackMessage) => message is DataSourceDataMessageWithSize;
+export declare const withConfigDefaults: (config: WithBaseFilter<DataSourceConfig>) => WithBaseFilter<WithFullConfig> & {
+    visualLink?: LinkDescriptorWithLabel;
+};
+export type Entity = Record<string, VuuRowDataItemType>;
+export declare const dataSourceRowToEntity: <T extends Entity = Entity>(row: DataSourceRow, columnMap: ColumnMap) => T;
+export {};

package/types/src/date/date-utils.d.ts

@@ -0,0 +1,39 @@
+import { CalendarDate } from "@internationalized/date";
+export declare function toCalendarDate(d: Date): CalendarDate;
+export type oneToFive = 1 | 2 | 3 | 4 | 5;
+export type zeroToFive = 0 | oneToFive;
+export type sixToNine = 6 | 7 | 8 | 9;
+export type zeroToNine = zeroToFive | sixToNine;
+export type oneToNine = oneToFive | sixToNine;
+export type TimeUnit = "hours" | "minutes" | "seconds";
+export type Hours = `${0 | 1}${zeroToNine}` | `2${0 | 1 | 2 | 3}`;
+export type Minutes = `${zeroToFive}${zeroToNine}`;
+export type Seconds = `${zeroToFive}${zeroToNine}`;
+export type TimeUnitValue<T extends TimeUnit> = T extends "hours" ? Hours : T extends "minutes" ? Minutes : Seconds;
+export type TimeString = `${number}${number}:${number}${number}:${number}${number}`;
+type YYYY = `19${zeroToNine}${zeroToNine}` | `20${zeroToNine}${zeroToNine}`;
+type MM = `0${oneToNine}` | `1${0 | 1 | 2}`;
+type DD = `${0}${oneToNine}` | `${1 | 2}${zeroToNine}` | `3${0 | 1}`;
+export type DateStringISO = `${YYYY}-${MM}-${DD}`;
+export declare const zeroTime: TimeString;
+export declare const zeroTimeUnit: TimeUnitValue<TimeUnit>;
+export declare function incrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): TimeUnitValue<T> | Hours;
+export declare function decrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): TimeUnitValue<T> | Hours;
+export declare function updateTimeString<T extends TimeUnit>(timeString: TimeString, unit: T, value: TimeUnitValue<T>): TimeString;
+export declare const isValidTimeString: (value: unknown) => value is TimeString;
+export declare function asTimeString(value: unknown, allowUndefined: false): TimeString;
+export declare function asTimeString(value: unknown, allowUndefined?: true): TimeString | undefined;
+export interface Time {
+    hours: number;
+    minutes: number;
+    seconds: number;
+    asDate: (date?: Date | DateStringISO) => Date;
+}
+export declare function Time(timeString: TimeString): Time;
+export declare namespace Time {
+    export var millisToTimeString: (timestamp: number) => TimeString;
+    var _a: (hours: number, minutes: number, seconds: number) => TimeString;
+    export { _a as toString };
+    export var isDateInMillis: (dtInMillis: string | number) => boolean;
+}
+export {};

package/types/src/date/dateTimePattern.d.ts

@@ -0,0 +1,8 @@
+import { DateTimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
+import { DateTimePattern } from "./types";
+export declare const defaultPatternsByType: {
+    readonly time: "hh:mm:ss";
+    readonly date: "dd.mm.yyyy";
+};
+export declare const fallbackDateTimePattern: DateTimePattern;
+export declare function dateTimePattern(type: DateTimeDataValueDescriptor["type"]): DateTimePattern;

package/types/src/date/formatter.d.ts

@@ -0,0 +1,9 @@
+import { DateFormatter } from "@internationalized/date";
+import { DateTimePattern } from "./types";
+type DateTimeFormatConfig = {
+    locale: string;
+    options: Intl.DateTimeFormatOptions;
+};
+export declare function getDateFormatter({ locale, options }: DateTimeFormatConfig): DateFormatter;
+export declare function formatDate(pattern: DateTimePattern): (d: Date) => string;
+export {};

package/types/src/date/index.d.ts

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

package/types/src/date/types.d.ts

@@ -0,0 +1,29 @@
+import { ColumnTypeFormatting } from "@vuu-ui/vuu-table-types";
+/**
+ * In the code below we distinguish between an ISO date pattern (yyyy-mm-dd) and
+ * other supported date patterns because the ISO format is not supported by the
+ * Intl dateFormatting function
+ */
+declare const supportedDatePatterns: readonly ["yyyy-mm-dd", "dd.mm.yyyy", "dd/mm/yyyy", "dd MMM yyyy", "dd MMMM yyyy", "mm/dd/yyyy", "MMM dd, yyyy", "MMMM dd, yyyy"];
+declare const supportedTimePatterns: readonly ["hh:mm:ss", "hh:mm:ss a", "hh:mm:ss.ms"];
+export declare const supportedDateTimePatterns: {
+    date: readonly ["yyyy-mm-dd", "dd.mm.yyyy", "dd/mm/yyyy", "dd MMM yyyy", "dd MMMM yyyy", "mm/dd/yyyy", "MMM dd, yyyy", "MMMM dd, yyyy"];
+    time: readonly ["hh:mm:ss", "hh:mm:ss a", "hh:mm:ss.ms"];
+};
+export declare const dateTimeLabelByType: {
+    readonly date: "Date";
+    readonly time: "Time";
+};
+export type DatePattern = (typeof supportedDatePatterns)[number];
+export type TimePattern = (typeof supportedTimePatterns)[number];
+export type DateTimePattern = {
+    date?: DatePattern;
+    time: TimePattern;
+} | {
+    date: DatePattern;
+    time?: TimePattern;
+};
+export declare const isDatePattern: (pattern?: string) => pattern is DatePattern;
+export declare const isTimePattern: (pattern?: string) => pattern is TimePattern;
+export declare const isDateTimePattern: (pattern?: ColumnTypeFormatting["pattern"]) => pattern is DateTimePattern;
+export {};

package/types/src/debug-utils.d.ts

@@ -0,0 +1,9 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+export declare class RangeMonitor {
+    private source;
+    range: VuuRange;
+    timestamp: number;
+    constructor(source: string);
+    isSet(): boolean;
+    set({ from, to }: VuuRange): 0 | undefined;
+}

package/types/src/edit-utils.d.ts

@@ -0,0 +1,2 @@
+import type { EditSessionMode } from "@vuu-ui/vuu-data-types";
+export declare const isInlineEditingSession: (editSessionMode: EditSessionMode) => editSessionMode is "inline-all-rows";

package/types/src/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class StaleUpdateError extends Error {
+}

package/types/src/event-emitter.d.ts

@@ -0,0 +1,21 @@
+type Listener = (...args: any[]) => void;
+export type EmittedEvents = Record<string, Listener>;
+export interface IEventEmitter<Events extends EmittedEvents> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): void;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): void;
+    on<E extends keyof Events>(event: E, listener: Events[E]): void;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): void;
+    removeAllListeners<E extends keyof Events>(event?: E): void;
+}
+export declare class EventEmitter<Events extends EmittedEvents> implements IEventEmitter<Events> {
+    #private;
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): void;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): void;
+    removeAllListeners<E extends keyof Events>(event?: E): void;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): void;
+    once<E extends keyof Events>(event: E, listener: Events[E]): void;
+    on<E extends keyof Events>(event: E, listener: Events[E]): void;
+    hasListener<E extends keyof Events>(event: E, listener: Events[E]): boolean;
+    private invokeHandler;
+}
+export {};

package/types/src/feature-utils.d.ts

@@ -0,0 +1,110 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ListOption } from "@vuu-ui/vuu-table-types";
+import { ReactElement } from "react";
+export type PathMap = {
+    [key: string]: Pick<DynamicFeatureDescriptor, "css" | "url">;
+};
+export type Environment = "development" | "production";
+export declare const env: Environment;
+export type LookupTableProvider = (table: VuuTable) => ListOption[];
+export interface ViewConfig {
+    allowRename?: boolean;
+    closeable?: boolean;
+    header?: boolean;
+}
+export interface DynamicFeatureProps<P extends object | undefined = object> {
+    /**
+      props that will be passed to the lazily loaded component.
+     */
+    ComponentProps?: P;
+    ViewProps?: ViewConfig;
+    css?: string;
+    height?: number;
+    title?: string;
+    /**
+     The url of javascript bundle to lazily load. Bundle must provide a default export
+     and that export must be a React component.
+     */
+    url: string;
+    width?: number;
+}
+declare global {
+    const vuuConfig: Promise<VuuConfig>;
+}
+export interface DynamicFeatureDescriptor {
+    /**
+     * url for css file for feature
+     */
+    css?: string;
+    featureProps?: {
+        vuuTables?: "*" | VuuTable[];
+    };
+    leftNavLocation: "vuu-features" | "vuu-tables";
+    name: string;
+    title: string;
+    /**
+     * url for javascript bundle to load feature
+     */
+    url: string;
+    viewProps?: ViewConfig;
+}
+export interface StaticFeatureDescriptor {
+    group?: string;
+    label: string;
+    type: string;
+}
+export declare const isStaticFeatures: (features: unknown) => features is StaticFeatureDescriptor[];
+export interface FilterTableFeatureProps {
+    tableSchema: TableSchema;
+}
+export type DynamicFeatures = {
+    [key: string]: DynamicFeatureDescriptor;
+};
+export declare function featureFromJson({ type }: {
+    type: string;
+}): ReactElement;
+export interface VuuConfig {
+    features: DynamicFeatures;
+    authUrl?: string;
+    websocketUrl: string;
+    ssl: boolean;
+}
+/**
+ * We currently categorize 'features' simply by the leftNavLocation
+ * @param feature
+ * @returns
+ */
+export declare const isCustomFeature: (feature: DynamicFeatureDescriptor) => boolean;
+export declare const isWildcardSchema: (vuuTables?: "*" | VuuTable[]) => vuuTables is "*";
+export declare const isVuuTables: (vuuTables?: "*" | VuuTable[]) => vuuTables is VuuTable[];
+export interface FeaturePropsWithFilterTableFeature extends Omit<DynamicFeatureProps, "ComponentProps"> {
+    ComponentProps: FilterTableFeatureProps;
+}
+export declare const hasFilterTableFeatureProps: (props: DynamicFeatureProps) => props is FeaturePropsWithFilterTableFeature;
+export declare const isSameTable: (t1: VuuTable, t2: VuuTable) => void;
+export declare const byModule: (schema1: TableSchema, schema2: TableSchema) => -1 | 0 | 1;
+export type GetFeaturePaths = (params: {
+    env: Environment;
+    fileName: string;
+    withCss?: boolean;
+}) => DynamicFeatureProps;
+export declare const getFilterTableFeatures: (schemas: TableSchema[], getFeaturePath: GetFeaturePaths) => DynamicFeatureProps<FilterTableFeatureProps>[];
+export type Component = {
+    componentName: string;
+    component: unknown;
+};
+export declare const assertComponentRegistered: (componentName: string, component: unknown) => void;
+export declare const assertComponentsRegistered: (componentList: Component[]) => void;
+/**
+ *  Process the DynamicFeature descriptors. Identify
+ * the vuu tables required and inject the appropriate TableSchemas
+ *
+ * @param dynamicFeatures
+ * @param tableSchemas
+ * @returns
+ */
+export declare const getCustomAndTableFeatures: (dynamicFeatures: DynamicFeatureDescriptor[], tableSchemas: TableSchema[]) => {
+    dynamicFeatures: DynamicFeatureProps[];
+    tableFeatures: DynamicFeatureProps<FilterTableFeatureProps>[];
+};

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

@@ -0,0 +1,75 @@
+import type { DataSourceFilter } from "@vuu-ui/vuu-data-types";
+import { ColumnFilterOp, ColumnFilterValue, ExtendedFilter, Filter, FilterClauseOp, FilterClauseOpBetween, FilterContainerFilter, FilterWithPartialClause, MultiClauseFilter, MultiValueFilterClause, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+import { SerializableFilter } from "@vuu-ui/vuu-filters/src/filter-container/ExtendedSingleValueFilterClause";
+import { ColumnDescriptor, RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { ScaledDecimal } from "../ScaledDecimal";
+export declare const isBetweenOperator: (op: ColumnFilterOp) => op is FilterClauseOpBetween;
+export declare const isValidFilterClauseOp: (op?: string) => op is FilterClauseOp;
+export declare const isNamedFilter: (f?: Filter) => boolean;
+export declare const isSingleValueFilter: (f?: Partial<Filter>) => f is SingleValueFilterClause;
+export declare const isScaledDecimalFilterClause: (f: SingleValueFilterClause) => f is SingleValueFilterClause<ScaledDecimal>;
+export declare const isSerializableFilter: (f: object) => f is SerializableFilter;
+export declare const isFilter: (f: unknown) => f is Filter;
+export declare const isFilterClause: (f?: Partial<Filter>) => f is SingleValueFilterClause | MultiValueFilterClause;
+export declare const isMultiValueFilter: (f?: Partial<Filter>) => f is MultiValueFilterClause;
+export declare const isInFilter: (f: Partial<Filter>) => f is MultiValueFilterClause;
+export declare const isAndFilter: (f?: Partial<Filter>) => f is MultiClauseFilter<"and">;
+export declare const isBetweenFilter: (f?: Filter) => f is MultiClauseFilter<"and", SingleValueFilterClause>;
+export declare const isOrFilter: (f?: Partial<Filter>) => f is MultiClauseFilter<"or">;
+export declare const isCompleteFilter: (filter: Partial<Filter>) => filter is Filter;
+export declare function isMultiClauseFilter(f?: Partial<Filter> | FilterWithPartialClause): f is MultiClauseFilter;
+export declare const isExtendedFilter: (f: Filter) => f is ExtendedFilter;
+export declare const applyFilterToColumns: (columns: RuntimeColumnDescriptor[], { filterStruct }: DataSourceFilter) => RuntimeColumnDescriptor[];
+export declare const isFilteredColumn: (column: RuntimeColumnDescriptor) => boolean;
+export declare const stripFilterFromColumns: (columns: RuntimeColumnDescriptor[]) => {
+    aggregate?: import("@vuu-ui/vuu-protocol-types").VuuAggType;
+    allowColumnHeaderMenu?: false;
+    colHeaderContentRenderer?: string;
+    colHeaderLabelRenderer?: string;
+    exportFormatter?: (value: unknown) => string;
+    getIcon?: (row: import("@vuu-ui/vuu-table-types").DataRow) => string | undefined;
+    groupable?: boolean;
+    hidden?: boolean;
+    locked?: Exclude<import("@vuu-ui/vuu-table-types").PinLocation, "left"> | false;
+    maxWidth?: number;
+    minWidth?: number;
+    pin?: import("@vuu-ui/vuu-table-types").PinLocation | false;
+    removeable?: boolean;
+    selected?: boolean;
+    source?: "client" | "server";
+    status?: import("@salt-ds/core").ValidationStatus;
+    align?: "left" | "right";
+    ariaColIndex: number;
+    CellRenderer?: import("react").FunctionComponent<import("@vuu-ui/vuu-table-types").TableCellRendererProps>;
+    HeaderCellContentRenderer?: import("react").FunctionComponent<Omit<import("@vuu-ui/vuu-table-types").HeaderCellProps, "id" | "index">>;
+    HeaderCellLabelRenderer?: import("react").FunctionComponent<Omit<import("@vuu-ui/vuu-table-types").HeaderCellProps, "id" | "index">>;
+    canStretch?: boolean;
+    className?: string;
+    clientSideEditValidationCheck?: import("@vuu-ui/vuu-data-types").DataValueValidationChecker;
+    draggable?: boolean;
+    flex?: number;
+    heading?: [...string[]];
+    isGroup?: boolean;
+    isSystemColumn?: boolean;
+    label: string;
+    marginLeft?: number;
+    moving?: boolean;
+    originalIdx?: number;
+    pinnedOffset?: number;
+    pinnedWidth?: number;
+    resizeable?: boolean;
+    resizing?: boolean;
+    sortable?: boolean;
+    sorted?: import("@vuu-ui/vuu-table-types").ColumnSort;
+    valueFormatter: import("@vuu-ui/vuu-table-types").ValueFormatter;
+    width: number;
+    editable?: import("@vuu-ui/vuu-data-types").DataEditable;
+    editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;
+    name: string;
+    required?: boolean;
+    serverDataType?: import("@vuu-ui/vuu-protocol-types").VuuColumnDataType;
+    type?: import("@vuu-ui/vuu-data-types").DataValueType;
+}[];
+export declare const extractFilterForColumn: (filter: Filter | undefined, columnName: string) => Filter | undefined;
+export declare const getColumnValueFromFilter: (column: ColumnDescriptor, operator: ColumnFilterOp, filter?: FilterContainerFilter) => ColumnFilterValue;
+export declare const filtersAreEqual: (f1: FilterContainerFilter | null | undefined, f2: FilterContainerFilter | null | undefined) => boolean;

package/types/src/filters/filterAsQuery.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnDescriptorsByName, Filter, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+export declare const filterAsQuery: (f: Filter, opts?: {
+    columnsByName?: ColumnDescriptorsByName;
+}) => string;
+export declare const ONE_DAY_IN_MILLIS: number;
+export declare function dateFilterAsQuery(f: SingleValueFilterClause<number>, opts?: {
+    columnsByName?: ColumnDescriptorsByName;
+}): string;

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

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

package/types/src/form-utils.d.ts

@@ -0,0 +1,37 @@
+import { DataValueTypeSimple } from "@vuu-ui/vuu-data-types";
+import { VuuColumnDataType, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { KeyboardEvent, SyntheticEvent } from "react";
+import { ExtendedFilterOptions } from "@vuu-ui/vuu-filter-types";
+export declare class DataValidationError extends Error {
+    actualType: string;
+    expectedType: string;
+    constructor(message: string, expectedType: string, actualType: string);
+}
+/**
+ * Use with the following convention:
+ *
+ * <FormField data-field="my-field-name">
+ */
+export declare const getFieldName: (target: EventTarget | HTMLElement) => string;
+export type InputSource = "typeahead-suggestion" | "text-input";
+export declare const isNumber: (type: string, value: VuuRowDataItemType) => value is number;
+export type CommitHandler<E extends HTMLElement = HTMLInputElement, T = VuuRowDataItemType> = (evt: SyntheticEvent<E> | KeyboardEvent<E>, value: T, source?: InputSource) => void;
+export declare const isValidRange: <T>([val1, val2]: [T, T]) => boolean;
+/**
+ * Convert a pair of string values to the type appropriate for the
+ * associated column or form field. Can be used when processing a string value
+ * from an input used for user editing.
+ *
+ */
+export declare function getTypedRange([value1, value2]: [string, string], dataType: VuuColumnDataType | DataValueTypeSimple, options?: ExtendedFilterOptions): (VuuRowDataItemType | undefined)[];
+/**
+ * Convert a string value to the type appropriate for the associated
+ * column or form field. Can be used when processing a string value
+ * from an input used for user editing.
+ *
+ * @param value
+ * @param type
+ * @param throwIfInvalid
+ */
+export declare function getTypedValue(value: string, type: VuuColumnDataType | DataValueTypeSimple, throwIfInvalid?: false, options?: ExtendedFilterOptions): VuuRowDataItemType | undefined;
+export declare function getTypedValue(value: string, type: VuuColumnDataType | DataValueTypeSimple, throwIfInvalid: true, options?: ExtendedFilterOptions): VuuRowDataItemType;

package/types/src/formatting-utils.d.ts

@@ -0,0 +1,14 @@
+import { ColumnDescriptor, ValueFormatter } from "@vuu-ui/vuu-table-types";
+export type ValueFormatters = {
+    [key: string]: ValueFormatter;
+};
+export declare const defaultValueFormatter: (value: unknown) => string;
+export declare const numericFormatter: ({ align, serverDataType, type, }: Partial<ColumnDescriptor>) => typeof defaultValueFormatter;
+export declare const getValueFormatter: (column: ColumnDescriptor) => ValueFormatter;
+/**
+ * Lowercases a string and returns as Lowercase typescript type
+ *
+ * @param str the input string
+ * @returns str converted to Lowercase
+ */
+export declare const lowerCase: (str: string) => Lowercase<string>;

package/types/src/getUniqueId.d.ts

@@ -0,0 +1 @@
+export declare const getUniqueId: () => string;

package/types/src/group-utils.d.ts

@@ -0,0 +1,10 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { VuuGroupBy } from "@vuu-ui/vuu-protocol-types";
+export declare function addGroupColumn(groupBy: VuuGroupBy, column: ColumnDescriptor): string[];
+export declare const removeGroupColumn: (groupBy: VuuGroupBy, column: ColumnDescriptor) => string[];
+export type ColumnGroupStatus = "no-groupby" | "single-groupby-other-column" | "single-groupby" | "multi-groupby-other-columns" | "multi-groupby-includes-column";
+/**
+ * Given a VuuGroupby definition and a column, determine whether the given column
+ * is included in the grouping and if so, in what position/direction.
+ */
+export declare const getGroupStatus: (columnName: string, groupBy?: VuuGroupBy) => ColumnGroupStatus;

package/types/src/html-utils.d.ts

@@ -0,0 +1,21 @@
+export declare const createEl: (elementType: "div" | "p" | "span", className?: string, textContent?: string) => HTMLElement;
+export declare const getFocusableElement: (el: HTMLElement | null, tabIndex?: number) => HTMLElement | undefined;
+export declare const getElementDataIndex: (el: HTMLElement | null) => number;
+export declare function queryClosest<T extends HTMLElement = HTMLElement>(el: HTMLElement | EventTarget | null, cssQueryString: string, throwIfNotFound?: false): T | null;
+export declare function queryClosest<T extends HTMLElement = HTMLElement>(el: HTMLElement | EventTarget | null, cssQueryString: string, throwIfNotFound: true): T;
+export declare const getClosest: (el: HTMLElement, dataProperty: string) => HTMLElement | null;
+export declare const getClosestIndexItem: (el: HTMLElement) => HTMLElement | null;
+export declare function getElementByDataIndex(c: HTMLElement | null | undefined, i: number | string, throwIfNotFound: true): HTMLElement;
+export declare function getElementByDataIndex(c: HTMLElement | null | undefined, i: number | string, throwIfNotFound?: false): HTMLElement | undefined;
+export declare const focusFirstFocusableElement: (el: HTMLElement | null, tabIndex?: number) => void;
+export declare const isSelectableElement: (el?: HTMLElement | null) => boolean;
+export declare const isInputElement: (el: HTMLElement | EventTarget | null) => el is HTMLInputElement;
+export declare const isDateInput: (el: HTMLElement | EventTarget | null) => el is HTMLInputElement;
+export declare const hasOpenOptionList: (el: HTMLElement | EventTarget | null) => boolean | undefined;
+export declare function getScrollbarSize(): number;
+export type MouseEventTypes = "dblclick" | "click";
+export type KeyboardEventTypes = "keydown" | "keypress" | "keyup";
+export declare const dispatchMouseEvent: (el: HTMLElement, type: MouseEventTypes) => void;
+export declare const dispatchKeyboardEvent: (el: HTMLElement, type: KeyboardEventTypes, key: string) => void;
+export type VuuDomEventType = "vuu-commit" | "vuu-dropped" | "vuu-begin-edit" | "vuu-enter-edit-mode" | "vuu-exit-edit-mode";
+export declare const dispatchCustomEvent: (el: HTMLElement, type: VuuDomEventType) => void;