@vuu-ui/vuu-utils 0.9.2 → 0.10.0

package/types/column-utils.d.ts

@@ -1,7 +1,7 @@
 import type { DataSourceRow, DataValueType, DataValueTypeSimple, DateTimeDataValueDescriptor, SchemaColumn, TableSchema } from "@vuu-ui/vuu-data-types";
 import type { VuuAggType, VuuAggregation, VuuColumnDataType, VuuDataRow, VuuGroupBy, VuuRowRecord, VuuSort } from "@vuu-ui/vuu-protocol-types";
 import type { ColumnAlignment, ColumnDescriptor, ColumnLayout, DataValueTypeDescriptor, ColumnTypeFormatting, ColumnTypeRendering, ColumnTypeWithValidationRules, DefaultColumnConfiguration, GroupColumnDescriptor, LookupRenderer, MappedValueTypeRenderer, PinLocation, RuntimeColumnDescriptor, TableCellRendererProps, TableConfig, TableHeadings, ValueListRenderer } from "@vuu-ui/vuu-table-types";
-import type { CSSProperties } from "react";
+import { type CSSProperties } from "react";
 import { TableModel } from "@vuu-ui/vuu-table";
 /**
  * ColumnMap provides a lookup of the index position of a data item within a row
@@ -10,6 +10,9 @@ import { TableModel } from "@vuu-ui/vuu-table";
 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;
@@ -45,6 +48,7 @@ export declare const isValueListRenderer: (renderer?: unknown) => renderer is Va
 export declare const hasValidationRules: (type?: DataValueType) => type is ColumnTypeWithValidationRules;
 export declare const isMappedValueTypeRenderer: (renderer?: unknown) => renderer is MappedValueTypeRenderer;
 export declare function buildColumnMap(columns?: (RuntimeColumnDescriptor | SchemaColumn | string)[]): ColumnMap;
+export declare function buildReverseColumnMap(columns?: (RuntimeColumnDescriptor | SchemaColumn | string)[]): ReverseColumnMap;
 export declare function projectUpdates(updates: number[]): number[];
 export declare const metadataKeys: {
     readonly IDX: 0;
@@ -62,7 +66,10 @@ export declare const metadataKeys: {
     readonly NEXT_FILTER_IDX: "next_filter_idx";
 };
 export declare const flattenColumnGroup: (columns: RuntimeColumnDescriptor[]) => RuntimeColumnDescriptor[];
-export declare function extractGroupColumn(columns: RuntimeColumnDescriptor[], groupBy?: VuuGroupBy, confirmed?: boolean): [GroupColumnDescriptor | null, 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
@@ -82,7 +89,13 @@ export declare const measurePinnedColumns: (columns: RuntimeColumnDescriptor[],
 export declare const getTableHeadings: (columns: RuntimeColumnDescriptor[]) => TableHeadings;
 export declare const getColumnStyle: ({ pin, pinnedOffset, width, }: RuntimeColumnDescriptor) => CSSProperties;
 export declare const setAggregations: (aggregations: VuuAggregation[], column: RuntimeColumnDescriptor, aggType: VuuAggType) => VuuAggregation[];
-export declare const applyGroupByToColumns: (columns: RuntimeColumnDescriptor[], groupBy: VuuGroupBy, confirmed?: boolean) => RuntimeColumnDescriptor[];
+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;
@@ -98,16 +111,16 @@ export declare const getColumnsInViewport: (columns: RuntimeColumnDescriptor[],
 export declare const isNotHidden: (column: RuntimeColumnDescriptor) => boolean;
 export declare const visibleColumnAtIndex: (columns: RuntimeColumnDescriptor[], index: number) => RuntimeColumnDescriptor | undefined;
 export declare const getGroupIcon: (columns: RuntimeColumnDescriptor[], row: DataSourceRow) => string | undefined;
-export declare const getGroupValue: (columns: RuntimeColumnDescriptor[], row: DataSourceRow, columnMap: ColumnMap) => unknown;
+export declare const getGroupValue: (columns: RuntimeColumnDescriptor[], row: DataSourceRow, columnMap: ColumnMap) => string | null;
 export declare const getDefaultColumnType: (serverDataType?: VuuColumnDataType) => DataValueTypeSimple;
 export declare const updateColumnFormatting: <T extends ColumnDescriptor = ColumnDescriptor>(column: T, formatting: ColumnTypeFormatting) => T;
 export declare function updateColumnType<T extends ColumnDescriptor = ColumnDescriptor>(column: T, type: DataValueTypeSimple): T;
 export declare const updateColumnRenderProps: <T extends ColumnDescriptor = ColumnDescriptor>(column: T, renderer: ColumnTypeRendering) => T;
 export declare const getTypeFormattingFromColumn: (column: ColumnDescriptor) => ColumnTypeFormatting;
 /**
- *
- * return a filter predicate that will reject columns, names of which
- * are not in provided list.
+ * Return a filter predicate that will reject columns, names of which
+ * are not in provided list. Exception made for columns explicitly
+ * configured as client columns.
  */
 export declare const subscribedOnly: (columnNames?: string[]) => (column: ColumnDescriptor) => boolean | undefined;
 export declare const addColumnToSubscribedColumns: (subscribedColumns: ColumnDescriptor[], availableColumns: SchemaColumn[], columnName: string) => ColumnDescriptor[];

package/types/context-definitions/DataSourceContext.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { DataSource, DataSourceConstructorProps, ServerAPI, TableSchema } from "@vuu-ui/vuu-data-types";
 export type DataSourceConstructor = {
     new (props: DataSourceConstructorProps): DataSource;

package/types/context-definitions/DataSourceProvider.d.ts

@@ -2,7 +2,7 @@ import { ReactNode } from "react";
 import { DataSourceContextProps } from "./DataSourceContext";
 export declare const DataSourceProvider: ({ children, getServerAPI, isLocalData, VuuDataSource, vuuModuleNames, }: Omit<DataSourceContextProps, "isLocalData"> & {
     children: ReactNode;
-    isLocalData?: boolean | undefined;
-}) => JSX.Element;
+    isLocalData?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare const useDataSource: () => DataSourceContextProps;
 export declare const useDataSourceExtensions: () => unknown;

package/types/data-utils.d.ts

@@ -16,3 +16,4 @@ export declare const shallowEquals: (o1?: {
 export declare function getMovingValueDirection(newValue?: number, direction?: valueChangeDirection, prevValue?: number, 
 /** the number of decimal places to take into account when highlighting a change  */
 decimalPlaces?: number): valueChangeDirection;
+export declare function asInteger(index: number | string | undefined, defaultValue?: number): number;

package/types/date/types.d.ts

@@ -18,7 +18,7 @@ export type DateTimePattern = {
     date: DatePattern;
     time?: TimePattern;
 };
-export declare const isDatePattern: (pattern?: string) => pattern is "dd.mm.yyyy" | "dd/mm/yyyy" | "dd MMM yyyy" | "dd MMMM yyyy" | "mm/dd/yyyy" | "MMM dd, yyyy" | "MMMM dd, yyyy";
-export declare const isTimePattern: (pattern?: string) => pattern is "hh:mm:ss" | "hh:mm:ss a";
+export declare const isDatePattern: (pattern?: string) => pattern is DatePattern;
+export declare const isTimePattern: (pattern?: string) => pattern is TimePattern;
 export declare const isDateTimePattern: (pattern?: ColumnTypeFormatting["pattern"]) => pattern is DateTimePattern;
 export {};

package/types/feature-utils.d.ts

@@ -39,8 +39,7 @@ export interface DynamicFeatureDescriptor {
     css?: string;
     leftNavLocation: "vuu-features" | "vuu-tables";
     featureProps?: {
-        schema?: "*" | VuuTable;
-        schemas?: VuuTable[];
+        vuuTables?: "*" | VuuTable[];
     };
     viewProps?: ViewConfig;
 }
@@ -65,13 +64,19 @@ export interface VuuConfig {
     websocketUrl: string;
     ssl: boolean;
 }
+/**
+ * We currently categorize 'features' simply by the leftNavLocation
+ * @param feature
+ * @returns
+ */
 export declare const isCustomFeature: (feature: DynamicFeatureDescriptor) => boolean;
-export declare const isWildcardSchema: (schema?: "*" | VuuTable) => schema is "*";
-export declare const isTableSchema: (schema?: "*" | VuuTable) => schema is VuuTable;
+export declare const isWildcardSchema: (vuuTables?: "*" | VuuTable[]) => vuuTables is "*";
+export declare const isVuuTables: (vuuTables?: "*" | VuuTable[]) => vuuTables is VuuTable[];
 export interface FeaturePropsWithFilterTableFeature extends Omit<DynamicFeatureProps, "ComponentProps"> {
     ComponentProps: FilterTableFeatureProps;
 }
 export declare const hasFilterTableFeatureProps: (props: DynamicFeatureProps) => props is FeaturePropsWithFilterTableFeature;
+export declare const isSameTable: (t1: VuuTable, t2: VuuTable) => void;
 export declare const byModule: (schema1: TableSchema, schema2: TableSchema) => 0 | 1 | -1;
 export type GetFeaturePaths = (params: {
     env: Environment;
@@ -85,7 +90,15 @@ export type Component = {
 };
 export declare const assertComponentRegistered: (componentName: string, component: unknown) => void;
 export declare const assertComponentsRegistered: (componentList: Component[]) => void;
-export declare const getCustomAndTableFeatures: (dynamicFeatures: DynamicFeatureDescriptor[], vuuTables: Map<string, TableSchema>) => {
+/**
+ *  Process the DynamicFeature descriptors. Identify
+ * the vuu tables required and inject the appropriate TableSchemas
+ *
+ * @param dynamicFeatures
+ * @param tableSchemas
+ * @returns
+ */
+export declare const getCustomAndTableFeatures: (dynamicFeatures: DynamicFeatureDescriptor[], tableSchemas: TableSchema[]) => {
     dynamicFeatures: DynamicFeatureProps[];
     tableFeatures: DynamicFeatureProps<FilterTableFeatureProps>[];
 };

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 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";
@@ -6,10 +5,10 @@ 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<string | number | boolean>;
-export declare const isFilterClause: (f?: Partial<Filter>) => f is SingleValueFilterClause<string | number | boolean> | MultiValueFilterClause<number[] | string[] | boolean[]>;
-export declare const isMultiValueFilter: (f?: Partial<Filter>) => f is MultiValueFilterClause<number[] | string[] | boolean[]>;
-export declare const isInFilter: (f: Partial<Filter>) => f is MultiValueFilterClause<number[] | string[] | 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;
@@ -17,44 +16,45 @@ export declare function isMultiClauseFilter(f?: Partial<Filter> | FilterWithPart
 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" | undefined;
+    align?: "left" | "right";
     ariaColIndex: number;
-    CellRenderer?: import("react").FunctionComponent<import("@vuu-ui/vuu-table-types").TableCellRendererProps> | undefined;
-    HeaderCellLabelRenderer?: import("react").FunctionComponent<import("@vuu-ui/vuu-table-types").HeaderCellProps> | undefined;
-    HeaderCellContentRenderer?: import("react").FunctionComponent<import("@vuu-ui/vuu-table-types").HeaderCellProps> | undefined;
-    canStretch?: boolean | undefined;
-    className?: string | undefined;
-    clientSideEditValidationCheck?: import("@vuu-ui/vuu-data-types").DataValueValidationChecker | undefined;
+    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 | undefined;
-    heading?: string[] | undefined;
-    isGroup?: boolean | undefined;
-    isSystemColumn?: boolean | undefined;
+    flex?: number;
+    heading?: [...string[]];
+    isGroup?: boolean;
+    isSystemColumn?: boolean;
     label: string;
-    locked?: boolean | undefined;
-    marginLeft?: number | undefined;
-    moving?: boolean | undefined;
-    originalIdx?: number | undefined;
-    pinnedOffset?: number | undefined;
-    resizeable?: boolean | undefined;
-    resizing?: boolean | undefined;
-    sortable?: boolean | undefined;
-    sorted?: import("@vuu-ui/vuu-table-types").ColumnSort | undefined;
+    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 | undefined;
-    colHeaderContentRenderer?: string | undefined;
-    colHeaderLabelRenderer?: string | undefined;
-    getIcon?: ((row: import("@vuu-ui/vuu-data-types").DataSourceRow) => string | undefined) | undefined;
-    hidden?: boolean | undefined;
-    maxWidth?: number | undefined;
-    minWidth?: number | undefined;
-    pin?: import("@vuu-ui/vuu-table-types").PinLocation | undefined;
-    editable?: boolean | undefined;
-    editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit | undefined;
+    aggregate?: import("@vuu-ui/vuu-protocol-types").VuuAggType;
+    colHeaderContentRenderer?: string;
+    colHeaderLabelRenderer?: string;
+    getIcon?: (row: import("@vuu-ui/vuu-data-types").DataSourceRow) => string | undefined;
+    hidden?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+    pin?: import("@vuu-ui/vuu-table-types").PinLocation;
+    source?: "client" | "server";
+    editable?: boolean;
+    editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;
     name: string;
-    serverDataType?: import("@vuu-ui/vuu-protocol-types").VuuColumnDataType | undefined;
-    type?: import("@vuu-ui/vuu-data-types").DataValueType | undefined;
+    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 = {

package/types/form-utils.d.ts

@@ -7,7 +7,8 @@ import { KeyboardEvent, SyntheticEvent } from "react";
  */
 export declare const getFieldName: (target: EventTarget | HTMLElement) => string;
 export type InputSource = "typeahead-suggestion" | "text-input";
-export type CommitHandler<E extends HTMLElement = HTMLInputElement, T extends VuuRowDataItemType | undefined = string> = (evt: SyntheticEvent<E> | KeyboardEvent<E>, value: T, source?: InputSource) => void;
+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

package/types/formatting-utils.d.ts

@@ -5,3 +5,10 @@ export type ValueFormatters = {
 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/module-utils.d.ts

@@ -1,9 +1,7 @@
-/// <reference types="react" />
 export type ReactComponent = {
     (props?: any): JSX.Element;
 };
-export declare const isModule: (entity: Module | ReactComponent) => entity is Module<ReactComponent>;
+export declare const isModule: (entity: Module | ReactComponent) => entity is Module;
 export interface Module<T = ReactComponent> {
     [key: string]: Module<T> | T;
 }
-export declare const assertModuleExportsAtLeastOneComponent: (module: Module) => void;

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

@@ -25,3 +25,4 @@ export declare function isSessionTableActionMessage(rpcResponse: VuuRpcResponse)
 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/react-utils.d.ts

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

package/types/row-utils.d.ts

@@ -20,4 +20,5 @@ export declare const actualRowPositioning: (rowHeight: number) => RowPositioning
  * @returns
  */
 export declare const virtualRowPositioning: (rowHeight: number, virtualisedExtent: number, pctScrollTop: MutableRefObject<number>) => RowPositioning;
-export declare const asDataSourceRowObject: (row: DataSourceRow, columnMap: ColumnMap) => DataSourceRowObject;
+export type RowToObjectMapper = (row: DataSourceRow, columnMap: ColumnMap) => DataSourceRowObject;
+export declare const asDataSourceRowObject: RowToObjectMapper;

package/types/selection-utils.d.ts

@@ -26,4 +26,4 @@ export type SelectionDiff = {
     added: SelectionItem[];
     removed: SelectionItem[];
 };
-export declare const selectionCount: (selected: Selection) => number;
+export declare const selectionCount: (selected?: Selection) => number;

package/types/tree-types.d.ts

@@ -1,17 +1,8 @@
-export interface TreeSourceNode {
+export interface TreeSourceNode<T = unknown> {
+    nodeData?: T;
     id: string;
     icon?: string;
     header?: boolean;
     label: string;
-    childNodes?: TreeSourceNode[];
-}
-export interface NormalisedTreeSourceNode extends TreeSourceNode {
-    childNodes?: NormalisedTreeSourceNode[];
-    count: number;
-    expanded?: boolean;
-    index: number;
-    level: number;
-}
-export interface NonLeafNode extends NormalisedTreeSourceNode {
-    childNodes: NormalisedTreeSourceNode[];
+    childNodes?: TreeSourceNode<T>[];
 }

package/types/tree-utils.d.ts

@@ -3,3 +3,7 @@ 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/ts-utils.d.ts

@@ -1,2 +1,19 @@
+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>>;
+/**
+ * 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 {};