@vuu-ui/vuu-data-test 0.13.45 → 0.13.46

package/types/vuu-utils/src/component-registry.d.ts

@@ -0,0 +1,65 @@
+import { DataSourceRow, EditRuleValidator } from "@vuu-ui/vuu-data-types";
+import { VuuColumnDataType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor, ColumnDescriptorCustomRenderer, ColumnTypeRendering, HeaderCellProps, TableCellRendererProps } from "@vuu-ui/vuu-table-types";
+import { FunctionComponent as FC, HTMLAttributes } from "react";
+import { ColumnMap } from "./column-utils";
+export interface CellConfigPanelProps extends HTMLAttributes<HTMLDivElement> {
+    onConfigChange: () => void;
+}
+export type PropertyChangeHandler = (propertyName: string, propertyValue: string | number | boolean) => void;
+export type ColumnRenderPropsChangeHandler = (renderProps: ColumnTypeRendering) => void;
+export interface ConfigurationEditorProps {
+    column: ColumnDescriptorCustomRenderer;
+    onChangeRendering: ColumnRenderPropsChangeHandler;
+}
+export type RowClassNameGenerator = (row: DataSourceRow, columnMap: ColumnMap) => string | undefined;
+export type RowClassGenerator = {
+    id: string;
+    fn: RowClassNameGenerator;
+};
+export type ConfigEditorComponent = FC<CellConfigPanelProps>;
+export type layoutComponentType = "container" | "view";
+export type ComponentType = layoutComponentType | "cell-renderer" | "cell-config-panel" | "column-header-content-renderer" | "column-header-label-renderer" | "component" | "data-edit-validator" | "row-class-generator";
+/**
+ * The CellRenderer Options provide configuration for the Column Settings panel
+ */
+type CellRendererOptions = {
+    configEditor?: string;
+    description?: string;
+    label?: string;
+    serverDataType?: VuuColumnDataType | VuuColumnDataType[] | "json" | "private";
+    userCanAssign?: boolean;
+};
+export interface CellRendererDescriptor extends CellRendererOptions {
+    name: string;
+}
+/**
+ * This check is performed during construction of UI from JSON. If component
+ * is not registered, it will log a warning.
+ */
+export declare const isContainer: (componentType: string) => boolean;
+/**
+ * This check is performed during construction of UI from JSON. If component
+ * is not registered, it will log a warning.
+ */
+export declare const isView: (componentType: string) => boolean;
+/**
+ * This check is performed during construction of UI from JSON. If component
+ * is not registered, it will log a warning.
+ */
+export declare const isLayoutComponent: (componentType: string) => componentType is layoutComponentType;
+export declare function registerComponent(componentName: string, component: RowClassGenerator, componentType: "row-class-generator", options?: CellRendererOptions): void;
+export declare function registerComponent(componentName: string, component: EditRuleValidator, componentType: "data-edit-validator", options?: CellRendererOptions): void;
+export declare function registerComponent(componentName: string, component: FC<any>, componentType: Omit<ComponentType, "data-edit-validator" | "row-class-generator">, options?: CellRendererOptions): void;
+export declare const registerConfigurationEditor: (componentName: string, configurationEditor: FC<ConfigurationEditorProps>) => void;
+export declare const getRegisteredCellRenderers: (serverDataType?: VuuColumnDataType | "json") => CellRendererDescriptor[];
+export declare const getLayoutComponent: (componentName: string) => FC<any>;
+export declare const getCellRendererOptions: (renderName: string) => CellRendererOptions | undefined;
+export declare function getCellRenderer(column: ColumnDescriptor): FC<TableCellRendererProps> | undefined;
+export declare function getColumnHeaderContentRenderer(column: ColumnDescriptor): FC<Omit<HeaderCellProps, "index" | "id">> | undefined;
+export declare function getColumnHeaderLabelRenderer(column: ColumnDescriptor): FC<Omit<HeaderCellProps, "index" | "id">> | undefined;
+export declare const getRowClassNameGenerator: (generatorId: string) => RowClassGenerator | undefined;
+export declare function getConfigurationEditor(configEditor?: string): FC<ConfigurationEditorProps> | undefined;
+export declare function getCellConfigPanelRenderer(name: string): ConfigEditorComponent | undefined;
+export declare function getEditRuleValidator(name: string): EditRuleValidator | undefined;
+export {};

package/types/vuu-utils/src/context-definitions/DataContext.d.ts

@@ -0,0 +1,18 @@
+import type { DataSource, DataSourceConstructorProps, ServerAPI, TableSchema } from "@vuu-ui/vuu-data-types";
+export type DataSourceConstructor = {
+    new (props: DataSourceConstructorProps): DataSource;
+};
+export interface DataContextProps {
+    VuuDataSource: DataSourceConstructor;
+    isLocalData: boolean;
+    getServerAPI: () => Promise<Pick<ServerAPI, "getTableList" | "getTableSchema" | "rpcCall">>;
+    /**
+     * A tableSchema would normally be requested via the serverAPI.
+     * schemas can be injected, in which case these 'local' schemas
+     * will be returned from the getTableSchema API call.
+     * The key is formed from concatenation of module and tableName
+     * from VuuTable e.g 'SIMUL:instruments'
+     */
+    tableSchemas?: Record<string, TableSchema>;
+}
+export declare const DataContext: import("react").Context<DataContextProps>;

package/types/vuu-utils/src/context-definitions/DataProvider.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+import { DataContextProps } from "./DataContext";
+export declare const DataProvider: ({ children, getServerAPI, isLocalData, VuuDataSource, }: Omit<DataContextProps, "isLocalData"> & {
+    children: ReactNode;
+    isLocalData?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useData: () => DataContextProps;

package/types/vuu-utils/src/context-definitions/DataSourceProvider.d.ts

@@ -0,0 +1,12 @@
+import { DataSource } from "@vuu-ui/vuu-data-types";
+import { ReactNode } from "react";
+export interface DataSourceContextProps {
+    dataSource?: DataSource;
+}
+export declare const DataSourceContext: import("react").Context<DataSourceContextProps>;
+export declare const DataSourceProvider: ({ children, dataSource, }: {
+    children: ReactNode;
+    dataSource: DataSource;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useDataSource(throwIfNoDataSource: true): DataSource;
+export declare function useDataSource(throwIfNoDataSource: false | undefined): DataSource | undefined;

package/types/vuu-utils/src/context-definitions/WorkspaceContext.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { ApplicationSetting, ApplicationSettings, LayoutJSON } from "../json-types";
+import { LayoutMetadata, LayoutMetadataDto } from "../layout-types";
+export interface WorkspaceContextProps {
+    layoutMetadata: LayoutMetadata[];
+    layoutPlaceholderJSON?: LayoutJSON;
+    getApplicationSettings: (key?: keyof ApplicationSettings) => ApplicationSettings | ApplicationSetting | undefined;
+    loadLayoutById: (id: string) => void;
+    saveApplicationSettings: (settings: ApplicationSettings | ApplicationSetting, key?: keyof ApplicationSettings) => void;
+    saveLayout: (n: LayoutMetadataDto) => void;
+    saveApplicationLayout: (layout: LayoutJSON) => void;
+    workspaceJSON?: LayoutJSON | LayoutJSON[];
+}
+export declare const WorkspaceContext: React.Context<WorkspaceContextProps>;
+export declare const usePlaceholderJSON: () => LayoutJSON<{
+    [key: string]: any;
+}> | undefined;

package/types/vuu-utils/src/cookie-utils.d.ts

@@ -0,0 +1 @@
+export declare const getCookieValue: (name: string) => string | number | undefined;

package/types/vuu-utils/src/css-utils.d.ts

@@ -0,0 +1 @@
+export declare const importCSS: (path: string) => Promise<CSSStyleSheet>;

package/types/vuu-utils/src/data-utils.d.ts

@@ -0,0 +1,19 @@
+export type valueChangeDirection = "up1" | "up2" | "down1" | "down2" | "";
+export declare const UP1 = "up1";
+export declare const UP2 = "up2";
+export declare const DOWN1 = "down1";
+export declare const DOWN2 = "down2";
+export declare const stringIsValidInt: (val: string) => boolean;
+export declare const stringIsValidDecimal: (val: string) => boolean;
+export declare const stringIsValidNumber: (val: string) => boolean;
+export declare const numericTypeOfStringValue: (val: string) => "double" | "int" | "NaN";
+export declare const isValidNumber: (n: unknown) => n is number;
+export declare const shallowEquals: (o1?: {
+    [key: string]: unknown;
+}, o2?: {
+    [key: string]: unknown;
+}) => boolean;
+export declare function getMovingValueDirection(newValue?: number, direction?: valueChangeDirection, prevValue?: number, 
+/** the number of decimal places to take into account when highlighting a change  */
+decimalPlaces?: number): valueChangeDirection;
+export declare function asInteger(index: number | string | undefined, defaultValue?: number): number;

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

@@ -0,0 +1,60 @@
+import type { DataSource, DataSourceConfig, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceSubscribeCallback, DataSourceSubscribeProps, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
+import { LinkDescriptorWithLabel, VuuAggregation, VuuRange, VuuRpcEditRequest, VuuRpcEditResponse, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import { EventEmitter } from "../event-emitter";
+import { DataSourceConfigChanges } from "./datasource-utils";
+import { Range } from "../range-utils";
+export type RuntimeConfig = WithBaseFilter<WithFullConfig> & {
+    visualLink?: LinkDescriptorWithLabel;
+};
+export declare abstract class BaseDataSource extends EventEmitter<DataSourceEvents> implements Pick<DataSource, "config"> {
+    #private;
+    viewport: string;
+    protected _clientCallback: DataSourceSubscribeCallback | undefined;
+    protected _config: RuntimeConfig;
+    protected _impendingConfig: RuntimeConfig | undefined;
+    protected _range: Range;
+    protected _size: number;
+    protected _title: string | undefined;
+    private awaitingConfirmationOfConfigChanges;
+    constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, sort, 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);
+    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);
+    applyConfig(config: WithBaseFilter<DataSourceConfig>, preserveExistingConfigAttributes?: boolean): DataSourceConfigChanges | undefined;
+    freeze(): void;
+    unfreeze(): void;
+    get freezeTimestamp(): number | undefined;
+    get isFrozen(): boolean;
+    abstract rangeRequest(range: VuuRange): void;
+    editRpcCall(rpcRequest: Omit<VuuRpcEditRequest, "vpId">): Promise<VuuRpcEditResponse>;
+}

package/types/vuu-utils/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/vuu-utils/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/vuu-utils/src/datasource/datasource-utils.d.ts

@@ -0,0 +1,49 @@
+import { ConnectionQualityMetrics, DataSourceCallbackMessage, DataSourceConfig, DataSourceDataMessage, DataSourceRow, RpcResponse, TypeaheadSuggestionProvider, VuuUIMessageIn, VuuUIMessageInRPC, VuuUIMessageInTableMeta, VuuUIMessageOutViewport, WithBaseFilter, WithFilter, WithFullConfig, WithGroupBy, WithSort } from "@vuu-ui/vuu-data-types";
+import { LinkDescriptorWithLabel, VuuCreateVisualLink, VuuFilter, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcEditError, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap } from "../column-utils";
+export declare const NoFilter: VuuFilter;
+export declare const NoSort: VuuSort;
+export declare const vanillaConfig: 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 isErrorResponse: (response?: Partial<RpcResponse>) => response is VuuRpcEditError;
+export declare const isVisualLinkMessage: (msg: unknown) => msg is VuuCreateVisualLink | VuuRemoveVisualLink;
+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/vuu-utils/src/date/date-utils.d.ts

@@ -0,0 +1,36 @@
+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>): Hours | TimeUnitValue<T>;
+export declare function decrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): Hours | TimeUnitValue<T>;
+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 const Time: {
+    (timeString: TimeString): Time;
+    millisToTimeString(timestamp: number): TimeString;
+};
+export {};

package/types/vuu-utils/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/vuu-utils/src/date/formatter.d.ts

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

package/types/vuu-utils/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, isDateTimePattern, isTimePattern, supportedDateTimePatterns, type DatePattern, type DateTimePattern, type TimePattern, } from "./types";

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

@@ -0,0 +1,24 @@
+import { ColumnTypeFormatting } from "@vuu-ui/vuu-table-types";
+declare const supportedDatePatterns: readonly ["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 ["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/vuu-utils/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/vuu-utils/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/vuu-utils/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) => 0 | 1 | -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/vuu-utils/src/filters/filter-utils.d.ts

@@ -0,0 +1,82 @@
+import type { DataSourceFilter } from "@vuu-ui/vuu-data-types";
+import { ColumnFilterOp, ColumnFilterValue, Filter, FilterClauseOp, FilterContainerFilter, FilterWithPartialClause, MultiClauseFilter, MultiValueFilterClause, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+import { ColumnDescriptor, RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+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 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 applyFilterToColumns: (columns: RuntimeColumnDescriptor[], { filterStruct }: DataSourceFilter) => RuntimeColumnDescriptor[];
+export declare const isFilteredColumn: (column: RuntimeColumnDescriptor) => boolean;
+export declare const stripFilterFromColumns: (columns: RuntimeColumnDescriptor[]) => {
+    align?: "left" | "right";
+    ariaColIndex: number;
+    CellRenderer?: import("react").FunctionComponent<import("@vuu-ui/vuu-table-types").TableCellRendererProps>;
+    HeaderCellLabelRenderer?: import("react").FunctionComponent<Omit<import("@vuu-ui/vuu-table-types").HeaderCellProps, "id" | "index">>;
+    HeaderCellContentRenderer?: 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;
+    endPin?: true | undefined;
+    flex?: number;
+    heading?: [...string[]];
+    isGroup?: boolean;
+    isSystemColumn?: boolean;
+    label: string;
+    locked?: boolean;
+    marginLeft?: number;
+    moving?: boolean;
+    originalIdx?: number;
+    pinnedOffset?: 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;
+    aggregate?: import("packages/vuu-protocol-types").VuuAggType;
+    allowColumnHeaderMenu?: false;
+    colHeaderContentRenderer?: string;
+    colHeaderLabelRenderer?: string;
+    getIcon?: (row: import("@vuu-ui/vuu-data-types").DataSourceRow) => string | undefined;
+    groupable?: boolean;
+    hidden?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+    pin?: import("@vuu-ui/vuu-table-types").PinLocation | false;
+    source?: "client" | "server";
+    editable?: boolean;
+    editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;
+    name: string;
+    serverDataType?: import("packages/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;
+/**
+ * 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): void;
+    has({ name }: ColumnDescriptor): boolean;
+    get({ name }: ColumnDescriptor): FilterContainerFilter | undefined;
+    /**
+     * Remove filter for this column. Return false if no filter found, otw true
+     */
+    remove(column: ColumnDescriptor): boolean;
+    get filter(): FilterContainerFilter | undefined;
+}
+export declare const filtersAreEqual: (f1: FilterContainerFilter, f2: FilterContainerFilter) => boolean;

package/types/vuu-utils/src/filters/filterAsQuery.d.ts

@@ -0,0 +1,7 @@
+import { ColumnDescriptorsByName, Filter, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+import type { RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export declare const filterAsQuery: (f: Filter, opts?: {
+    columnsByName?: ColumnDescriptorsByName;
+}) => string;
+export declare function dateFilterAsQuery(f: SingleValueFilterClause<number>): string;
+export declare const removeColumnFromFilter: (column: RuntimeColumnDescriptor, filter: Filter) => [Filter | undefined, string];

package/types/vuu-utils/src/filters/index.d.ts

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

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

@@ -0,0 +1,23 @@
+import { VuuColumnDataType, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { KeyboardEvent, SyntheticEvent } from "react";
+import { DataValueTypeSimple } from "@vuu-ui/vuu-data-types";
+/**
+ * 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;
+/**
+ * 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): VuuRowDataItemType | undefined;
+export declare function getTypedValue(value: string, type: VuuColumnDataType | DataValueTypeSimple, throwIfInvalid: true): VuuRowDataItemType;

package/types/vuu-utils/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, type, }: Partial<ColumnDescriptor>) => (value: unknown) => string;
+export declare const getValueFormatter: (column: ColumnDescriptor, serverDataType?: import("packages/vuu-protocol-types").VuuColumnDataType | undefined) => 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>;