@vuu-ui/vuu-utils 0.5.3 → 0.5.5

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/index.ts

@@ -1,14 +0,0 @@
-export * from "./array-utils";
-export * from "./column-utils";
-export * from "./DataWindow";
-export * from "./data-utils";
-export * from "./date-utils";
-export * from "./event-emitter";
-export * from "./getUniqueId";
-export * from "./input-utils";
-export * from "./invariant";
-export * from "./nanoid";
-export * from "./round-decimal";
-export * from "./range-utils";
-export * from "./row-utils";
-export * from "./text-utils";

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);
-  }
-};