@vuu-ui/vuu-utils 3.3.9 → 3.3.10

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.9",
+  "version": "3.3.10",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -15,14 +15,14 @@
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "3.3.9",
-    "@vuu-ui/vuu-table-types": "3.3.9",
-    "@vuu-ui/vuu-filter-types": "3.3.9",
-    "@vuu-ui/vuu-protocol-types": "3.3.9"
+    "@vuu-ui/vuu-data-types": "3.3.10",
+    "@vuu-ui/vuu-table-types": "3.3.10",
+    "@vuu-ui/vuu-filter-types": "3.3.10",
+    "@vuu-ui/vuu-protocol-types": "3.3.10"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "3.3.9",
+    "@vuu-ui/vuu-filter-parser": "3.3.10",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"

package/types/src/Clock.d.ts

@@ -0,0 +1,20 @@
+export interface ClockProps {
+    year?: number;
+    month?: number;
+    day?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+}
+export type ClockTimeUnit = "minutes" | "seconds" | "ms";
+export declare class Clock {
+    #private;
+    constructor(props?: ClockProps);
+    goBack(value: number, units?: ClockTimeUnit): this;
+    advance(value: number, units?: ClockTimeUnit): this;
+    set showCurrentTime(value: boolean);
+    toString(): string;
+    get now(): number;
+    get date(): Date;
+}

package/types/src/PageVisibilityObserver.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from "./event-emitter";
+export type PageVisibilityEvents = {
+    /**
+     * emits when page has been hidden for this period of time
+     */
+    "inactive-timeout": () => void;
+    /**
+     * emits when page is hidden
+     */
+    hidden: () => void;
+    /**
+     * emits when page is made visible
+     */
+    visible: () => void;
+    /**
+     * emits when page visibility status changes
+     */
+    visibilityChange: (hidden: boolean) => void;
+};
+export interface PageVisibilityObserverConstructorProps {
+    /**
+     * timeout period in seconds. Defaults to zero which will never timeout
+     */
+    inactiveTimeout?: number;
+    onHidden?: () => void;
+    onInactiveTimeout?: () => void;
+    onVisible?: () => void;
+    onVisibilityChange?: () => void;
+}
+export declare class PageVisibilityObserver extends EventEmitter<PageVisibilityEvents> {
+    #private;
+    visibilityChangeHandler: () => void;
+    constructor({ inactiveTimeout, onHidden, onInactiveTimeout, onVisibilityChange, onVisible, }?: PageVisibilityObserverConstructorProps);
+    clear(): void;
+    private set hidden(value);
+}

package/types/src/ScaledDecimal.d.ts

@@ -0,0 +1,12 @@
+export declare class ScaledDecimal {
+    protected readonly value: string;
+    private readonly decimals;
+    constructor(value: string, decimals?: number);
+    get asLong(): string;
+    toJSON(): string;
+    toString(): string;
+}
+export declare const ScaledDecimal2: (value: string) => ScaledDecimal;
+export declare const ScaledDecimal4: (value: string) => ScaledDecimal;
+export declare const ScaledDecimal6: (value: string) => ScaledDecimal;
+export declare const ScaledDecimal8: (value: string) => ScaledDecimal;

package/types/src/ShellContext.d.ts

@@ -0,0 +1,11 @@
+import type { RpcResponseHandler } from "@vuu-ui/vuu-data-types";
+import type { DefaultColumnConfiguration, DefaultTableConfiguration } from "@vuu-ui/vuu-table-types";
+import { LookupTableProvider } from "./feature-utils";
+export interface ShellContextProps {
+    getDefaultColumnConfig?: DefaultColumnConfiguration;
+    getDefaultTableConfig?: DefaultTableConfiguration;
+    getLookupValues?: LookupTableProvider;
+    handleRpcResponse?: RpcResponseHandler;
+}
+export declare const ShellContext: import("react").Context<ShellContextProps>;
+export declare const useShellContext: () => ShellContextProps;

package/types/src/ThemeProvider.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from "react";
+export declare const DEFAULT_DENSITY: Density;
+export declare const DEFAULT_THEME = "salt-theme";
+export declare const DEFAULT_THEME_MODE: ThemeMode;
+export type Density = "high" | "medium" | "low" | "touch";
+export type ThemeMode = "light" | "dark";
+export type TargetElement = "root" | "scope" | "child";
+export interface ThemeContextProps {
+    density: Density;
+    theme: string;
+    themeMode: ThemeMode;
+}
+export declare const ThemeContext: import("react").Context<ThemeContextProps>;
+export type ThemeClasses = [string, string, ThemeMode];
+export type ThemeAttributes = {
+    themeClass: string;
+    densityClass: string;
+    dataMode: ThemeMode;
+};
+export declare const useThemeAttributes: (themeAttributes?: ThemeAttributes) => [string, string, ThemeMode];
+interface ThemeProviderProps {
+    applyThemeClasses?: boolean;
+    children: ReactNode;
+    density?: Density;
+    theme?: string;
+    themeMode?: ThemeMode;
+}
+export declare function ThemeProvider({ applyThemeClasses, children, theme: themeProp, themeMode: themeModeProp, density: densityProp, }: ThemeProviderProps): import("react").JSX.Element;
+export declare namespace ThemeProvider {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,16 @@
+export type PartitionTest<T> = (value: T, index: number) => boolean;
+export declare function partition<T>(array: T[], test: PartitionTest<T>, pass?: T[], fail?: T[]): [T[], T[]];
+export declare function itemsChanged<T = unknown>(currentItems: T[], newItems: T[], identityProperty?: string): boolean;
+export declare function itemsOrOrderChanged<T = unknown>(currentItems: T[], newItems: T[], identityProperty?: string): boolean;
+export declare const moveItemDeprecated: <T = unknown>(items: T[], item: T, moveTo: number) => T[];
+export declare const moveItem: <T = unknown>(items: T[], fromIndex: number, toIndex: number) => T[];
+export declare const getAddedItems: <T>(values: undefined | T[], newValues: T[]) => T[];
+export declare const getMissingItems: <T, I>(sourceItems: T[], items: I[], identity: (s: T) => I) => I[];
+/**
+ * Given an ordered list of item names, return items in same order
+ */
+export declare const reorderItems: <T extends {
+    name: string;
+} = {
+    name: string;
+}>(originalItems: readonly T[], orderedNames: string[]) => T[];

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

@@ -0,0 +1,24 @@
+export interface rect {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export type rectTuple = [number, number, number, number];
+export type dimension = "width" | "height";
+export declare function boxContainsPoint(rect: rect, x: number, y: number): boolean | undefined;
+export type GridLayoutSplitDirection = "north" | "south" | "east" | "west";
+export type GridLayoutDropPosition = GridLayoutSplitDirection | "header" | "centre";
+export declare function getCenteredBox({ right, left, top, bottom }: rect, pctSize: number): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export declare function pointPositionWithinRect(x: number, y: number, rect: rect, borderZone?: number): {
+    pctX: number;
+    pctY: number;
+    closeToTheEdge: number;
+};
+export declare const isGridLayoutSplitDirection: (position: GridLayoutDropPosition) => position is GridLayoutSplitDirection;
+export declare function getPositionWithinBox(x: number, y: number, rect: rect, pctX: number, pctY: number): GridLayoutDropPosition;

package/types/src/broadcast-channel.d.ts

@@ -0,0 +1,16 @@
+interface VuuBroadcastChannelEventMap<T> {
+    message: MessageEvent<T>;
+    messageerror: MessageEvent<T>;
+}
+export interface VuuBroadcastChannel<T> extends EventTarget {
+    readonly name: string;
+    onmessage: ((this: BroadcastChannel, evt: MessageEvent<T>) => void) | null;
+    onmessageerror: ((this: BroadcastChannel, evt: MessageEvent<T>) => void) | null;
+    close(): void;
+    postMessage<M extends T = T>(message: M): void;
+    addEventListener<K extends keyof VuuBroadcastChannelEventMap<T>>(type: K, listener: (this: BroadcastChannel, evt: VuuBroadcastChannelEventMap<T>[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof VuuBroadcastChannelEventMap<T>>(type: K, listener: (this: BroadcastChannel, evt: VuuBroadcastChannelEventMap<T>[K]) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export {};

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

@@ -0,0 +1,243 @@
+import type { DataSourceRow, DataValueDescriptor, DataValueType, DataValueTypeSimple, DateTimeDataValueDescriptor, SchemaColumn, TableSchema, TimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
+import type { VuuAggType, VuuAggregation, VuuColumnDataType, VuuDataRowDto, VuuGroupBy, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import { TableModel } from "@vuu-ui/vuu-table";
+import type { ColumnAlignment, ColumnDescriptor, ColumnLayout, ColumnTypeFormatting, ColumnTypeRendering, ColumnTypeWithValidationRules, DataRow, DataValueTypeDescriptor, DefaultColumnConfiguration, GroupColumnDescriptor, LookupRenderer, MappedValueTypeRenderer, PinLocation, RuntimeColumnDescriptor, TableCellRendererProps, TableConfig, TableHeadings, ValueListRenderer } from "@vuu-ui/vuu-table-types";
+import { type CSSProperties } from "react";
+/**
+ * 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 interface ReverseColumnMap {
+    [columnIndex: number]: string;
+}
+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 type EditOperation = "insert" | "update";
+export declare const isDataValueEditable: (dataDescriptor: Pick<DataValueDescriptor, "editable">, operation: EditOperation, defaultValue?: boolean) => boolean;
+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 isNanoTimestampColumn: ({ serverDataType, }: DataValueDescriptor) => boolean;
+export declare const isTimestampColumn: (column: ColumnDescriptor) => boolean;
+export declare const isNumericColumn: ({ serverDataType, type }: ColumnDescriptor) => boolean;
+export declare const isDateTimeDataType: (column: ColumnDescriptor) => column is DateTimeDataValueDescriptor;
+export declare const isTimeDataType: (column: ColumnDescriptor) => column is TimeDataValueDescriptor;
+export declare const isDateTimeDataValue: (column: ColumnDescriptor) => boolean;
+export declare const isTimeDataValue: (column?: ColumnDescriptor) => column is TimeDataValueDescriptor;
+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, serverDataType?: ColumnDescriptor["serverDataType"]) => 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?: readonly (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 TIMESTAMP: 8;
+    readonly IS_NEW: 9;
+    readonly count: 10;
+    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, dataRow: DataRow) => boolean;
+export declare const isJsonColumn: (column: RuntimeColumnDescriptor) => boolean;
+export declare const sortPinnedColumns: (columns: RuntimeColumnDescriptor[], selectionBookendWidth?: number) => 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, pinnedWidth, width, }: RuntimeColumnDescriptor) => CSSProperties;
+export declare const getAllCellsInColumn: (container: HTMLElement | null, colIndex: number) => HTMLDivElement[];
+export type PinState = {
+    /**
+     * The pinned 'endPin' cell
+     */
+    cell: HTMLElement;
+    /**
+     * With multiple columns pinned, left pinned columns that follow
+     * // the resized column. These will need pinOffset adjustments.
+     */
+    pinnedCells?: HTMLElement[];
+    pinnedWidth: number;
+};
+export declare const getAriaRowIndex: (rowElement: HTMLElement | null) => number;
+export declare const getAriaColIndex: (cellElement: HTMLElement | null) => number;
+export declare const getPinStateFromElement: (cell: HTMLElement) => PinState | undefined;
+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: readonly T[], column: T): T[];
+export declare function updateColumn(columns: readonly 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[], dataRow: DataRow) => string | undefined;
+export declare const getGroupValue: (columns: RuntimeColumnDescriptor[], dataRow: DataRow) => 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;
+/**
+ * Check that columnDescriptors are included in provided list of subscribec column names (unless they
+ * atr 'client side' columns).
+ */
+export declare const assertAllColumnsAreIncludedInSubscription: (columns: readonly ColumnDescriptor[], columnNames: string[]) => void;
+/**
+ * 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;
+/**
+ * Called from TableSettings.ColumnList when a column is added to subscription.
+ *
+ * @param subscribedColumns
+ * @param availableColumns
+ * @param columnName
+ * @returns
+ */
+export declare const addColumnToSubscribedColumns: (subscribedColumns: readonly ColumnDescriptor[], availableColumns: readonly SchemaColumn[], columnName: string) => ColumnDescriptor[];
+export declare function getServerDataType(column: ColumnDescriptor): VuuColumnDataType | undefined;
+export declare function getServerDataType(column: ColumnDescriptor, throwIfUndefined: true): VuuColumnDataType;
+export declare const isCalculatedColumn: (columnName?: string) => boolean;
+export declare const getCalculatedColumnDetails: (column: ColumnDescriptor | string) => Partial<CalculatedColumn>;
+export declare const setCalculatedColumnName: (column: ColumnDescriptor, name: string) => ColumnDescriptor;
+export declare const setCalculatedColumnType: (column: ColumnDescriptor, serverDataType: VuuColumnDataType) => 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: readonly C[], column: C): C[];
+export declare const applyDefaultColumnConfig: ({ columns: columnsProp, table }: TableSchema, getDefaultColumnConfig?: DefaultColumnConfiguration, includeVuuDefaultColumns?: boolean) => (SchemaColumn | {
+    aggregate?: VuuAggType;
+    align?: ColumnAlignment;
+    allowColumnHeaderMenu?: false;
+    className?: string;
+    colHeaderContentRenderer?: string;
+    colHeaderLabelRenderer?: string;
+    exportFormatter?: (value: unknown) => string;
+    flex?: number;
+    getIcon?: (row: DataRow) => string | undefined;
+    groupable?: boolean;
+    heading?: string[];
+    hidden?: boolean;
+    isSystemColumn?: boolean;
+    locked?: Exclude<PinLocation, "left"> | false;
+    maxWidth?: number;
+    minWidth?: number;
+    pin?: PinLocation | false;
+    removeable?: boolean;
+    resizeable?: boolean;
+    selected?: boolean;
+    sortable?: boolean;
+    source?: "client" | "server";
+    status?: import("@salt-ds/core").ValidationStatus;
+    width?: number;
+    editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;
+    label?: string;
+    required?: boolean;
+    type?: DataValueType;
+    editable?: import("@vuu-ui/vuu-data-types").DataEditable | undefined;
+    name: string;
+    serverDataType: VuuColumnDataType;
+})[] | readonly 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;
+export declare const columnByAriaIndex: (columns: RuntimeColumnDescriptor[], ariaColIndex: number) => RuntimeColumnDescriptor;
+export {};

package/types/src/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/src/component-registry.d.ts

@@ -0,0 +1,65 @@
+import { EditRuleValidator } from "@vuu-ui/vuu-data-types";
+import { VuuColumnDataType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnDescriptor, ColumnDescriptorCustomRenderer, ColumnTypeRendering, DataRow, HeaderCellProps, TableCellRendererProps } from "@vuu-ui/vuu-table-types";
+import { FunctionComponent as FC, HTMLAttributes } from "react";
+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 = (dataRow: DataRow) => 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;
+type CellRendererDataType = VuuColumnDataType | "json";
+export declare const getRegisteredCellRenderers: (cellRendererDataType?: CellRendererDataType) => 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, "id" | "index">> | undefined;
+export declare function getColumnHeaderLabelRenderer(column: ColumnDescriptor): FC<Omit<HeaderCellProps, "id" | "index">> | 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/src/context-definitions/DataContext.d.ts

@@ -0,0 +1,21 @@
+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 class NullDataSourceConstructor {
+    constructor(_: DataSourceConstructorProps);
+}
+export declare const DataContext: import("react").Context<DataContextProps>;

package/types/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.Element;
+export declare const useData: () => DataContextProps;

package/types/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.Element;
+export declare function useDataSource(throwIfNoDataSource: true): DataSource;
+export declare function useDataSource(throwIfNoDataSource: false | undefined): DataSource | undefined;

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

@@ -0,0 +1,9 @@
+export declare const getCookieValue: (name: string) => string | undefined;
+/**
+ * Sets a cookie value.
+ *
+ * @param {string} name - Cookie name
+ * @param {string} value - Cookie value
+ * @param {number} [days] - Optional: number of days until the cookie expires
+ */
+export declare function setCookieValue(name: string, value: string, days?: number): void;

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

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

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

@@ -0,0 +1,33 @@
+import { DataValueDescriptor } from "@vuu-ui/vuu-data-types";
+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 stringIsValidLong: (val: string) => boolean;
+export declare const stringIsValidDecimal: (val: string) => boolean;
+export declare const stringIsValidNumber: (val: string) => boolean;
+export declare const numericTypeOfStringValue: (val: string) => "NaN" | "double" | "int";
+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;
+/**
+ * Convert a value to integer.
+ * If value is a number, remove any decimals.
+ * If value is a string, parse as integer. If NaN,
+ * return defaultValue else throw.
+ * If value is integer numeric, return value.
+ *
+ * @param value
+ * @param defaultValue
+ * @returns
+ */
+export declare function asInteger(value: number | string | undefined, defaultValue?: number): number;
+export declare const dataDescriptorTypeToVuuRowDataItemType: ({ serverDataType, }: DataValueDescriptor) => "string" | "number" | "boolean";