@vuu-ui/vuu-utils 3.5.5 → 3.5.6

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.5",
+  "version": "3.5.6",
   "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.5.5",
-    "@vuu-ui/vuu-table-types": "3.5.5",
-    "@vuu-ui/vuu-filter-types": "3.5.5",
-    "@vuu-ui/vuu-protocol-types": "3.5.5"
+    "@vuu-ui/vuu-data-types": "3.5.6",
+    "@vuu-ui/vuu-table-types": "3.5.6",
+    "@vuu-ui/vuu-filter-types": "3.5.6",
+    "@vuu-ui/vuu-protocol-types": "3.5.6"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "3.5.5",
+    "@vuu-ui/vuu-filter-parser": "3.5.6",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"

package/src/column-utils.js

@@ -45,14 +45,17 @@ const getRuntimeColumnWidth = (col, runtimeColumns)=>{
     if (runtimeColumn) return runtimeColumn.width;
     return DEFAULT_COL_WIDTH;
 };
-const applyRuntimeColumnWidthsToConfig = (tableConfig, columns)=>({
+const applyRuntimeColumnWidthsToConfig = (tableConfig, columns)=>{
+    const runtimeColumns = columns.flatMap((column)=>isGroupColumn(column) ? column.columns : column);
+    return {
         ...tableConfig,
-        columns: columns.map((column)=>({
+        columns: tableConfig.columns.map((column)=>({
                 ...column,
-                width: column.width ?? getRuntimeColumnWidth(column, columns)
+                width: runtimeColumns.find(({ name })=>name === column.name)?.width ?? column.width ?? DEFAULT_COL_WIDTH
             })),
         columnLayout: "manual"
-    });
+    };
+};
 const isValidColumnAlignment = (v)=>"left" === v || "right" === v;
 const isValidPinLocation = (v)=>isValidColumnAlignment(v) || "floating" === v || "" === v;
 const VUU_COLUMN_DATA_TYPES = [

package/src/feature-utils.js

@@ -3,6 +3,12 @@ import { wordify } from "./text-utils.js";
 import react from "react";
 import { getLayoutComponent } from "./component-registry.js";
 const env = process.env.NODE_ENV;
+const importFeatureByUrl = (url)=>import(/* @vite-ignore */ url);
+let featureImporter = importFeatureByUrl;
+const setFeatureImporter = (importer)=>{
+    featureImporter = importer;
+};
+const importFeature = (url)=>featureImporter(url);
 const isStaticFeature = (feature)=>null !== feature && "object" == typeof feature && "type" in feature;
 const isStaticFeatures = (features)=>Array.isArray(features) && features.every(isStaticFeature);
 function featureFromJson({ type }) {
@@ -83,4 +89,4 @@ const getCustomAndTableFeatures = (dynamicFeatures, tableSchemas)=>{
         tableFeatures: tableFeatures
     };
 };
-export { assertComponentRegistered, assertComponentsRegistered, byModule, env, featureFromJson, getCustomAndTableFeatures, getFilterTableFeatures, hasFilterTableFeatureProps, isCustomFeature, isSameTable, isStaticFeatures, isVuuTables, isWildcardSchema };
+export { assertComponentRegistered, assertComponentsRegistered, byModule, env, featureFromJson, getCustomAndTableFeatures, getFilterTableFeatures, hasFilterTableFeatureProps, importFeature, importFeatureByUrl, isCustomFeature, isSameTable, isStaticFeatures, isVuuTables, isWildcardSchema, setFeatureImporter };

package/src/round-decimal.js

@@ -4,6 +4,12 @@ const DECIMALS_AUTO = -1;
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER.toString();
 const MAX_INTEGER_DIGITS = MAX_SAFE_INTEGER.length;
 const exceedsMaxSafeInteger = (value)=>value.length > MAX_INTEGER_DIGITS || value.length === MAX_INTEGER_DIGITS && value > MAX_SAFE_INTEGER;
+const carriesIntoIntegral = (fraction, decimals, roundingRule)=>"round" === roundingRule && decimals !== DECIMALS_AUTO && fraction.length > decimals && parseFloat(`0.${fraction}`).toFixed(decimals).startsWith("1");
+const incrementIntegral = (integral)=>{
+    const negative = integral.startsWith("-");
+    const magnitude = BigInt(negative ? integral.slice(1) : integral) + 1n;
+    return `${negative ? "-" : ""}${magnitude}`;
+};
 const Space = {
     DIGIT: DIGIT_STR,
     TWO_DIGITS: DIGIT_STR + DIGIT_STR,
@@ -61,7 +67,8 @@ function roundDecimal(value, align = Align.Right, decimals = 4, zeroPad, alignOn
     let integral;
     let fraction;
     let Pad;
-    const [part1, part2 = ""] = value.toString().split(".");
+    const [whole, part2 = ""] = value.toString().split(".");
+    const part1 = carriesIntoIntegral(part2, decimals, roundingRule) ? incrementIntegral(whole) : whole;
     const actualDecimals = part2.length;
     integral = "-0" === part1 ? "-0" : useLocaleString ? parseFloat(part1).toLocaleString() : parseFloat(part1).toString();
     if (align === Align.Left && alignOnDecimals) integral = padLeft(integral);
@@ -73,7 +80,8 @@ function roundScaledDecimal(value, align = Align.Right, decimals = 4, zeroPad, a
     let fraction;
     let Pad;
     if ("" === value) return "";
-    const [part1, part2 = ""] = value.split(".");
+    const [whole, part2 = ""] = value.split(".");
+    const part1 = carriesIntoIntegral(part2, decimals, roundingRule) ? incrementIntegral(whole) : whole;
     const actualDecimals = part2.length;
     integral = "" === part1 ? "0" : "-0" === part1 ? "-0" : useLocaleString ? exceedsMaxSafeInteger(value) ? BigInt(part1).toLocaleString() : parseFloat(part1).toLocaleString() : part1;
     if (align === Align.Left && alignOnDecimals) integral = padLeft(integral);

package/types/feature-utils.d.ts

@@ -1,7 +1,7 @@
 import type { TableSchema } from "@vuu-ui/vuu-data-types";
 import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
-import { ListOption } from "@vuu-ui/vuu-table-types";
-import { ReactElement } from "react";
+import type { ListOption } from "@vuu-ui/vuu-table-types";
+import React, { type ReactElement } from "react";
 export type PathMap = {
     [key: string]: Pick<DynamicFeatureDescriptor, "css" | "url">;
 };
@@ -29,6 +29,20 @@ export interface DynamicFeatureProps<P extends object | undefined = object> {
     url: string;
     width?: number;
 }
+export type FeatureModule = {
+    default: React.ComponentType<object>;
+};
+export type FeatureImporter = (url: string) => Promise<FeatureModule>;
+declare const importFeatureByUrl: FeatureImporter;
+/**
+ * By default, a dynamic feature is loaded from its url with a native
+ * dynamic import. An application that bundles its features can install
+ * an importer that resolves feature urls to bundled modules. Use
+ * `importFeatureByUrl` as a fallback for unknown urls.
+ */
+export declare const setFeatureImporter: (importer: FeatureImporter) => void;
+export declare const importFeature: (url: string) => Promise<FeatureModule>;
+export { importFeatureByUrl };
 declare global {
     const vuuConfig: Promise<VuuConfig>;
 }

package/types/tree-types.d.ts

@@ -5,5 +5,7 @@ export interface TreeSourceNode<T = unknown> {
     header?: boolean;
     label: string;
     childNodes?: TreeSourceNode<T>[];
+    /** node is rendered expanded initially */
+    expanded?: boolean;
     tags?: string[];
 }

package/types/src/Clock.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,243 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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 {};