@vuu-ui/vuu-utils 0.13.4 → 0.13.6

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

@@ -0,0 +1,69 @@
+import type { DataSourceFilter } from "@vuu-ui/vuu-data-types";
+import { AndFilter, Filter, FilterClauseOp, FilterWithPartialClause, MultiClauseFilter, MultiValueFilterClause, OrFilter, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+import { ColumnDescriptor, RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { EventEmitter } from "../event-emitter";
+import { VuuFilter } from "@vuu-ui/vuu-protocol-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 AndFilter;
+export declare const isOrFilter: (f: Partial<Filter>) => f is OrFilter;
+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<import("@vuu-ui/vuu-table-types").HeaderCellProps>;
+    HeaderCellContentRenderer?: import("react").FunctionComponent<import("@vuu-ui/vuu-table-types").HeaderCellProps>;
+    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("@vuu-ui/vuu-protocol-types").VuuAggType;
+    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("@vuu-ui/vuu-protocol-types").VuuColumnDataType;
+    type?: import("@vuu-ui/vuu-data-types").DataValueType;
+}[];
+export declare const extractFilterForColumn: (filter: Filter | undefined, columnName: string) => Filter | undefined;
+export type FilterEvents = {
+    filter: (vuuFilter: VuuFilter) => void;
+};
+export declare class FilterAggregator extends EventEmitter<FilterEvents> {
+    #private;
+    addFilter(column: ColumnDescriptor, value: string | number): void;
+    removeFilter(column: ColumnDescriptor): boolean;
+    get filter(): VuuFilter;
+}

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

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

package/types/form-utils.d.ts

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

package/types/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("@vuu-ui/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>;

package/types/getUniqueId.d.ts

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

package/types/group-utils.d.ts

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

package/types/html-utils.d.ts

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

package/types/index.d.ts

@@ -0,0 +1,67 @@
+export * from "./array-utils";
+export * from "./box-utils";
+export * from "./broadcast-channel";
+export * from "./column-utils";
+export * from "./cookie-utils";
+export * from "./component-registry";
+export * from "./DataWindow";
+export * from "./common-types";
+export * from "./css-utils";
+export * from "./data-utils";
+export * from "./datasource/BaseDataSource";
+export * from "./datasource/datasource-action-utils";
+export * from "./datasource/datasource-filter-utils";
+export * from "./datasource/datasource-utils";
+export * from "./date";
+export * from "./debug-utils";
+export * from "./filters";
+export * from "./html-utils";
+export * from "./event-emitter";
+export * from "./feature-utils";
+export * from "./form-utils";
+export * from "./formatting-utils";
+export * from "./getUniqueId";
+export * from "./group-utils";
+export * from "./input-utils";
+export * from "./invariant";
+export * from "./itemToString";
+export * from "./json-types";
+export * from "./json-utils";
+export * from "./keyboard-utils";
+export * from "./keyset";
+export * from "./layout-types";
+export * from "./list-utils";
+export * from "./local-storage-utils";
+export * from "./logging-utils";
+export * from "./menu-utils";
+export * from "./module-utils";
+export * from "./moving-window";
+export * from "./nanoid";
+export * from "./react-utils";
+export * from "./round-decimal";
+export * from "./perf-utils";
+export * from "./promise-utils";
+export * from "./protocol-message-utils";
+export * from "./range-utils";
+export * from "./row-utils";
+export * from "./selection-utils";
+export * from "./shell-layout-types";
+export * from "./sort-utils";
+export * from "./table-schema-utils";
+export * from "./text-utils";
+export * from "./typeahead-utils";
+export * from "./tree-types";
+export * from "./tree-utils";
+export * from "./ThemeProvider";
+export * from "./ts-utils";
+export * from "./url-utils";
+export * from "./useId";
+export * from "./useStateRef";
+export * from "./user-types";
+export * from "./useLayoutEffectSkipFirst";
+/** Context declarations hosted in utils to minimize intra package dependencies */
+export * from "./ShellContext";
+export * from "./context-definitions/DataContext";
+export * from "./context-definitions/DataProvider";
+export { DataSourceProvider, useDataSource, } from "./context-definitions/DataSourceProvider";
+export * from "./context-definitions/WorkspaceContext";

package/types/input-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isCharacterKey: (key: string) => boolean;
+export declare const isQuoteKey: (evt: KeyboardEvent) => boolean;

package/types/invariant.d.ts

@@ -0,0 +1 @@
+export declare function invariant(condition: boolean, message: string): void;

package/types/itemToString.d.ts

@@ -0,0 +1,2 @@
+export type ItemToStringFunction = (item: any) => string;
+export declare function itemToString(item: unknown): string;

package/types/json-types.d.ts

@@ -0,0 +1,52 @@
+import { NamedFilter } from "@vuu-ui/vuu-filter-types";
+import { CSSProperties, ReactElement } from "react";
+export type ValueOf<T> = T[keyof T];
+export interface ApplicationSettings {
+    leftNav?: {
+        activeTabIndex: number;
+        expanded: boolean;
+    };
+    /**
+     * filters are keyed by MODULE:tablename
+     */
+    filters?: {
+        [key: string]: NamedFilter[];
+    };
+}
+export type ApplicationSetting = ValueOf<ApplicationSettings>;
+export type Settings = Record<string, string | number | boolean>;
+export interface ApplicationJSON {
+    workspaceJSON: LayoutJSON | LayoutJSON[];
+    settings?: ApplicationSettings;
+    userSettings?: Settings;
+}
+export interface WithActive {
+    active?: number;
+}
+export interface WithProps {
+    props?: {
+        [key: string]: unknown;
+    };
+}
+export interface LayoutRoot extends WithProps {
+    active?: number;
+    children?: ReactElement[];
+    type: string;
+}
+export interface WithType {
+    props?: unknown;
+    title?: string;
+    type: string;
+}
+export type LayoutModel = LayoutRoot | ReactElement | WithType;
+export interface LayoutJSON<T extends object = {
+    [key: string]: any;
+}> extends WithType {
+    active?: number;
+    children?: LayoutJSON[];
+    id?: string;
+    props?: T;
+    state?: unknown;
+    type: string;
+    style?: CSSProperties;
+}

package/types/json-utils.d.ts

@@ -0,0 +1,6 @@
+import { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export type JsonData = {
+    [key: string]: unknown;
+} | JsonData[];
+export declare const jsonToDataSourceRows: (json: JsonData) => [ColumnDescriptor[], DataSourceRow[]];

package/types/keyboard-utils.d.ts

@@ -0,0 +1,15 @@
+export declare const ArrowUp = "ArrowUp";
+export declare const ArrowDown = "ArrowDown";
+export declare const ArrowLeft = "ArrowLeft";
+export declare const ArrowRight = "ArrowRight";
+export declare const Enter = "Enter";
+export declare const Escape = "Escape";
+export declare const Home = "Home";
+export declare const End = "End";
+export declare const PageUp = "PageUp";
+export declare const PageDown = "PageDown";
+export declare const Space = " ";
+export declare const Tab = "Tab";
+export type ArrowKey = "ArrowUp" | "ArrowDown" | "ArrowLeft" | "ArrowRight";
+export type PageKey = "Home" | "End" | "PageUp" | "PageDown";
+export declare const isArrowKey: (key: string) => key is ArrowKey;

package/types/keyset.d.ts

@@ -0,0 +1,12 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+export declare class KeySet {
+    private keys;
+    private nextKeyValue;
+    private range;
+    constructor(range: VuuRange);
+    next(free?: number[]): number;
+    private init;
+    reset(range: VuuRange): boolean;
+    keyFor(rowIndex: number): number;
+    toDebugString(): string;
+}

package/types/layout-types.d.ts

@@ -0,0 +1,22 @@
+import { LayoutJSON } from "@vuu-ui/vuu-utils";
+export interface WithId {
+    id: string;
+}
+export interface LayoutMetadata extends WithId {
+    name: string;
+    group: string;
+    screenshot: string;
+    user: string;
+    created: string;
+}
+export interface SystemLayoutMetadata extends LayoutMetadata {
+    layoutJSON: LayoutJSON;
+}
+export type LayoutMetadataDto = Omit<LayoutMetadata, "id" | "created">;
+export interface Layout extends WithId {
+    json: LayoutJSON;
+}
+export type ApplicationLayout = {
+    username: string;
+    definition: LayoutJSON;
+};

package/types/list-utils.d.ts

@@ -0,0 +1,2 @@
+import type { ListOption } from "@vuu-ui/vuu-table-types";
+export declare const getSelectedOption: (values: ListOption[], selectedValue: string | number | undefined) => ListOption | undefined;

package/types/local-storage-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const getLocalEntity: <T>(url: string) => T | undefined;
+export declare const getAllLocalEntity: <T>(url: string) => T[];
+export declare const saveLocalEntity: <T>(url: string, data: T) => T | undefined;

package/types/logging-utils.d.ts

@@ -0,0 +1,45 @@
+declare global {
+    const loggingSettings: loggingSettings;
+}
+export interface LogFn {
+    (message?: unknown, ...optionalParams: unknown[]): void;
+}
+export interface AssertLogFn {
+    (condition: boolean, message?: unknown, errorMessaage?: unknown): void;
+}
+export interface TableLogFn {
+    (properties?: object): void;
+}
+type loggingSettings = {
+    loggingLevel: LogLevel;
+};
+export interface Logger {
+    warn: LogFn;
+    error: LogFn;
+    debug: LogFn;
+    info: LogFn;
+}
+export type LogLevel = keyof Logger;
+export type BuildEnv = "production" | "development";
+export declare const logger: (category: string) => {
+    errorEnabled: boolean;
+    error: (message: string) => void;
+    debugEnabled?: undefined;
+    infoEnabled?: undefined;
+    warnEnabled?: undefined;
+    info?: undefined;
+    warn?: undefined;
+    debug?: undefined;
+} | {
+    debugEnabled: boolean;
+    infoEnabled: boolean;
+    warnEnabled: boolean;
+    errorEnabled: boolean;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+};
+export declare const getLoggingConfigForWorker: () => string;
+export declare const logUnhandledMessage: (message: never, context?: string) => void;
+export {};

package/types/menu-utils.d.ts

@@ -0,0 +1,6 @@
+import { MenuRpcResponse, OpenDialogActionWithSchema } from "@vuu-ui/vuu-data-types";
+import { ShowNotificationAction, VuuRpcResponse } from "@vuu-ui/vuu-protocol-types";
+import { ContextMenuGroupItemDescriptor, ContextMenuItemDescriptor } from "@vuu-ui/vuu-context-menu";
+export declare const isGroupMenuItemDescriptor: (menuItem?: ContextMenuItemDescriptor) => menuItem is ContextMenuGroupItemDescriptor;
+export declare const isOpenBulkEditResponse: (rpcResponse: Partial<VuuRpcResponse>) => rpcResponse is MenuRpcResponse<OpenDialogActionWithSchema>;
+export declare const hasShowNotificationAction: (res: Partial<VuuRpcResponse>) => res is MenuRpcResponse<ShowNotificationAction>;

package/types/module-utils.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from "react";
+export type ReactComponent = {
+    (props?: any): ReactElement;
+};
+export declare const isModule: (entity: Module | ReactComponent) => entity is Module;
+export interface Module<T = ReactComponent> {
+    [key: string]: Module<T> | T;
+}

package/types/moving-window.d.ts

@@ -0,0 +1,18 @@
+import { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+import { WindowRange } from "./range-utils";
+export declare class MovingWindow {
+    #private;
+    data: DataSourceRow[];
+    rowCount: number;
+    constructor({ from, to }: VuuRange);
+    setRowCount: (rowCount: number) => void;
+    add(data: DataSourceRow): void;
+    getAtIndex(index: number): DataSourceRow | undefined;
+    isWithinRange(index: number): boolean;
+    setRange({ from, to }: VuuRange): void;
+    getSelectedRows(): DataSourceRow[];
+    get range(): WindowRange;
+    slice(): DataSourceRow[];
+    get hasAllRowsWithinRange(): boolean;
+}

package/types/nanoid/index.d.ts

@@ -0,0 +1 @@
+export declare const uuid: (size?: number) => string;

package/types/perf-utils.d.ts

@@ -0,0 +1,5 @@
+type VoidFunction = (...args: any) => void;
+export type PerfFunction<T extends VoidFunction> = (...args: Parameters<T>) => void;
+export declare function debounce<T extends VoidFunction>(callback: T, timeInterval: number): PerfFunction<T>;
+export declare function throttle<T extends VoidFunction>(callback: T, limit: number): PerfFunction<T>;
+export {};

package/types/promise-utils.d.ts

@@ -0,0 +1,8 @@
+export declare class DeferredPromise<T = unknown> {
+    #private;
+    constructor();
+    get promise(): Promise<T>;
+    get isResolved(): boolean;
+    resolve(value: T): void;
+    get reject(): (err: unknown) => void;
+}

package/types/protocol-message-utils.d.ts

@@ -0,0 +1,28 @@
+import type { MenuRpcAction, MenuRpcResponse, OpenDialogActionWithSchema, RpcResponse, TableSchema, VuuUiMessageInRequestResponse } from "@vuu-ui/vuu-data-types";
+import { VuuRpcMenuRequest, OpenDialogAction, VuuRpcEditCellRequest, VuuRowDataItemType, VuuRpcRequest, VuuRpcEditAddRowRequest, VuuDataRowDto, VuuRpcEditDeleteRowRequest, VuuRpcViewportRequest, VuuRpcResponse, VuuRpcMenuSuccess, VuuRpcViewportResponse } from "@vuu-ui/vuu-protocol-types";
+export declare const isVuuMenuRpcRequest: (message: VuuRpcRequest | Omit<VuuRpcRequest, "vpId">) => message is VuuRpcMenuRequest;
+export declare const isRequestResponse: (message: object) => message is VuuUiMessageInRequestResponse;
+export declare const isOpenSessionTableDialogMessage: (rpcResponse: RpcResponse) => rpcResponse is MenuRpcResponse<OpenDialogActionWithSchema>;
+export declare const isOpenDialogAction: (action?: MenuRpcAction) => action is OpenDialogAction;
+export declare function isViewportRpcRequest(request: VuuRpcRequest): request is VuuRpcViewportRequest;
+export declare function isViewportRpcRequest(request: Omit<VuuRpcRequest, "vpId">): request is Omit<VuuRpcViewportRequest, "vpId">;
+export declare function isEditCellRequest(request: VuuRpcRequest): request is VuuRpcEditCellRequest;
+export declare function isEditCellRequest(request: Omit<VuuRpcRequest, "vpId">): request is Omit<VuuRpcEditCellRequest, "vpId">;
+export declare function vuuEditCellRequest(rowKey: string, field: string, value: VuuRowDataItemType, vpId: string): VuuRpcEditCellRequest;
+export declare function vuuEditCellRequest(rowKey: string, field: string, value: VuuRowDataItemType): Omit<VuuRpcEditCellRequest, "vpId">;
+export declare function viewportRpcRequest(rpcName: string, vpId: string): VuuRpcViewportRequest;
+export declare function viewportRpcRequest(rpcName: string): Omit<VuuRpcViewportRequest, "vpId">;
+export declare function vuuAddRowRequest(rowKey: string, data: VuuDataRowDto, vpId: string): VuuRpcEditAddRowRequest;
+export declare function vuuAddRowRequest(rowKey: string, data: VuuDataRowDto): Omit<VuuRpcEditAddRowRequest, "vpId">;
+export declare function vuuDeleteRowRequest(rowKey: string, vpId: string): VuuRpcEditDeleteRowRequest;
+export declare function vuuDeleteRowRequest(rowKey: string): Omit<VuuRpcEditDeleteRowRequest, "vpId">;
+export declare const isSessionTable: (table?: unknown) => boolean;
+export declare function isActionMessage(rpcResponse: VuuRpcResponse): rpcResponse is VuuRpcViewportResponse | VuuRpcMenuSuccess;
+export declare function isActionMessage(rpcResponse: Omit<VuuRpcResponse, "vpId">): rpcResponse is Omit<VuuRpcViewportResponse, "vpId"> | Omit<VuuRpcMenuSuccess, "vpId">;
+export declare function isSessionTableActionMessage(rpcResponse: VuuRpcResponse): rpcResponse is VuuRpcMenuSuccess<OpenDialogAction & {
+    tableSchema: TableSchema;
+}>;
+export declare function isSessionTableActionMessage(rpcResponse: Omit<VuuRpcResponse, "vpId">): rpcResponse is Omit<VuuRpcMenuSuccess<OpenDialogAction & {
+    tableSchema: TableSchema;
+}>, "vpId">;
+export declare const isRpcSuccess: (response: VuuRpcResponse | Omit<VuuRpcResponse, "vpId">) => response is VuuRpcViewportResponse;

package/types/range-utils.d.ts

@@ -0,0 +1,31 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+interface FromToRange {
+    from: number;
+    to: number;
+}
+export interface Range extends VuuRange {
+    equals: (vuuRange: VuuRange) => boolean;
+    firstRowInViewport: number;
+    lastRowInViewport: number;
+    renderBufferSize?: number;
+    reset: Range;
+    rowCount?: number;
+}
+export interface RangeOptions {
+    renderBufferSize?: number;
+    rowCount?: number;
+}
+export declare const Range: (from: number, to: number, rangeOptions?: RangeOptions) => Range;
+export declare const NULL_RANGE: Range;
+export declare function getFullRange({ from, to }: VuuRange, bufferSize?: number, totalRowCount?: number): FromToRange;
+export declare const withinRange: (value: number, { from, to }: VuuRange) => boolean;
+export declare const rangeNewItems: ({ from: from1, to: to1 }: VuuRange, newRange: VuuRange) => VuuRange;
+export declare class WindowRange {
+    from: number;
+    to: number;
+    constructor(from: number, to: number);
+    isWithin(index: number): boolean;
+    overlap(from: number, to: number): [number, number];
+    copy(): WindowRange;
+}
+export {};

package/types/react-utils.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement, ReactNode, SetStateAction } from "react";
+export declare const asReactElements: (children: ReactNode) => ReactElement[];
+export declare const useIsMounted: (id?: string) => import("react").RefObject<boolean>;
+export declare const isSimpleStateValue: <T>(arg: SetStateAction<T>) => arg is T;

package/types/round-decimal.d.ts

@@ -0,0 +1 @@
+export declare function roundDecimal(value?: number, align?: string, decimals?: number, zeroPad?: boolean, alignOnDecimals?: boolean): string;

package/types/row-utils.d.ts

@@ -0,0 +1,24 @@
+import type { DataSourceRow, DataSourceRowObject } from "@vuu-ui/vuu-data-types";
+import type { MutableRefObject } from "react";
+import { ColumnMap } from "./column-utils";
+export type RowOffsetFunc = (row: DataSourceRow, pctScrollTop?: number) => number;
+export type RowAtPositionFunc = (position: number) => number;
+/**
+ * RowOffset function, RowAtPosition function, isVirtualScroll
+ */
+export type RowPositioning = [RowOffsetFunc, RowAtPositionFunc, boolean];
+export declare const actualRowPositioning: (rowHeight: number) => RowPositioning;
+/**
+ * return functions for determining a) the pixel offset to apply to a row, given the
+ * row index and b) the index of the row at a given scroll offset. This implementation
+ * is used when we are forced to 'virtualise' scrolling - because the number of rows
+ * is high enough that we cannot create a large enough HTML content container.
+ *
+ * @param rowHeight
+ * @param virtualisedExtent
+ * @param pctScrollTop
+ * @returns
+ */
+export declare const virtualRowPositioning: (rowHeight: number, virtualisedExtent: number, pctScrollTop: MutableRefObject<number>) => RowPositioning;
+export type RowToObjectMapper = (row: DataSourceRow, columnMap: ColumnMap) => DataSourceRowObject;
+export declare const asDataSourceRowObject: RowToObjectMapper;

package/types/selection-utils.d.ts

@@ -0,0 +1,29 @@
+import { DataSourceRow, Selection, SelectionItem } from "@vuu-ui/vuu-data-types";
+import { TableSelectionModel } from "@vuu-ui/vuu-table-types";
+export declare const RowSelected: {
+    False: number;
+    True: number;
+    First: number;
+    Last: number;
+};
+export declare const isRowSelected: (row: DataSourceRow) => boolean;
+export declare const isRowSelectedLast: (row?: DataSourceRow) => boolean;
+export declare const deselectItem: (selectionModel: TableSelectionModel, selected: Selection, itemIndex: number, rangeSelect: boolean, keepExistingSelection?: boolean) => Selection;
+export declare const selectItem: (selectionModel: TableSelectionModel, selected: Selection, itemIndex: number, rangeSelect: boolean, keepExistingSelection?: boolean, activeItemIndex?: number) => Selection;
+/**
+ *  Determine the value for selected. We use a bitmap to represent a number of selection states
+ * a row might exhibit. selected/not-selected is the fundamental value. We also identify first
+ * row of a selected block, last row of a selected block;
+ */
+export declare const getSelectionStatus: (selected: Selection, itemIndex: number) => number;
+export declare const isSelected: (selected: Selection, itemIndex: number) => boolean;
+/**
+ * Vuu server expects a full list if indexes of selected rows. Client represents selection in a more
+ * efficient structure. This converts client structure to full server format.
+ */
+export declare const expandSelection: (selected: Selection) => number[];
+export type SelectionDiff = {
+    added: SelectionItem[];
+    removed: SelectionItem[];
+};
+export declare const selectionCount: (selected?: Selection) => number;

package/types/shell-layout-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The Vuu Shell creates the outermost application layout. This includes some
+ * 'special' identifiers that can be targetted by layout commands to effect or
+ * react to layout changes.
+ */
+export declare const VuuShellLocation: {
+    readonly ContextPanel: "context-panel";
+    readonly MultiWorkspaceContainer: "vuu-multi-workspace-container";
+    readonly SidePanel: "vuu-side-panel";
+    readonly SideToolbar: "vuu-side-toolbar";
+    readonly Workspace: "vuu-workspace";
+    readonly WorkspaceContainer: "vuu-workspace-container";
+};
+export type VuuShellLocation = (typeof VuuShellLocation)[keyof typeof VuuShellLocation];

package/types/sort-utils.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { VuuSort, VuuSortType } from "@vuu-ui/vuu-protocol-types";
+export declare const toggleOrApplySort: ({ sortDefs }: VuuSort, { name: column }: ColumnDescriptor, extendSort?: boolean, sortType?: VuuSortType) => VuuSort;
+export declare const setSortColumn: ({ sortDefs }: VuuSort, column: ColumnDescriptor, sortType?: "A" | "D") => VuuSort;
+export declare const addSortColumn: ({ sortDefs }: VuuSort, column: ColumnDescriptor, sortType?: "A" | "D") => VuuSort;
+export type ColumnSortStatus = "no-sort" | "sort-other-column" | "single-sort-asc" | "single-sort-desc" | "multi-sort-includes-column-asc" | "multi-sort-includes-column-desc";
+/**
+ * Given a VuuSort definition and a column, determine whether the given column
+ * is included in the sort and if so, in what position/direction.
+ */
+export declare const getSortStatus: (columnName: string, vuuSort?: VuuSort) => ColumnSortStatus;

package/types/table-schema-utils.d.ts

@@ -0,0 +1,3 @@
+import { TableSchemaTable } from "@vuu-ui/vuu-data-types";
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export declare const getVuuTable: (schemaTable: TableSchemaTable) => VuuTable;

package/types/text-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const lastWord: (text: string) => string;
+export declare const wordify: (text: string) => string;