@vuu-ui/vuu-utils 3.3.9 → 3.3.11

package/types/src/index.d.ts

@@ -0,0 +1,76 @@
+import { RestrictToHorizontalAxis } from "@dnd-kit/abstract/modifiers";
+import { KeyboardSensor, PointerSensor } from "@dnd-kit/dom";
+import { DragDropProvider, DragOverlay, useInstance } from "@dnd-kit/react";
+import { useSortable } from "@dnd-kit/react/sortable";
+export * from "./array-utils";
+export * from "./box-utils";
+export * from "./broadcast-channel";
+export { Clock } from "./Clock";
+export * from "./column-utils";
+export * from "./common-types";
+export * from "./component-registry";
+export * from "./cookie-utils";
+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 { isInlineEditingSession } from "./edit-utils";
+export { StaleUpdateError } from "./errors";
+export * from "./event-emitter";
+export * from "./feature-utils";
+export * from "./filters";
+export * from "./form-utils";
+export * from "./formatting-utils";
+export * from "./getUniqueId";
+export * from "./group-utils";
+export * from "./html-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 "./module-utils";
+export * from "./nanoid";
+export * from "./perf-utils";
+export * from "./promise-utils";
+export * from "./protocol-message-utils";
+export * from "./range-utils";
+export * from "./react-utils";
+export * from "./round-decimal";
+export * from "./row-utils";
+export * from "./ScaledDecimal";
+export * from "./selection-utils";
+export * from "./shell-layout-types";
+export * from "./sort-utils";
+export * from "./table-schema-utils";
+export * from "./text-utils";
+export * from "./ThemeProvider";
+export * from "./tree-types";
+export * from "./tree-utils";
+export * from "./ts-utils";
+export * from "./typeahead-utils";
+export * from "./url-utils";
+export * from "./useId";
+export * from "./useLayoutEffectSkipFirst";
+export * from "./user-types";
+export { useResizeObserver, WidthHeight, WidthOnly, type measurements, type ResizeHandler, } from "./useResizeObserver";
+export * from "./useStateRef";
+export { DragDropProvider, DragOverlay, KeyboardSensor, PointerSensor, RestrictToHorizontalAxis, useInstance, useSortable, };
+/** Context declarations hosted in utils to minimize intra package dependencies */
+export { DataContext } from "./context-definitions/DataContext";
+export * from "./context-definitions/DataProvider";
+export { DataSourceProvider, useDataSource, } from "./context-definitions/DataSourceProvider";
+export * from "./context-definitions/WorkspaceContext";
+export { PageVisibilityObserver } from "./PageVisibilityObserver";
+export * from "./ShellContext";
+export { ThemeLoadChecker } from "./theme-utils";

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

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

package/types/src/invariant.d.ts

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

package/types/src/itemToString.d.ts

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

package/types/src/json-types.d.ts

@@ -0,0 +1,52 @@
+import { NamedFilter } from "@vuu-ui/vuu-filter-types";
+import { CSSProperties, ReactElement } from "react";
+import { ValueOf } from "./ts-utils";
+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/src/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/src/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/src/keyset.d.ts

@@ -0,0 +1,16 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+export interface IKeySet {
+    keyFor: (rowIndex: number) => number;
+    reset: (range: VuuRange) => void;
+}
+export declare class KeySet implements IKeySet {
+    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/src/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/src/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/src/local-storage-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const getLocalEntity: <T>(key: string, deleteOnRead?: boolean) => T | undefined;
+export declare const clearLocalEntity: (key: string) => boolean;
+export declare const getAllLocalEntity: <T>(url: string) => T[];
+export declare const saveLocalEntity: <T>(key: string, data: T) => T | undefined;

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

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

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

@@ -0,0 +1,43 @@
+import type { MenuRpcAction, MenuRpcResponse, OpenDialogActionWithSchema, RpcResponse, TableSchema, VuuUiMessageInRequestResponse } from "@vuu-ui/vuu-data-types";
+import { VuuRpcMenuRequest, OpenDialogAction, VuuRpcRequest, VuuRpcResponse, VuuRpcMenuSuccess, VuuViewportRpcTypeaheadRequest, VuuRpcServiceRequest, ViewportRpcContext, OpenComponentInDialogAction, VuuLoginSuccessResponse, SelectRequest, SelectResponse, SelectSuccessWithRowCount, VuuViewportCreateSuccessResponse, VuuViewportCreateResponse, InvalidTokenReason, InvalidSessionReason, LoginErrorMessage, RpcResult, RpcResultSuccess, RpcResultError, VuuColumnDataType, VuuNumericType, AddRowRpcServiceRequest, EndEditSessionRpcServiceRequest, EditCellRpcServiceRequest, BeginEditSessionRpcServiceRequest, UndoRowChangeRpcServiceRequest, DeleteSelectedRowsRpcServiceRequest, CreateSessionTableRpcServiceRequest, ServerToClientError } from "@vuu-ui/vuu-protocol-types";
+export declare const INVALID_SESSION: InvalidSessionReason;
+export declare const SESSION_LIMIT_EXCEEDED: InvalidSessionReason;
+export declare const INVALID_TOKEN: InvalidTokenReason;
+export declare const TOKEN_EXPIRED: InvalidTokenReason;
+export declare const isErrorMessage: (message: unknown) => message is ServerToClientError;
+export declare const isLoginErrorMessage: (message: unknown) => message is LoginErrorMessage;
+export declare const isSelectRequest: (message: object) => message is SelectRequest;
+export declare const isSelectSuccessWithRowCount: (response: SelectResponse | SelectSuccessWithRowCount) => response is SelectSuccessWithRowCount;
+export declare const isRpcServiceRequest: (message: {
+    type: string;
+}) => message is VuuRpcServiceRequest | Omit<VuuRpcServiceRequest, "context">;
+export declare const hasViewPortContext: (message: VuuRpcServiceRequest) => message is VuuRpcServiceRequest<ViewportRpcContext>;
+export declare const isVuuMenuRpcRequest: (message: VuuRpcRequest | Omit<VuuRpcRequest, "vpId">) => message is VuuRpcMenuRequest;
+export declare const isLoginResponse: (message: unknown) => message is VuuLoginSuccessResponse;
+export declare const isRpcSuccess: (rpcResult?: RpcResult) => rpcResult is RpcResultSuccess;
+export declare const isRpcError: (rpcResult?: RpcResult) => rpcResult is RpcResultError;
+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 const isTypeaheadRequest: (request: Omit<VuuRpcRequest, "vpId">) => request is Omit<VuuViewportRpcTypeaheadRequest, "vpId">;
+export declare const isCreateVpSuccess: (response: VuuViewportCreateResponse) => response is VuuViewportCreateSuccessResponse;
+export declare const isSessionTable: (table?: unknown) => boolean;
+export declare function isActionMessage(rpcResponse: VuuRpcResponse): rpcResponse is VuuRpcMenuSuccess;
+export declare function isActionMessage(rpcResponse: Omit<VuuRpcResponse, "vpId">): rpcResponse is 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 function isCustomComponentActionMessage(rpcResponse: VuuRpcResponse | Omit<VuuRpcResponse, "vpId">): rpcResponse is VuuRpcMenuSuccess<OpenComponentInDialogAction & {
+    tableSchema: TableSchema;
+}>;
+export declare function isNumericType(dataType?: VuuColumnDataType): dataType is VuuNumericType;
+export declare const isAddRowRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is AddRowRpcServiceRequest;
+export declare const isEditCellRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is EditCellRpcServiceRequest;
+export declare const isBeginEditSessionRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is BeginEditSessionRpcServiceRequest;
+export declare const isEndEditSessionRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is EndEditSessionRpcServiceRequest;
+export declare const isUndoRowChangeRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is UndoRowChangeRpcServiceRequest;
+export declare const isDeleteSelectedRowsRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is DeleteSelectedRowsRpcServiceRequest;
+export declare const isCreateSessionTableRpcRequest: (rpcRequest: VuuRpcServiceRequest) => rpcRequest is CreateSessionTableRpcServiceRequest;

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

@@ -0,0 +1,29 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+interface FromToRange {
+    from: number;
+    to: number;
+}
+export interface Range extends VuuRange {
+    equals: (vuuRange: VuuRange) => boolean;
+    reset: Range;
+    withBuffer: VuuRange;
+}
+export interface RangeOptions {
+    renderBufferSize?: number;
+    rowCount?: number;
+}
+export declare const Range: (from: number, to: number, renderBufferSize?: number) => Range;
+export declare const NULL_RANGE: Range;
+export declare function getFullRange({ from, to }: VuuRange, bufferSize?: number, maxRangeEnd?: 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 declare const constrainRange: (range: VuuRange, maxRangeEnd: number, maxRangeWidth?: number) => VuuRange;
+export {};

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

@@ -0,0 +1,15 @@
+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;
+/**
+ * From an example by stack overflow user Maxim G
+ */
+export declare const createSyntheticEvent: <T extends Element, E extends Event>(event: E) => React.SyntheticEvent<T, E>;
+/**
+ * Store a value in a RefObject and update that ref whenever the value changes.
+ * Use to maintain a stable reference to a changing value that we need to use
+ * within a hook, but when that hook does not need to be triggered just because
+ * this value changes.
+ */
+export declare const useStableReference: <T>(value: T) => import("react").RefObject<T>;

package/types/src/round-decimal.d.ts

@@ -0,0 +1,4 @@
+import { RoundingRule } from "@vuu-ui/vuu-table-types";
+export declare const exceedsMaxSafeInteger: (value: string) => boolean;
+export declare function roundDecimal(value?: number, align?: string, decimals?: number, zeroPad?: boolean, alignOnDecimals?: boolean, useLocaleString?: boolean, roundingRule?: RoundingRule): string;
+export declare function roundScaledDecimal(value: string, align?: string, decimals?: number, zeroPad?: boolean, alignOnDecimals?: boolean, useLocaleString?: boolean, roundingRule?: RoundingRule): string;

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

@@ -0,0 +1,28 @@
+import type { DataSourceRow, DataSourceRowObject } from "@vuu-ui/vuu-data-types";
+import { ColumnMap } from "./column-utils";
+import { IKeySet } from "./keyset";
+import { VuuRow } from "@vuu-ui/vuu-protocol-types";
+import { RefObject } from "react";
+import { DataRow } from "@vuu-ui/vuu-table-types";
+export type RowOffsetFunc = (dataRow: DataRow, 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: RefObject<number>) => RowPositioning;
+export type RowToObjectMapper = (row: DataSourceRow, columnMap: ColumnMap) => DataSourceRowObject;
+export declare const asDataSourceRowObject: RowToObjectMapper;
+export declare const vuuRowToDataSourceRow: ({ rowIndex, rowKey, sel: isSelected, ts, data }: VuuRow, keys: IKeySet) => DataSourceRow;

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

@@ -0,0 +1,9 @@
+import { DataRow, TableSelectionModel } from "@vuu-ui/vuu-table-types";
+import { SelectRequest } from "@vuu-ui/vuu-protocol-types";
+export declare const deselectItem: (selectionModel: TableSelectionModel, rowKey: string, rangeSelect: boolean, preserveExistingSelection?: boolean) => Omit<SelectRequest, "vpId"> | undefined;
+export declare const selectItem: (selectionModel: TableSelectionModel, rowKey: string, rangeSelect: boolean, preserveExistingSelection?: boolean, activeRowKey?: string) => Omit<SelectRequest, "vpId"> | undefined;
+/**
+ * Split a row range into sub-ranges that exclude non-selectable rows.
+ * Returns one SELECT_ROW_RANGE per consecutive run of selectable rows.
+ */
+export declare const splitSelectableRanges: (rows: DataRow[], isRowSelectable: (row: DataRow) => boolean, preserveExistingSelection: boolean) => Omit<SelectRequest, "vpId">[];

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

@@ -0,0 +1,15 @@
+import { ValueOf } from "./ts-utils";
+/**
+ * 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 = ValueOf<typeof VuuShellLocation>;

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

@@ -0,0 +1,5 @@
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import type { SchemaColumn, TableSchemaTable } from "@vuu-ui/vuu-data-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export declare const toSchemaColumn: ({ editable, name, serverDataType, }: ColumnDescriptor) => SchemaColumn;
+export declare const getVuuTable: (schemaTable: TableSchemaTable) => VuuTable;

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

@@ -0,0 +1,10 @@
+export type SingularPluralForm = {
+    singular: string;
+    plural: string;
+};
+export type ItemTypeName = string | SingularPluralForm;
+export declare const lastWord: (text: string) => string;
+export declare const capitalize: (text: string) => string;
+export declare const singularForm: (typeName: ItemTypeName) => string;
+export declare const pluralForm: (typeName: ItemTypeName) => string;
+export declare const wordify: (text: string) => string;

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

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+/**
+ * Checks that a theme is loaded by making sure a known css variable
+ * returns a value. Not normally needed except for cases where a theme
+ * is loaded dynamically on startup and there may be components that
+ * may fail if theme is not in place (eg component that rely on taking dom
+ * measurements).
+ * Used by Showcase.
+ */
+export declare const ThemeLoadChecker: ({ children, cssToken, theme, }: {
+    children: ReactNode;
+    cssToken?: string;
+    theme: string;
+}) => ReactNode;

package/types/src/tree-types.d.ts

@@ -0,0 +1,9 @@
+export interface TreeSourceNode<T = unknown> {
+    nodeData?: T;
+    id: string;
+    icon?: string;
+    header?: boolean;
+    label: string;
+    childNodes?: TreeSourceNode<T>[];
+    tags?: string[];
+}

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

@@ -0,0 +1,9 @@
+import { TreeSourceNode } from "./tree-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import { IconProvider } from "@vuu-ui/vuu-data-local/src/tree-data-source/IconProvider";
+export declare const treeToDataSourceRows: (treeSourceNodes: TreeSourceNode[], iconProvider?: IconProvider) => [ColumnDescriptor[], DataSourceRow[]];
+export declare const lastPathSegment: (path: string, separator?: string) => string;
+export declare const dropLastPathSegment: (path: string, separator?: string) => string;
+export declare const getParentRow: (rows: DataSourceRow[], row: DataSourceRow) => DataSourceRow | undefined;
+export declare const missingAncestor: (row: DataSourceRow, previousRow?: DataSourceRow) => boolean;

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

@@ -0,0 +1,20 @@
+import { JSXElementConstructor, ReactElement } from "react";
+import { LayoutJSON } from "./json-types";
+export declare function isNotNullOrUndefined<T>(value: T | undefined | null): value is NonNullable<T>;
+export declare const isObject: (o: unknown) => o is object;
+export type OptionalProperty<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type ValueOf<T> = T[keyof T];
+/**
+ * test whether a given react element implements a custom toJSON
+ * serialisation (static) method.
+ */
+type JsonEnabledJSXElementConstructor<P> = JSXElementConstructor<P> & {
+    toJSON: (el: ReactElement) => LayoutJSON<any>;
+};
+interface ReactElementWithJSON<P = any, T extends JsonEnabledJSXElementConstructor<any> = JsonEnabledJSXElementConstructor<any>> {
+    type: T;
+    props: P;
+    key: string | null;
+}
+export declare const elementImplementsJSONSerialization: (element: ReactElement) => element is ReactElementWithJSON;
+export {};

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

@@ -0,0 +1 @@
+export declare const NO_DATA_MATCH: string[];

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

@@ -0,0 +1,3 @@
+export declare function getUrlParameter(paramName: string): string | undefined;
+export declare function getUrlParameter(paramName: string, defaultValue: string): string;
+export declare const hasUrlParameter: (paramName: string) => boolean;

package/types/src/useId.d.ts

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

package/types/src/useLayoutEffectSkipFirst.d.ts

@@ -0,0 +1,2 @@
+import { DependencyList, EffectCallback } from "react";
+export declare const useLayoutEffectSkipFirst: (func: EffectCallback, deps: DependencyList) => void;

package/types/src/useResizeObserver.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from "react";
+export declare const WidthHeight: string[];
+export declare const WidthOnly: string[];
+export type measurements<T = string | number> = {
+    height?: T;
+    clientHeight?: number;
+    clientWidth?: number;
+    contentHeight?: number;
+    contentWidth?: number;
+    scrollHeight?: number;
+    scrollWidth?: number;
+    width?: T;
+};
+export type ResizeHandler = (measurements: measurements<number>) => void;
+export declare function useResizeObserver(ref: RefObject<Element | HTMLElement | null>, dimensions: readonly string[], onResize: ResizeHandler, reportInitialSize?: boolean): void;

package/types/src/useStateRef.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, RefObject, SetStateAction } from "react";
+export declare const useStateRef: <T = string>(initialValue: T) => [RefObject<T>, Dispatch<SetStateAction<T>>];

package/types/src/user-types.d.ts

@@ -0,0 +1,3 @@
+export type VuuUser = {
+    username: string;
+};