@vuu-ui/vuu-utils 0.6.10-debug → 0.6.11

package/package.json

@@ -3,10 +3,10 @@
   "author": "heswell",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@vuu-ui/vuu-data": "0.6.10-debug",
-    "@vuu-ui/vuu-datagrid-types": "0.6.10-debug",
-    "@vuu-ui/vuu-filter-types": "0.6.10-debug",
-    "@vuu-ui/vuu-protocol-types": "0.6.10-debug"
+    "@vuu-ui/vuu-data": "0.6.11",
+    "@vuu-ui/vuu-datagrid-types": "0.6.11",
+    "@vuu-ui/vuu-filter-types": "0.6.11",
+    "@vuu-ui/vuu-protocol-types": "0.6.11"
   },
   "peerDependencies": {
     "react": "^17.0.2",
@@ -14,9 +14,11 @@
   },
   "files": [
     "cjs",
-    "esm"
+    "esm",
+    "/types"
   ],
   "module": "esm/index.js",
   "main": "cjs/index.js",
-  "version": "0.6.10-debug"
+  "version": "0.6.11",
+  "types": "types/index.d.ts"
 }

package/types/DataWindow.d.ts

@@ -0,0 +1,39 @@
+export type DataItem = string | number | boolean;
+export type DataRow = [
+    /** index */
+    number,
+    /** render index */
+    number,
+    /** isLeaf */
+    boolean,
+    /** isExpanded */
+    boolean,
+    /** depth  */
+    number,
+    /** child count */
+    number,
+    /** key  */
+    string,
+    /** selected */
+    number,
+    /** data values  */
+    ...DataItem[]
+];
+export type RangeLike = {
+    from: number;
+    to: number;
+};
+export declare class DataWindow {
+    private range;
+    data: DataRow[];
+    rowCount: number;
+    constructor({ from, to }: RangeLike);
+    setRowCount: (rowCount: number) => void;
+    add(data: DataRow): boolean;
+    getAtIndex(index: number): DataRow | undefined;
+    getByKey(key: string): DataRow | undefined;
+    isWithinRange(index: number): boolean;
+    setRange(from: number, to: number): void;
+    hasData(from: number, to: number): boolean;
+    getData(from: number, to: number): any[];
+}

package/types/array-utils.d.ts

@@ -0,0 +1,4 @@
+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 const moveItem: <T = unknown>(items: T[], item: T, moveTo: number) => T[];

package/types/column-utils.d.ts

@@ -0,0 +1,55 @@
+import { ColumnDescriptor, ColumnType, ColumnTypeDescriptor, ColumnTypeSimple, GroupColumnDescriptor, KeyedColumnDescriptor, TableHeadings } from "@vuu-ui/vuu-datagrid-types";
+import { VuuAggregation, VuuAggType, VuuColumnDataType, VuuGroupBy, VuuRowRecord, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import { CSSProperties } from "react";
+import { DataSourceRow } from "@vuu-ui/vuu-data";
+import { DataSourceFilter } from "@vuu-ui/vuu-data-types";
+import { Filter } from "@vuu-ui/vuu-filter-types";
+export interface ColumnMap {
+    [columnName: string]: number;
+}
+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 isKeyedColumn: (column: ColumnDescriptor) => column is KeyedColumnDescriptor;
+export declare const fromServerDataType: (serverDataType: VuuColumnDataType) => ColumnTypeSimple;
+export declare const isNumericColumn: ({ serverDataType, type }: ColumnDescriptor) => boolean;
+export declare const notHidden: (column: ColumnDescriptor) => boolean;
+export declare const isPinned: (column: ColumnDescriptor) => boolean;
+export declare const hasHeadings: (column: ColumnDescriptor) => boolean;
+export declare const isResizing: (column: KeyedColumnDescriptor) => boolean | undefined;
+export declare const isTextColumn: ({ serverDataType }: ColumnDescriptor) => boolean;
+export declare const toColumnDescriptor: (name: string) => ColumnDescriptor;
+export declare const isTypeDescriptor: (type?: ColumnType) => type is ColumnTypeDescriptor;
+export declare function buildColumnMap(columns?: (KeyedColumnDescriptor | 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 count: 8;
+    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: KeyedColumnDescriptor[]) => KeyedColumnDescriptor[];
+export declare function extractGroupColumn(columns: KeyedColumnDescriptor[], groupBy?: VuuGroupBy): [GroupColumnDescriptor | null, KeyedColumnDescriptor[]];
+export declare const isGroupColumn: (column: KeyedColumnDescriptor) => column is GroupColumnDescriptor;
+export declare const sortPinnedColumns: (columns: KeyedColumnDescriptor[]) => KeyedColumnDescriptor[];
+export declare const getTableHeadings: (columns: KeyedColumnDescriptor[]) => TableHeadings;
+export declare const getColumnPinStyle: (column: KeyedColumnDescriptor) => CSSProperties | undefined;
+export declare const setAggregations: (aggregations: VuuAggregation[], column: KeyedColumnDescriptor, aggType: VuuAggType) => VuuAggregation[];
+export declare const extractFilterForColumn: (filter: Filter | undefined, columnName: string) => Filter | undefined;
+export declare const applyGroupByToColumns: (columns: KeyedColumnDescriptor[], groupBy: VuuGroupBy) => KeyedColumnDescriptor[];
+export declare const applySortToColumns: (colunms: KeyedColumnDescriptor[], sort: VuuSort) => KeyedColumnDescriptor[];
+export declare const applyFilterToColumns: (columns: KeyedColumnDescriptor[], { filterStruct }: DataSourceFilter) => KeyedColumnDescriptor[];
+export declare const getColumnName: (name: string) => string;
+export declare const toDataSourceColumns: (column: ColumnDescriptor) => string;
+export declare const getRowRecord: (row: DataSourceRow, columnMap: ColumnMap) => VuuRowRecord;

package/types/component-registry.d.ts

@@ -0,0 +1,19 @@
+import { FunctionComponent as FC, HTMLAttributes } from "react";
+import { TableCellProps } from "@vuu-ui/vuu-datatable/src/TableCell";
+import { VuuColumnDataType } from "@vuu-ui/vuu-protocol-types";
+export interface CellConfigPanelProps extends HTMLAttributes<HTMLDivElement> {
+    onConfigChange: () => void;
+}
+export type ComponentType = "cell-renderer" | "cell-config-panel";
+type CellRendererOptions = {
+    [key: string]: unknown;
+    serverDataType?: VuuColumnDataType | VuuColumnDataType[];
+};
+export interface CellRendererDescriptor extends CellRendererOptions {
+    name: string;
+}
+export declare function registerComponent<T extends TableCellProps | CellConfigPanelProps = TableCellProps>(componentName: string, component: FC<T>, type: ComponentType | undefined, options: CellRendererOptions): void;
+export declare const getRegisteredCellRenderers: (serverDataType?: VuuColumnDataType) => CellRendererDescriptor[];
+export declare function getCellRenderer(name?: string): FC<TableCellProps> | undefined;
+export declare function getCellConfigPanelRenderer(name: string): FC<CellConfigPanelProps> | undefined;
+export {};

package/types/data-utils.d.ts

@@ -0,0 +1,9 @@
+export type valueChangeDirection = "up1" | "up2" | "down1" | "down2" | "";
+export declare const UP1 = "up1";
+export declare const UP2 = "up2";
+export declare const DOWN1 = "down1";
+export declare const DOWN2 = "down2";
+export declare const isValidNumber: (n: unknown) => n is number;
+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;

package/types/date-utils.d.ts

@@ -0,0 +1 @@
+export declare const formatDate: (date: Date, format: string) => string;

package/types/event-emitter.d.ts

@@ -0,0 +1,19 @@
+export interface Event {
+}
+export type EventListener = (evtName: string, ...args: any[]) => void;
+export type EventListenerMap = {
+    [eventName: string]: EventListener[] | EventListener;
+};
+export interface IEventEmitter {
+    emit: (type: string, ...args: unknown[]) => void;
+}
+export declare class EventEmitter implements IEventEmitter {
+    private _events?;
+    constructor();
+    addListener(type: string, listener: EventListener): void;
+    removeListener(type: string, listener: EventListener): void;
+    removeAllListeners(type: string): void;
+    emit(type: string, ...args: unknown[]): void;
+    once(type: string, listener: EventListener): void;
+    on(type: string, listener: EventListener): void;
+}

package/types/filter-utils.d.ts

@@ -0,0 +1,8 @@
+import { AndFilter, Filter, MultiClauseFilter, MultiValueFilterClause, OrFilter, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+export declare const isSingleValueFilter: (f?: Partial<Filter>) => f is SingleValueFilterClause<string | number | boolean>;
+export declare const isFilterClause: (f?: Partial<Filter>) => f is MultiValueFilterClause | SingleValueFilterClause<string | number | boolean>;
+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 function isMultiClauseFilter(f?: Partial<Filter>): f is MultiClauseFilter;

package/types/formatting-utils.d.ts

@@ -0,0 +1,8 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-datagrid-types";
+export type ValueFormatter = (value: unknown) => string;
+export type ValueFormatters = {
+    [key: string]: ValueFormatter;
+};
+export declare const defaultValueFormatter: (value: unknown) => string;
+export declare const numericFormatter: ({ align, type, }: ColumnDescriptor) => (value: unknown) => string;
+export declare const getValueFormatter: (column: ColumnDescriptor) => ValueFormatter;

package/types/getUniqueId.d.ts

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

package/types/group-utils.d.ts

@@ -0,0 +1,3 @@
+import { KeyedColumnDescriptor } from "@vuu-ui/vuu-datagrid-types";
+import { VuuGroupBy } from "@vuu-ui/vuu-protocol-types";
+export declare function addGroupColumn(groupBy: VuuGroupBy, column: KeyedColumnDescriptor): string[];

package/types/html-utils.d.ts

@@ -0,0 +1 @@
+export declare const createEl: (elementType: "div" | "p" | "span", className?: string, textContent?: string) => HTMLElement;

package/types/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./array-utils";
+export * from "./column-utils";
+export * from "./component-registry";
+export * from "./DataWindow";
+export * from "./data-utils";
+export * from "./date-utils";
+export * from "./filter-utils";
+export * from "./html-utils";
+export * from "./event-emitter";
+export * from "./formatting-utils";
+export * from "./getUniqueId";
+export * from "./group-utils";
+export * from "./input-utils";
+export * from "./invariant";
+export * from "./nanoid";
+export * from "./round-decimal";
+export * from "./range-utils";
+export * from "./row-utils";
+export * from "./selection-utils";
+export * from "./sort-utils";
+export * from "./text-utils";
+export * from "./logging-utils";

package/types/input-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isCharacterKey: (evt: KeyboardEvent) => boolean | undefined;
+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/logging-level.d.ts

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

package/types/logging-utils.d.ts

@@ -0,0 +1,40 @@
+export interface LogFn {
+    (message?: unknown, ...optionalParams: unknown[]): void;
+}
+export interface AssertLogFn {
+    (condition: boolean, message?: unknown, errorMessaage?: unknown): void;
+}
+export interface TableLogFn {
+    (properties?: object): void;
+}
+export interface Logger {
+    log: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    group: LogFn;
+    groupCollapsed: LogFn;
+    groupEnd: LogFn;
+    assert: AssertLogFn;
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    table: TableLogFn;
+}
+export type BuildEnv = 'production' | 'development';
+export declare class ConsoleLogger implements Logger {
+    readonly log: LogFn;
+    readonly warn: LogFn;
+    readonly error: LogFn;
+    readonly group: LogFn;
+    readonly groupCollapsed: LogFn;
+    readonly groupEnd: LogFn;
+    readonly assert: AssertLogFn;
+    readonly trace: LogFn;
+    readonly debug: LogFn;
+    readonly info: LogFn;
+    readonly table: TableLogFn;
+    constructor(options?: {
+        buildEnv?: string;
+    }, level?: string);
+}
+export declare const logger: ConsoleLogger;

package/types/nanoid/index.d.ts

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

package/types/range-utils.d.ts

@@ -0,0 +1,22 @@
+export interface VuuRange {
+    from: number;
+    to: number;
+    bufferSize?: number;
+    reset?: boolean;
+}
+interface FromToRange {
+    from: number;
+    to: number;
+}
+export declare function getFullRange({ from, to }: VuuRange, bufferSize?: number, rowCount?: number): FromToRange;
+export declare function resetRange({ from, to, bufferSize }: VuuRange): VuuRange;
+export declare const withinRange: (value: number, { from, to }: VuuRange) => boolean;
+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/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,10 @@
+export type RowIndex = {
+    [field: string]: number;
+};
+export type Row = {
+    [strKey: string]: any;
+} & any[];
+export declare function addRowsToIndex(rows: Row[], index: RowIndex, indexField: string): RowIndex;
+export declare function indexRows(rows: Row[], indexField: string): RowIndex;
+export declare function isEmptyRow(row: Row): boolean;
+export declare function update(rows: Row[], updates: any): Row[];

package/types/selection-utils.d.ts

@@ -0,0 +1,5 @@
+import { Selection, TableSelectionModel } from "@vuu-ui/vuu-datagrid-types";
+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;
+export declare const isSelected: (selected: Selection, itemIndex: number) => boolean;
+export declare const expandSelection: (selected: Selection) => number[];

package/types/sort-utils.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDescriptor, KeyedColumnDescriptor } from "@vuu-ui/vuu-datagrid-types";
+import { VuuSort, VuuSortType } from "@vuu-ui/vuu-protocol-types";
+export declare const applySort: ({ sortDefs }: VuuSort, { name: column }: ColumnDescriptor, extendSort?: boolean, sortType?: VuuSortType) => VuuSort;
+export declare const setSortColumn: ({ sortDefs }: VuuSort, column: KeyedColumnDescriptor, sortType?: "A" | "D") => VuuSort;
+export declare const addSortColumn: ({ sortDefs }: VuuSort, column: KeyedColumnDescriptor, sortType?: "A" | "D") => VuuSort;

package/types/text-utils.d.ts

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