@vuu-ui/vuu-utils 0.5.10 → 0.5.14

package/types/packages/vuu-utils/src/event-emitter.d.ts

@@ -0,0 +1,19 @@
+export interface Event {
+}
+export declare type EventListener = (evtName: string, ...args: any[]) => void;
+export declare 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/packages/vuu-utils/src/getUniqueId.d.ts

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

package/types/packages/vuu-utils/src/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/packages/vuu-utils/src/invariant.d.ts

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

package/types/packages/vuu-utils/src/nanoid/index.d.ts

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

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

@@ -0,0 +1,21 @@
+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 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/packages/vuu-utils/src/round-decimal.d.ts

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

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

@@ -0,0 +1,10 @@
+export declare type RowIndex = {
+    [field: string]: number;
+};
+export declare 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/packages/vuu-utils/src/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/packages/vuu-utils/src/text-utils.d.ts

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

package/types/showcase/src/examples/DataGrid/columnMetaData.d.ts

@@ -0,0 +1,233 @@
+export const pricesColumns: ({
+    name: string;
+    width: number;
+    type?: undefined;
+    aggregate?: undefined;
+} | {
+    name: string;
+    type: {
+        name: string;
+        renderer: {
+            name: string;
+            flashStyle: string;
+        };
+        formatting: {
+            decimals: number;
+            zeroPad: boolean;
+        };
+    };
+    aggregate: string;
+    width?: undefined;
+} | {
+    name: string;
+    type: {
+        name: string;
+        renderer?: undefined;
+        formatting?: undefined;
+    };
+    width?: undefined;
+    aggregate?: undefined;
+} | {
+    name: string;
+    width?: undefined;
+    type?: undefined;
+    aggregate?: undefined;
+})[];
+export const orderColumns: {
+    name: string;
+    width: number;
+}[];
+export const instrumentPriceColumns: ({
+    name: string;
+    width: number;
+    type?: undefined;
+    aggregate?: undefined;
+} | {
+    name: string;
+    width?: undefined;
+    type?: undefined;
+    aggregate?: undefined;
+} | {
+    name: string;
+    type: {
+        name: string;
+        renderer?: undefined;
+        formatting?: undefined;
+    };
+    width?: undefined;
+    aggregate?: undefined;
+} | {
+    name: string;
+    type: {
+        name: string;
+        renderer: {
+            name: string;
+            flashStyle: string;
+        };
+        formatting: {
+            decimals: number;
+            zeroPad: boolean;
+        };
+    };
+    aggregate: string;
+    width?: undefined;
+})[];
+export namespace instrumentSchema {
+    const columns: ({
+        name: string;
+        width: number;
+        type?: undefined;
+        aggregate?: undefined;
+    } | {
+        name: string;
+        type: {
+            name: string;
+            renderer: {
+                name: string;
+                flashStyle: string;
+            };
+            formatting: {
+                decimals: number;
+                zeroPad: boolean;
+            };
+        };
+        aggregate: string;
+        width?: undefined;
+    } | {
+        name: string;
+        type: string;
+        aggregate: string;
+        width?: undefined;
+    } | {
+        name: string;
+        width?: undefined;
+        type?: undefined;
+        aggregate?: undefined;
+    })[];
+}
+export namespace instrumentSchemaFixed {
+    const columns_1: ({
+        name: string;
+        width: number;
+        locked: boolean;
+        type?: undefined;
+        aggregate?: undefined;
+    } | {
+        name: string;
+        width: number;
+        locked?: undefined;
+        type?: undefined;
+        aggregate?: undefined;
+    } | {
+        name: string;
+        type: {
+            name: string;
+            renderer: {
+                name: string;
+                flashStyle: string;
+            };
+            formatting: {
+                decimals: number;
+                zeroPad: boolean;
+            };
+        };
+        aggregate: string;
+        width?: undefined;
+        locked?: undefined;
+    } | {
+        name: string;
+        type: string;
+        aggregate: string;
+        width?: undefined;
+        locked?: undefined;
+    } | {
+        name: string;
+        width?: undefined;
+        locked?: undefined;
+        type?: undefined;
+        aggregate?: undefined;
+    })[];
+    export { columns_1 as columns };
+}
+export namespace instrumentSchemaLabels {
+    const columns_2: ({
+        name: string;
+        width: number;
+        label: string;
+        type?: undefined;
+        aggregate?: undefined;
+    } | {
+        name: string;
+        type: {
+            name: string;
+            renderer: {
+                name: string;
+                flashStyle: string;
+            };
+            formatting: {
+                decimals: number;
+                zeroPad: boolean;
+            };
+        };
+        aggregate: string;
+        width?: undefined;
+        label?: undefined;
+    } | {
+        name: string;
+        label: string;
+        type: string;
+        aggregate: string;
+        width?: undefined;
+    } | {
+        name: string;
+        label: string;
+        width?: undefined;
+        type?: undefined;
+        aggregate?: undefined;
+    } | {
+        name: string;
+        width?: undefined;
+        label?: undefined;
+        type?: undefined;
+        aggregate?: undefined;
+    })[];
+    export { columns_2 as columns };
+}
+export namespace instrumentSchemaHeaders {
+    const columns_3: ({
+        name: string;
+        width: number;
+        heading: string[];
+        type?: undefined;
+        aggregate?: undefined;
+    } | {
+        name: string;
+        type: {
+            name: string;
+            renderer: {
+                name: string;
+                flashStyle: string;
+            };
+            formatting: {
+                decimals: number;
+                zeroPad: boolean;
+            };
+        };
+        aggregate: string;
+        heading: string[];
+        width?: undefined;
+    } | {
+        name: string;
+        type: string;
+        aggregate: string;
+        heading: string[];
+        width?: undefined;
+    } | {
+        name: string;
+        heading: string[];
+        width?: undefined;
+        type?: undefined;
+        aggregate?: undefined;
+    })[];
+    export { columns_3 as columns };
+}

package/src/DataWindow.ts

@@ -1,111 +0,0 @@
-import { WindowRange } from "./range-utils";
-import { metadataKeys } from "./column-utils";
-
-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 };
-
-const { KEY } = metadataKeys;
-
-const log = (message: string) =>
-  console.log(`%c[DataWindow] ${message}`, "color: purple;font-weight: bold;");
-export class DataWindow {
-  private range: WindowRange;
-  public data: DataRow[];
-  public rowCount = 0;
-  constructor({ from, to }: RangeLike) {
-    log(`constructor ${from} - ${to}`);
-    this.range = new WindowRange(from, to);
-    //internal data is always 0 based, we add range.from to determine an offset
-    this.data = new Array(to - from);
-    // window.dataWindow = this.data;
-    // log(`constructor initial range ${from} - ${to}`);
-  }
-
-  setRowCount = (rowCount: number) => {
-    // log(`rowCount => ${rowCount}`);
-    if (rowCount < this.data.length) {
-      this.data.length = rowCount;
-    }
-    this.rowCount = rowCount;
-  };
-
-  // return true if existing row was updated
-  add(data: DataRow) {
-    const [index] = data;
-    if (this.isWithinRange(index)) {
-      const internalIndex = index - this.range.from;
-      const isUpdate = this.data[internalIndex] !== undefined;
-      this.data[internalIndex] = data;
-      return isUpdate;
-    } else {
-      return false;
-    }
-  }
-
-  getAtIndex(index: number) {
-    return this.range.isWithin(index) &&
-      this.data[index - this.range.from] != null
-      ? this.data[index - this.range.from]
-      : undefined;
-  }
-
-  getByKey(key: string) {
-    return this.data.find((row) => row[KEY] === key);
-  }
-
-  isWithinRange(index: number) {
-    return this.range.isWithin(index) && index <= this.rowCount;
-  }
-
-  setRange(from: number, to: number) {
-    log(`setRange ${from} ${to}`);
-    if (from !== this.range.from || to !== this.range.to) {
-      const [overlapFrom, overlapTo] = this.range.overlap(from, to);
-      const newData = new Array(to - from);
-      for (let i = overlapFrom; i < overlapTo; i++) {
-        const data = this.getAtIndex(i);
-        if (data) {
-          const index = i - from;
-          newData[index] = data;
-        }
-      }
-      this.data = newData;
-      this.range.from = from;
-      this.range.to = to;
-    }
-  }
-
-  hasData(from: number, to: number) {
-    const offset = this.range.from;
-    const start = from - offset;
-    const end = Math.min(to - offset - 1, this.rowCount - 1);
-    return this.data[start] !== undefined && this.data[end] !== undefined;
-  }
-
-  getData(from: number, to: number): any[] {
-    const { from: clientFrom, to: clientTo } = this.range;
-    const startOffset = Math.max(0, from - clientFrom);
-    const endOffset = Math.min(to - clientFrom, this.rowCount ?? to);
-    return this.data.slice(startOffset, endOffset);
-  }
-}

package/src/array-utils.ts

@@ -1,37 +0,0 @@
-export type PartitionTest<T> = (value: T, index: number) => boolean;
-
-export function partition<T>(
-  array: T[],
-  test: PartitionTest<T>,
-  pass: T[] = [],
-  fail: T[] = []
-): [T[], T[]] {
-  for (let i = 0, len = array.length; i < len; i++) {
-    (test(array[i], i) ? pass : fail).push(array[i]);
-  }
-  return [pass, fail];
-}
-
-// Note order of items can be different between arrays
-// If an identityProperty is not defined, item identity is used
-export function itemsChanged<T = unknown>(
-  currentItems: T[],
-  newItems: T[],
-  identityProperty?: string
-) {
-  if (currentItems.length !== newItems.length) {
-    return true;
-  }
-  if (identityProperty === undefined) {
-    return !currentItems.every((item) => newItems.includes(item));
-  } else {
-    return currentItems.some(
-      (currentItem) =>
-        newItems.findIndex(
-          (newItem) =>
-            (newItem as { [key: string]: unknown })[identityProperty] ===
-            (currentItem as { [key: string]: unknown })[identityProperty]
-        ) === -1
-    );
-  }
-}

package/src/column-utils.ts

@@ -1,224 +0,0 @@
-import {
-  ColumnDescriptor,
-  GroupColumnDescriptor,
-  KeyedColumnDescriptor,
-} from "@vuu-ui/vuu-datagrid-types";
-import { VuuGroupBy } from "@vuu-ui/vuu-protocol-types";
-import { instrumentPriceColumns } from "../../../showcase/src/examples/DataGrid/columnMetaData";
-import { Row } from "./row-utils";
-
-export interface ColumnMap {
-  [columnName: string]: number;
-}
-
-const SORT_ASC = "asc";
-
-export type SortCriteriaItem = string | [string, "asc"]; // TODO where is 'desc'?
-
-export function mapSortCriteria(
-  sortCriteria: SortCriteriaItem[],
-  columnMap: ColumnMap,
-  metadataOffset = 0
-): [number, "asc"][] {
-  return sortCriteria.map((s) => {
-    if (typeof s === "string") {
-      return [columnMap[s] + metadataOffset, "asc"];
-    } else if (Array.isArray(s)) {
-      const [columnName, sortDir] = s;
-      return [columnMap[columnName] + metadataOffset, sortDir || SORT_ASC];
-    } else {
-      throw Error("columnUtils.mapSortCriteria invalid input");
-    }
-  });
-}
-
-export const isKeyedColumn = (
-  column: ColumnDescriptor
-): column is KeyedColumnDescriptor => {
-  return typeof (column as KeyedColumnDescriptor).key === "number";
-};
-
-export const isNumericColumn = ({ serverDataType }: ColumnDescriptor) =>
-  serverDataType === undefined
-    ? false
-    : serverDataType === "int" ||
-      serverDataType === "long" ||
-      serverDataType === "double";
-
-export const toColumnDescriptor = (name: string): ColumnDescriptor => ({
-  name,
-});
-
-const EMPTY_COLUMN_MAP = {} as const;
-
-export function buildColumnMap(
-  columns?: (KeyedColumnDescriptor | string)[]
-): ColumnMap {
-  const start = metadataKeys.count;
-  if (columns) {
-    return columns.reduce((map, column, i) => {
-      if (typeof column === "string") {
-        map[column] = start + i;
-      } else if (typeof column.key === "number") {
-        map[column.name] = column.key;
-      } else {
-        map[column.name] = start + i;
-      }
-      return map;
-    }, {} as ColumnMap);
-  } else {
-    return EMPTY_COLUMN_MAP;
-  }
-}
-
-export function projectUpdates(updates: number[]): number[] {
-  const results: number[] = [];
-  const metadataOffset = metadataKeys.count - 2;
-  for (let i = 0; i < updates.length; i += 3) {
-    results[i] = updates[i] + metadataOffset;
-    results[i + 1] = updates[i + 1];
-    results[i + 2] = updates[i + 2];
-  }
-  return results;
-}
-
-export function projectColumns(
-  tableRowColumnMap: ColumnMap,
-  columns: ColumnDescriptor[]
-) {
-  const columnCount = columns.length;
-  const { IDX, RENDER_IDX, DEPTH, COUNT, KEY, SELECTED, count } = metadataKeys;
-  return (startIdx: number, offset: number, selectedRows: Row[] = []) =>
-    (row: Row, i: number) => {
-      // selectedRows are indices of rows within underlying dataset (not sorted or filtered)
-      // row is the original row from this set, with original index in IDX pos, which might
-      // be overwritten with a different value below if rows are sorted/filtered
-      const baseRowIdx: any = row[IDX]; // TODO
-      const out = [];
-      for (let i = 0; i < columnCount; i++) {
-        const colIdx = tableRowColumnMap[columns[i].name];
-        out[count + i] = row[colIdx];
-      }
-
-      out[IDX] = startIdx + i + offset;
-      out[RENDER_IDX] = 0;
-      out[DEPTH] = 0;
-      out[COUNT] = 0;
-      out[KEY] = row[tableRowColumnMap.KEY];
-      out[SELECTED] = selectedRows.includes(baseRowIdx) ? 1 : 0;
-      return out;
-    };
-}
-
-export const metadataKeys = {
-  IDX: 0,
-  RENDER_IDX: 1,
-  IS_LEAF: 2,
-  IS_EXPANDED: 3,
-  DEPTH: 4,
-  COUNT: 5,
-  KEY: 6,
-  SELECTED: 7,
-  count: 8,
-  // TODO following only used in datamodel
-  PARENT_IDX: "parent_idx",
-  IDX_POINTER: "idx_pointer",
-  FILTER_COUNT: "filter_count",
-  NEXT_FILTER_IDX: "next_filter_idx",
-} as const;
-
-// This method mutates the passed columns array
-const insertColumn = (
-  columns: KeyedColumnDescriptor[],
-  column: KeyedColumnDescriptor
-) => {
-  const { originalIdx } = column;
-  if (typeof originalIdx === "number") {
-    for (let i = 0; i < columns.length; i++) {
-      const { originalIdx: colIdx = -1 } = columns[i];
-      if (colIdx > originalIdx) {
-        columns.splice(i, 0, column);
-        return columns;
-      }
-    }
-  }
-  columns.push(column);
-  return columns;
-};
-
-export const flattenColumnGroup = (
-  columns: KeyedColumnDescriptor[]
-): KeyedColumnDescriptor[] => {
-  if (columns[0]?.isGroup) {
-    const [groupColumn, ...nonGroupedColumns] = columns as [
-      GroupColumnDescriptor,
-      ...KeyedColumnDescriptor[]
-    ];
-    groupColumn.columns.forEach((groupColumn) => {
-      insertColumn(nonGroupedColumns, groupColumn);
-    });
-    return nonGroupedColumns;
-  } else {
-    return columns;
-  }
-};
-
-export function extractGroupColumn(
-  columns: KeyedColumnDescriptor[],
-  groupBy?: VuuGroupBy
-): [GroupColumnDescriptor | null, KeyedColumnDescriptor[]] {
-  if (groupBy && groupBy.length > 0) {
-    const flattenedColumns = flattenColumnGroup(columns);
-    // Note: groupedColumns will be in column order, not groupBy order
-    const [groupedColumns, rest] = flattenedColumns.reduce(
-      (result, column, i) => {
-        const [g, r] = result;
-        if (groupBy.includes(column.name)) {
-          g.push({
-            ...column,
-            originalIdx: i,
-          });
-        } else {
-          r.push(column);
-        }
-
-        return result;
-      },
-      [[], []] as [KeyedColumnDescriptor[], KeyedColumnDescriptor[]]
-    );
-    if (groupedColumns.length !== groupBy.length) {
-      throw Error(
-        `extractGroupColumn: no column definition found for all groupBy cols ${JSON.stringify(
-          groupBy
-        )} `
-      );
-    }
-    const groupCount = groupBy.length;
-    const groupCols: KeyedColumnDescriptor[] = groupBy.map((name, idx) => {
-      // Keep the cols in same order defined on groupBy
-      const column = groupedColumns.find(
-        (col) => col.name === name
-      ) as KeyedColumnDescriptor;
-      return {
-        ...column,
-        groupLevel: groupCount - idx,
-      };
-    });
-
-    const groupCol = {
-      key: -1,
-      name: "group-col",
-      heading: ["group-col"],
-      isGroup: true,
-      columns: groupCols,
-      width: groupCols.map((c) => c.width).reduce((a, b) => a + b) + 100,
-    } as GroupColumnDescriptor;
-
-    return [groupCol, rest];
-  }
-  return [null, flattenColumnGroup(columns)];
-}
-
-export const isGroupColumn = (
-  column: KeyedColumnDescriptor
-): column is GroupColumnDescriptor => column.isGroup === true;