@vuu-ui/vuu-utils 0.5.4 → 0.5.6

package/src/column-utils.ts

@@ -1,133 +0,0 @@
-import {
-  ColumnDescriptor,
-  KeyedColumnDescriptor,
-} from "@vuu-ui/vuu-datagrid/src/grid-model/gridModelTypes";
-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 function isKeyedColumn(
-  column: ColumnDescriptor
-): column is KeyedColumnDescriptor {
-  return typeof (column as KeyedColumnDescriptor).key === "number";
-}
-
-export const toColumnDescriptor = (name: string): ColumnDescriptor => ({
-  name,
-});
-
-export const toKeyedColumn = (
-  column: string | ColumnDescriptor,
-  key: number
-): KeyedColumnDescriptor => {
-  if (typeof column === "string") {
-    return { key, name: column };
-  }
-  if (isKeyedColumn(column)) {
-    return column;
-  }
-  return { ...column, key };
-};
-
-const EMPTY_COLUMN_MAP = {} as const;
-
-export function buildColumnMap(columns?: (Column | 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 type Meta = {
-  [key: string]: any;
-} & any[];
-
-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;

package/src/data-utils.ts

@@ -1,60 +0,0 @@
-export type valueChangeDirection = "up1" | "up2" | "down1" | "down2" | "";
-
-export const UP1 = "up1";
-export const UP2 = "up2";
-export const DOWN1 = "down1";
-export const DOWN2 = "down2";
-
-export const isValidNumber = (n: unknown): n is number =>
-  typeof n === "number" && isFinite(n);
-
-export function getMovingValueDirection(
-  newValue: number,
-  direction?: valueChangeDirection,
-  prevValue?: number,
-  /** the number of decimal places to take into account when highlighting a change  */
-  decimalPlaces?: number
-): valueChangeDirection {
-  if (
-    !isFinite(newValue) ||
-    prevValue === undefined ||
-    direction === undefined
-  ) {
-    return "";
-  } else {
-    let diff = newValue - prevValue;
-    if (diff) {
-      // make sure there is still a diff when reduced to number of decimals to be displayed
-      if (typeof decimalPlaces === "number") {
-        diff =
-          +newValue.toFixed(decimalPlaces) - +prevValue.toFixed(decimalPlaces);
-      }
-    }
-
-    if (diff) {
-      if (direction === "") {
-        if (diff < 0) {
-          return DOWN1;
-        } else {
-          return UP1;
-        }
-      } else if (diff > 0) {
-        if (direction === DOWN1 || direction === DOWN2 || direction === UP2) {
-          return UP1;
-        } else {
-          return UP2;
-        }
-      } else if (
-        direction === UP1 ||
-        direction === UP2 ||
-        direction === DOWN2
-      ) {
-        return DOWN1;
-      } else {
-        return DOWN2;
-      }
-    } else {
-      return "";
-    }
-  }
-}

package/src/date-utils.ts

@@ -1,4 +0,0 @@
-//TODO
-export const formatDate = (date: Date, format: string) => {
-  return date.toUTCString();
-};

package/src/event-emitter.ts

@@ -1,139 +0,0 @@
-export interface Event {}
-
-export type EventListener = (evtName: string, ...args: any[]) => void;
-
-export type EventListenerMap = {
-  [eventName: string]: EventListener[] | EventListener;
-};
-
-function isArrayOfListeners(
-  listeners: EventListener | EventListener[]
-): listeners is EventListener[] {
-  return Array.isArray(listeners);
-}
-
-function isOnlyListener(
-  listeners: EventListener | EventListener[]
-): listeners is EventListener {
-  return !Array.isArray(listeners);
-}
-
-export interface IEventEmitter {
-  emit: (type: string, ...args: unknown[]) => void;
-}
-
-export class EventEmitter implements IEventEmitter {
-  private _events?: EventListenerMap;
-
-  constructor() {
-    this._events = {};
-  }
-
-  addListener(type: string, listener: EventListener) {
-    if (!this._events) {
-      this._events = {};
-    }
-
-    const listeners = this._events[type];
-
-    if (!listeners) {
-      this._events[type] = listener;
-    } else if (isArrayOfListeners(listeners)) {
-      listeners.push(listener);
-    } else if (isOnlyListener(listeners)) {
-      this._events[type] = [listeners, listener];
-    }
-  }
-
-  removeListener(type: string, listener: EventListener) {
-    if (!this._events || !this._events[type]) {
-      return;
-    }
-
-    const listenerOrListeners = this._events[type];
-    let position = -1;
-
-    if (listenerOrListeners === listener) {
-      delete this._events[type];
-    } else if (Array.isArray(listenerOrListeners)) {
-      for (let i = length; i-- > 0; ) {
-        if (listenerOrListeners[i] === listener) {
-          position = i;
-          break;
-        }
-      }
-
-      if (position < 0) {
-        return;
-      }
-
-      if (listenerOrListeners.length === 1) {
-        listenerOrListeners.length = 0;
-        delete this._events[type];
-      } else {
-        listenerOrListeners.splice(position, 1);
-      }
-    }
-  }
-
-  removeAllListeners(type: string) {
-    if (!this._events) {
-      return;
-    } else if (type === undefined) {
-      delete this._events;
-    } else {
-      delete this._events[type];
-    }
-  }
-
-  emit(type: string, ...args: unknown[]) {
-    if (this._events) {
-      const handler = this._events[type];
-      if (handler) {
-        invokeHandler(handler, type, args);
-      }
-      const wildcardHandler = this._events["*"];
-      if (wildcardHandler) {
-        invokeHandler(wildcardHandler, type, args);
-      }
-    }
-  }
-
-  once(type: string, listener: EventListener) {
-    const handler = (evtName: string, message: unknown) => {
-      this.removeListener(evtName, handler);
-      listener(evtName, message);
-    };
-
-    this.on(type, handler);
-  }
-
-  on(type: string, listener: EventListener) {
-    return this.addListener(type, listener);
-  }
-}
-
-function invokeHandler(
-  handler: EventListener | EventListener[],
-  type: string,
-  args: unknown[]
-) {
-  if (isArrayOfListeners(handler)) {
-    handler.slice().forEach((listener) => invokeHandler(listener, type, args));
-  } else {
-    switch (args.length) {
-      case 0:
-        handler(type);
-        break;
-      case 1:
-        handler(type, args[0]);
-        break;
-      case 2:
-        handler(type, args[0], args[1]);
-        break;
-      // slower
-      default:
-        handler.call(null, type, ...args);
-    }
-  }
-}

package/src/getUniqueId.ts

@@ -1 +0,0 @@
-export const getUniqueId = () => `hw-${Math.round(Math.random() * 1e5)}`;

package/src/input-utils.ts

@@ -1,50 +0,0 @@
-const actionKeys = {
-  Enter: 'Enter',
-  Delete: 'Delete'
-};
-
-const navigationKeys = {
-  Home: 'Home',
-  End: 'End',
-  ArrowRight: 'ArrowRight',
-  ArrowLeft: 'ArrowLeft',
-  ArrowDown: 'ArrowDown',
-  ArrowUp: 'ArrowUp',
-  Tab: 'Tab'
-};
-const functionKeys = {
-  F1: 'F1',
-  F2: 'F2',
-  F3: 'F3',
-  F4: 'F4',
-  F5: 'F5',
-  F6: 'F6',
-  F7: 'F7',
-  F8: 'F8',
-  F9: 'F9',
-  F10: 'F10',
-  F11: 'F11',
-  F12: 'F12'
-};
-
-const specialKeys = {
-  ...actionKeys,
-  ...navigationKeys,
-  ...functionKeys
-};
-type specialKey = keyof typeof specialKeys;
-
-const isSpecialKey = (key: string): key is specialKey => key in specialKeys;
-
-export const isCharacterKey = (evt: KeyboardEvent) => {
-  if (isSpecialKey(evt.key)) {
-    return false;
-  }
-  if (typeof evt.which === 'number' && evt.which > 0) {
-    return !evt.ctrlKey && !evt.metaKey && !evt.altKey && evt.which !== 8;
-  }
-};
-
-export const isQuoteKey = (evt: KeyboardEvent) => {
-  return evt.key === '"' || evt.key === "'";
-};

package/src/invariant.ts

@@ -1,10 +0,0 @@
-export function invariant(condition: boolean, message: string) {
-  if (!condition) {
-    const error = new Error(message);
-    error.name = 'Invariant Violation';
-    // TODO what is framesToPop?
-    // @ts-ignore
-    error.framesToPop = 1; // we don't care about invariant's own frame
-    throw error;
-  }
-}

package/src/nanoid/index.ts

@@ -1,30 +0,0 @@
-// This is the index.browser.js file from nanoid
-// couldn't get original code to work as npm import without crypro warnings -
-// seemed to be picking up node version, not browser version
-
-export const uuid = (size: number = 21): string => {
-  let id: string = '';
-  let bytes = crypto.getRandomValues(new Uint8Array(size));
-
-  // A compact alternative for `for (var i = 0; i < step; i++)`.
-  while (size--) {
-    // It is incorrect to use bytes exceeding the alphabet size.
-    // The following mask reduces the random byte in the 0-255 value
-    // range to the 0-63 value range. Therefore, adding hacks, such
-    // as empty string fallback or magic numbers, is unneccessary because
-    // the bitmask trims bytes down to the alphabet size.
-    let byte = bytes[size] & 63;
-    if (byte < 36) {
-      // `0-9a-z`
-      id += byte.toString(36);
-    } else if (byte < 62) {
-      // `A-Z`
-      id += (byte - 26).toString(36).toUpperCase();
-    } else if (byte < 63) {
-      id += '_';
-    } else {
-      id += '-';
-    }
-  }
-  return id;
-};

package/src/range-utils.ts

@@ -1,72 +0,0 @@
-export interface VuuRange {
-  from: number;
-  to: number;
-  bufferSize?: number;
-  reset?: boolean;
-}
-
-interface FromToRange {
-  from: number;
-  to: number;
-}
-
-export function getFullRange(
-  { from, to }: VuuRange,
-  bufferSize: number = 0,
-  rowCount: number = Number.MAX_SAFE_INTEGER
-): FromToRange {
-  if (bufferSize === 0) {
-    return { from, to: Math.min(to, rowCount) };
-  } else if (from === 0) {
-    return { from, to: Math.min(to + bufferSize, rowCount) };
-  } else {
-    const rangeSize = to - from;
-    const buff = Math.round(bufferSize / 2);
-    const shortfallBefore = from - buff < 0;
-    const shortFallAfter = rowCount - (to + buff) < 0;
-
-    if (shortfallBefore && shortFallAfter) {
-      return { from: 0, to: rowCount };
-    } else if (shortfallBefore) {
-      return { from: 0, to: rangeSize + bufferSize };
-    } else if (shortFallAfter) {
-      return { from: Math.max(0, rowCount - (rangeSize + bufferSize)), to: rowCount };
-    } else {
-      return { from: from - buff, to: to + buff };
-    }
-  }
-}
-
-export function resetRange({ from, to, bufferSize = 0 }: VuuRange): VuuRange {
-  return {
-    from: 0,
-    to: to - from,
-    bufferSize,
-    reset: true
-  };
-}
-
-export class WindowRange {
-  public from: number;
-  public to: number;
-
-  constructor(from: number, to: number) {
-    this.from = from;
-    this.to = to;
-  }
-
-  public isWithin(index: number) {
-    return index >= this.from && index < this.to;
-  }
-
-  //find the overlap of this range and a new one
-  public overlap(from: number, to: number): [number, number] {
-    return from >= this.to || to < this.from
-      ? [0, 0]
-      : [Math.max(from, this.from), Math.min(to, this.to)];
-  }
-
-  public copy(): WindowRange {
-    return new WindowRange(this.from, this.to);
-  }
-}

package/src/round-decimal.ts

@@ -1,126 +0,0 @@
-const PUNCTUATION_STR = String.fromCharCode(8200);
-const DIGIT_STR = String.fromCharCode(8199);
-const DECIMALS_AUTO = -1;
-
-type PadMap = {
-  DIGIT: string;
-  TWO_DIGITS: string;
-  THREE_DIGITS: string;
-  FULL_PADDING: [null, string, string, string, string];
-};
-
-const Space: PadMap = {
-  DIGIT: DIGIT_STR,
-  TWO_DIGITS: DIGIT_STR + DIGIT_STR,
-  THREE_DIGITS: DIGIT_STR + DIGIT_STR + DIGIT_STR,
-  FULL_PADDING: [
-    null,
-    PUNCTUATION_STR + DIGIT_STR,
-    PUNCTUATION_STR + DIGIT_STR + DIGIT_STR,
-    PUNCTUATION_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR,
-    PUNCTUATION_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR + DIGIT_STR,
-  ],
-};
-
-const Zero: PadMap = {
-  DIGIT: "0",
-  TWO_DIGITS: "00",
-  THREE_DIGITS: "000",
-  FULL_PADDING: [null, "0", "00", "000", "0000"],
-};
-
-function padLeft(value: string, maxLength = 6) {
-  return (LEADING_FILL + value).slice(-maxLength);
-}
-
-const LEADING_FILL =
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR +
-  DIGIT_STR;
-
-const Align = {
-  Right: "right",
-  Center: "center",
-  Left: "left",
-};
-
-function pad(n: string, dp: number, Pad: PadMap): string {
-  let len = n.length;
-  const diff = dp - len;
-
-  if (diff > 0) {
-    if (diff === 1) {
-      n = n + Pad.DIGIT;
-    } else if (diff === 2) {
-      n = n + Pad.TWO_DIGITS;
-    } else if (diff === 3) {
-      n = n + Pad.THREE_DIGITS;
-    }
-  } else {
-    if (diff < 0) {
-      n = n.slice(0, dp);
-      len = dp;
-    }
-
-    if (Pad === Space && n.charAt(len - 1) === "0") {
-      n = n.replace(/0+$/, "");
-      return pad(n, dp, Pad);
-    }
-  }
-  return n;
-}
-
-export function roundDecimal(
-  value?: number,
-  align = Align.Right,
-  decimals = 4,
-  zeroPad?: boolean,
-  alignOnDecimals?: boolean
-) {
-  if (value === undefined || typeof value !== "number" || isNaN(value)) {
-    return "";
-  }
-  let integral, fraction, Pad;
-
-  const [part1, part2 = ""] = value.toString().split(".");
-  const actualDecimals = part2.length;
-
-  integral = parseFloat(part1).toLocaleString();
-
-  if (align === Align.Left && alignOnDecimals) {
-    integral = padLeft(integral);
-  }
-
-  if (decimals === DECIMALS_AUTO || actualDecimals === decimals) {
-    fraction = part2;
-  } else if (actualDecimals > decimals) {
-    fraction = parseFloat("0." + part2)
-      .toFixed(decimals)
-      .slice(2);
-  } else {
-    /* eslint-disable no-cond-assign */
-    if (
-      (Pad = zeroPad
-        ? Zero
-        : alignOnDecimals && align !== Align.Left
-        ? Space
-        : null)
-    ) {
-      if (actualDecimals === 0) {
-        fraction = Pad.FULL_PADDING[decimals];
-      } else {
-        fraction = pad(part2, decimals, Pad);
-      }
-    } else {
-      fraction = part2;
-    }
-  }
-
-  return integral + (fraction ? "." + fraction : "");
-}

package/src/row-utils.ts

@@ -1,44 +0,0 @@
-export type RowIndex = {
-  [field: string]: number;
-}
-
-// TODO
-export type Row = {
-  [strKey: string]: any;
-} & any[];
-
-export function addRowsToIndex(rows: Row[], index: RowIndex, indexField: string) {
-  for (let idx = 0, len = rows.length; idx < len; idx++) {
-    index[rows[idx][indexField]] = idx;
-  }
-  return index;
-}
-
-export function indexRows(rows: Row[], indexField: string) {
-  return addRowsToIndex(rows, {}, indexField);
-}
-
-export function isEmptyRow(row: Row) {
-  return row[0] === undefined;
-}
-
-// TODO rename
-export function update(rows: Row[], updates: any) { // TODO
-  const results = rows.slice();
-  const [[offsetIdx]] = rows;
-  for (let i = 0; i < updates.length; i++) {
-    const idx = updates[i][0] - offsetIdx;
-    // slow, refactor for performance
-    if (rows[idx]) {
-      const row = rows[idx].slice();
-      for (let j = 1; j < updates[i].length; j += 3) {
-        row[updates[i][j]] = updates[i][j + 2];
-      }
-      results[idx] = row;
-    } else {
-      console.log(`row not found in rows`);
-    }
-  }
-
-  return results;
-}

package/src/text-utils.ts

@@ -1,9 +0,0 @@
-export const lastWord = (text: string): string => {
-  const trimmedText = text.trim();
-  const pos = trimmedText.lastIndexOf(' ');
-  if (pos === -1) {
-    return trimmedText;
-  } else {
-    return trimmedText.slice(pos + 1);
-  }
-};