@vuu-ui/vuu-utils 0.13.4 → 0.13.6

package/types/column-utils.d.ts

@@ -0,0 +1,175 @@
+import type { DataSourceRow, DataValueType, DataValueTypeSimple, DateTimeDataValueDescriptor, SchemaColumn, TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuAggType, VuuAggregation, VuuColumnDataType, VuuDataRow, VuuDataRowDto, VuuGroupBy, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import type { ColumnAlignment, ColumnDescriptor, ColumnLayout, DataValueTypeDescriptor, ColumnTypeFormatting, ColumnTypeRendering, ColumnTypeWithValidationRules, DefaultColumnConfiguration, GroupColumnDescriptor, LookupRenderer, MappedValueTypeRenderer, PinLocation, RuntimeColumnDescriptor, TableCellRendererProps, TableConfig, TableHeadings, ValueListRenderer } from "@vuu-ui/vuu-table-types";
+import { type CSSProperties } from "react";
+import { TableModel } from "@vuu-ui/vuu-table";
+/**
+ * ColumnMap provides a lookup of the index position of a data item within a row
+ * by column name.
+ */
+export interface ColumnMap {
+    [columnName: string]: number;
+}
+export type SortCriteriaItem = string | [string, "asc"];
+export declare const AggregationType: {
+    [key: string]: VuuAggType;
+};
+export declare function mapSortCriteria(sortCriteria: SortCriteriaItem[], columnMap: ColumnMap, metadataOffset?: number): [number, "asc"][];
+export declare const getDefaultAlignment: (serverDataType?: VuuColumnDataType) => ColumnAlignment;
+export declare const getRuntimeColumnWidth: (col: ColumnDescriptor, runtimeColumns: RuntimeColumnDescriptor[]) => number;
+export declare const applyRuntimeColumnWidthsToConfig: (tableConfig: TableConfig, columns: RuntimeColumnDescriptor[]) => TableConfig;
+export declare const isValidColumnAlignment: (v: string) => v is ColumnAlignment;
+export declare const isValidPinLocation: (v: string) => v is PinLocation;
+export type CalculatedColumn = {
+    name: string;
+    expression: string;
+    serverDataType: VuuColumnDataType;
+};
+export declare const isVuuColumnDataType: (value: string | undefined | null) => value is VuuColumnDataType;
+export declare const fromServerDataType: (serverDataType: VuuColumnDataType) => DataValueTypeSimple;
+export declare const isNumericColumn: ({ serverDataType, type }: ColumnDescriptor) => boolean;
+export declare const isDateTimeDataValue: (column: ColumnDescriptor) => column is DateTimeDataValueDescriptor;
+export declare const isPinned: (column: ColumnDescriptor) => boolean;
+export declare const hasHeadings: (column: ColumnDescriptor) => boolean;
+export declare const isResizing: (column: RuntimeColumnDescriptor) => boolean | undefined;
+export declare const isTextColumn: ({ serverDataType }: ColumnDescriptor) => boolean;
+export declare const toColumnDescriptor: (name: string) => ColumnDescriptor;
+/**
+ *
+ */
+export declare const isTypeDescriptor: (type?: DataValueType) => type is DataValueTypeDescriptor;
+export declare const isColumnTypeRenderer: (renderer?: unknown) => renderer is ColumnTypeRendering;
+export declare const hasCustomRenderer: (type?: DataValueType) => type is DataValueTypeDescriptor;
+export declare const isLookupRenderer: (renderer?: unknown) => renderer is LookupRenderer;
+export declare const isValueListRenderer: (renderer?: unknown) => renderer is ValueListRenderer;
+export declare const hasValidationRules: (type?: DataValueType) => type is ColumnTypeWithValidationRules;
+export declare const isMappedValueTypeRenderer: (renderer?: unknown) => renderer is MappedValueTypeRenderer;
+export declare function buildColumnMap(columns?: (ColumnDescriptor | SchemaColumn | string)[]): ColumnMap;
+export declare function projectUpdates(updates: number[]): number[];
+export declare const metadataKeys: {
+    readonly IDX: 0;
+    readonly RENDER_IDX: 1;
+    readonly IS_LEAF: 2;
+    readonly IS_EXPANDED: 3;
+    readonly DEPTH: 4;
+    readonly COUNT: 5;
+    readonly KEY: 6;
+    readonly SELECTED: 7;
+    readonly count: 8;
+    readonly PARENT_IDX: "parent_idx";
+    readonly IDX_POINTER: "idx_pointer";
+    readonly FILTER_COUNT: "filter_count";
+    readonly NEXT_FILTER_IDX: "next_filter_idx";
+};
+export declare const flattenColumnGroup: (columns: RuntimeColumnDescriptor[]) => RuntimeColumnDescriptor[];
+export declare function extractGroupColumn({ availableWidth, columns, groupBy, confirmed, }: ColumnGroupProps): [
+    GroupColumnDescriptor | null,
+    RuntimeColumnDescriptor[]
+];
+export declare const isGroupColumn: (column: RuntimeColumnDescriptor) => column is GroupColumnDescriptor;
+/**
+ *  groupConfirmed is currently the only 'pending' attribute we use. A
+ * value of true is only reset by a follow-up value of false. Intermediary
+ * values of undefined are discounted.
+ */
+export declare const checkConfirmationPending: (previousConfig?: TableModel) => boolean | undefined;
+export declare const isJsonAttribute: (value: unknown) => boolean;
+export declare const isJsonGroup: (column: RuntimeColumnDescriptor, row: VuuDataRow, columnMap: ColumnMap) => boolean;
+export declare const isJsonColumn: (column: RuntimeColumnDescriptor) => boolean;
+export declare const sortPinnedColumns: (columns: RuntimeColumnDescriptor[]) => RuntimeColumnDescriptor[];
+export declare const measurePinnedColumns: (columns: RuntimeColumnDescriptor[], selectionEndSize: number) => {
+    pinnedWidthLeft: number;
+    pinnedWidthRight: number;
+    unpinnedWidth: number;
+};
+export declare const getTableHeadings: (columns: RuntimeColumnDescriptor[]) => TableHeadings;
+export declare const getColumnStyle: ({ pin, pinnedOffset, width, }: RuntimeColumnDescriptor) => CSSProperties;
+export declare const setAggregations: (aggregations: VuuAggregation[], column: ColumnDescriptor, aggType: VuuAggType) => VuuAggregation[];
+export type ColumnGroupProps = {
+    columns: RuntimeColumnDescriptor[];
+    groupBy: VuuGroupBy;
+    confirmed?: boolean;
+    availableWidth: number;
+};
+export declare const applyGroupByToColumns: (props: ColumnGroupProps) => RuntimeColumnDescriptor[];
+export declare const applySortToColumns: (columns: RuntimeColumnDescriptor[], sort: VuuSort) => RuntimeColumnDescriptor[];
+export declare const removeSort: (columns: RuntimeColumnDescriptor[]) => RuntimeColumnDescriptor[];
+export declare const existingSort: (columns: RuntimeColumnDescriptor[]) => boolean;
+export declare const getColumnName: (name: string) => string;
+export declare const getColumnLabel: (column: ColumnDescriptor) => string;
+export declare const findColumn: (columns: RuntimeColumnDescriptor[], columnName: string) => RuntimeColumnDescriptor | undefined;
+export declare function updateColumn<T extends ColumnDescriptor>(columns: T[], column: T): T[];
+export declare function updateColumn(columns: RuntimeColumnDescriptor[], column: string, options: Partial<ColumnDescriptor>): RuntimeColumnDescriptor[];
+export declare const toDataSourceColumns: (column: ColumnDescriptor) => string;
+export declare const dataSourceRowToDataRowDto: (row: DataSourceRow, columnMap: ColumnMap) => VuuDataRowDto;
+export declare const isDataLoading: (columns: RuntimeColumnDescriptor[]) => boolean;
+export declare const getColumnsInViewport: (columns: RuntimeColumnDescriptor[], vpStart: number, vpEnd: number) => [RuntimeColumnDescriptor[], number];
+export declare const isNotHidden: (column: RuntimeColumnDescriptor) => boolean;
+export declare const visibleColumnAtIndex: (columns: RuntimeColumnDescriptor[], index: number) => RuntimeColumnDescriptor | undefined;
+export declare const getGroupIcon: (columns: RuntimeColumnDescriptor[], row: DataSourceRow) => string | undefined;
+export declare const getGroupValue: (columns: RuntimeColumnDescriptor[], row: DataSourceRow, columnMap: ColumnMap) => string | null;
+export declare const getDefaultColumnType: (serverDataType?: VuuColumnDataType) => DataValueTypeSimple;
+export declare const updateColumnFormatting: <T extends ColumnDescriptor = ColumnDescriptor>(column: T, formatting: ColumnTypeFormatting) => T;
+export declare function updateColumnType<T extends ColumnDescriptor = ColumnDescriptor>(column: T, type: DataValueTypeSimple): T;
+export declare const updateColumnRenderProps: <T extends ColumnDescriptor = ColumnDescriptor>(column: T, renderer: ColumnTypeRendering) => T;
+export declare const getTypeFormattingFromColumn: (column: ColumnDescriptor) => ColumnTypeFormatting;
+/**
+ * Return a filter predicate that will reject columns, names of which
+ * are not in provided list. Exception made for columns explicitly
+ * configured as client columns.
+ */
+export declare const subscribedOnly: (columnNames?: string[]) => (column: ColumnDescriptor) => boolean | undefined;
+export declare const addColumnToSubscribedColumns: (subscribedColumns: ColumnDescriptor[], availableColumns: SchemaColumn[], columnName: string) => ColumnDescriptor[];
+export declare const isCalculatedColumn: (columnName?: string) => boolean;
+export declare const getCalculatedColumnDetails: (column: ColumnDescriptor) => Partial<CalculatedColumn>;
+export declare const setCalculatedColumnName: (column: ColumnDescriptor, name: string) => ColumnDescriptor;
+export declare const setCalculatedColumnType: (column: ColumnDescriptor, type: string) => ColumnDescriptor;
+export declare const setCalculatedColumnExpression: (column: ColumnDescriptor, expression: string) => ColumnDescriptor;
+export declare const moveColumnTo: (columns: ColumnDescriptor[], column: ColumnDescriptor, newIndex: number) => ColumnDescriptor[];
+export declare function replaceColumn<C extends ColumnDescriptor = RuntimeColumnDescriptor>(columns: C[], column: C): C[];
+export declare const applyDefaultColumnConfig: ({ columns, table }: TableSchema, getDefaultColumnConfig?: DefaultColumnConfiguration) => SchemaColumn[];
+export type columnOptions = {
+    availableWidth?: number;
+    columnLayout?: ColumnLayout;
+    defaultWidth?: number;
+    defaultMinWidth?: number;
+    defaultMaxWidth?: number;
+    defaultFlex?: number;
+};
+type ColumnLayoutOptions = Pick<columnOptions, "defaultMinWidth" | "defaultMaxWidth" | "defaultWidth">;
+interface StaticColumnLayoutOptions extends ColumnLayoutOptions {
+    columnLayout: "manual" | "static";
+}
+interface FitColumnLayoutOptions extends ColumnLayoutOptions {
+    availableWidth?: number;
+    columnLayout: "fit";
+}
+export declare function applyWidthToColumns(columns: RuntimeColumnDescriptor[], options: StaticColumnLayoutOptions | FitColumnLayoutOptions): RuntimeColumnDescriptor[];
+/**
+ * A memo compare function for cell renderers. Can be used to suppress
+ * render where column and data are both unchanged. Avoids render
+ * when row changes, where changes in row are unrelated to this cell.
+ * Suitabnle only for readonly cell renderers. See below for editable
+ * cell renderers.
+ */
+export declare const dataAndColumnUnchanged: (p: TableCellRendererProps, p1: TableCellRendererProps) => boolean;
+/**
+ * A memo compare function for cell renderers. Can be used to suppress
+ * render where column, row key  and data are all unchanged. Avoids render
+ * when row changes, where changes in row are unrelated to this cell.
+ * Suitable for editable cells. Including key in compare is not strictly
+ * necessary for rendering, but it is important in the event that user
+ * edits data - ensures we never have a stale key.
+ */
+export declare const dataColumnAndKeyUnchanged: (p: TableCellRendererProps, p1: TableCellRendererProps) => boolean;
+export declare const toColumnName: (column: ColumnDescriptor) => string;
+export declare const isStringColumn: (column: ColumnDescriptor) => boolean;
+/**
+ * Given an ordered list of column names, return column items in same order
+ */
+export declare const reorderColumnItems: <T extends {
+    name: string;
+} = {
+    name: string;
+}>(columnItems: Array<T>, orderedNames: string[]) => T[];
+export {};

package/types/common-types.d.ts

@@ -0,0 +1,6 @@
+export type orientationType = "horizontal" | "vertical";
+type measureProp = keyof DOMRect;
+type measureType = Record<string, measureProp>;
+type measuresType = Record<orientationType, measureType>;
+export declare const MEASURES: measuresType;
+export {};

package/types/component-registry.d.ts

@@ -0,0 +1,62 @@
+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";
+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<HeaderCellProps> | undefined;
+export declare function getColumnHeaderLabelRenderer(column: ColumnDescriptor): FC<HeaderCellProps> | 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/context-definitions/DataContext.d.ts

@@ -0,0 +1,19 @@
+import type { DataSource, DataSourceConstructorProps, ServerAPI, TableSchema } from "@vuu-ui/vuu-data-types";
+export type DataSourceConstructor = {
+    new (props: DataSourceConstructorProps): DataSource;
+};
+export interface DataContextProps {
+    VuuDataSource: DataSourceConstructor;
+    dataSourceExtensions?: unknown;
+    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/context-definitions/DataProvider.d.ts

@@ -0,0 +1,8 @@
+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;
+export declare const useDataSourceExtensions: () => unknown;

package/types/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/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/cookie-utils.d.ts

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

package/types/css-utils.d.ts

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

package/types/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) => "int" | "double" | "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/datasource/BaseDataSource.d.ts

@@ -0,0 +1,46 @@
+import type { DataSource, DataSourceConfig, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceSubscribeCallback, DataSourceSubscribeProps, 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 { 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>);
+    set impendingConfig(config: 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;
+    abstract rangeRequest(range: VuuRange): void;
+}

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

@@ -0,0 +1,45 @@
+import { ConnectionQualityMetrics, DataSourceCallbackMessage, DataSourceConfig, DataSourceDataMessage, DataSourceRow, RpcResponse, TypeaheadSuggestionProvider, VuuUIMessageIn, VuuUIMessageInRPC, VuuUIMessageInRPCEditReject, VuuUIMessageInTableMeta, VuuUIMessageOutViewport, WithBaseFilter, WithFilter, WithFullConfig, WithGroupBy, WithSort } from "@vuu-ui/vuu-data-types";
+import { LinkDescriptorWithLabel, VuuCreateVisualLink, VuuFilter, VuuRemoveVisualLink, VuuRowDataItemType, 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 VuuUIMessageInRPCEditReject;
+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 declare const messageHasDataRows: (message: DataSourceCallbackMessage) => message is DataSourceDataMessageWithRows;
+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/date/date-utils.d.ts

@@ -0,0 +1,2 @@
+import { CalendarDate } from "@internationalized/date";
+export declare function toCalendarDate(d: Date): CalendarDate;

package/types/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/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/date/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./formatter";
+export { dateTimeLabelByType, isDatePattern, isTimePattern, isDateTimePattern, type DatePattern, type TimePattern, type DateTimePattern, supportedDateTimePatterns, } from "./types";
+export { toCalendarDate } from "./date-utils";
+export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern, } from "./dateTimePattern";

package/types/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"];
+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"];
+};
+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/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/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/feature-utils.d.ts

@@ -0,0 +1,104 @@
+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 {
+    name: string;
+    title: string;
+    url: string;
+    css?: string;
+    leftNavLocation: "vuu-features" | "vuu-tables";
+    featureProps?: {
+        vuuTables?: "*" | VuuTable[];
+    };
+    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>[];
+};