@vuu-ui/vuu-utils 0.5.0 → 0.5.1

package/cjs/index.js

@@ -0,0 +1,561 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ASC: () => ASC,
+  DOWN1: () => DOWN1,
+  DOWN2: () => DOWN2,
+  DSC: () => DSC,
+  DataTypes: () => DataTypes,
+  DataWindow: () => DataWindow,
+  EventEmitter: () => EventEmitter,
+  UP1: () => UP1,
+  UP2: () => UP2,
+  WindowRange: () => WindowRange,
+  addRowsToIndex: () => addRowsToIndex,
+  arrayOfIndices: () => arrayOfIndices,
+  buildColumnMap: () => buildColumnMap,
+  formatDate: () => formatDate,
+  getFullRange: () => getFullRange,
+  getMovingValueDirection: () => getMovingValueDirection,
+  getUniqueId: () => getUniqueId,
+  indexRows: () => indexRows,
+  invariant: () => invariant,
+  isCharacterKey: () => isCharacterKey,
+  isEmptyRow: () => isEmptyRow,
+  isKeyedColumn: () => isKeyedColumn,
+  isQuoteKey: () => isQuoteKey,
+  isValidNumber: () => isValidNumber,
+  lastWord: () => lastWord,
+  mapSortCriteria: () => mapSortCriteria,
+  metadataKeys: () => metadataKeys,
+  partition: () => partition,
+  projectColumns: () => projectColumns,
+  projectUpdates: () => projectUpdates,
+  resetRange: () => resetRange,
+  toColumnDescriptor: () => toColumnDescriptor,
+  toKeyedColumn: () => toKeyedColumn,
+  update: () => update,
+  uuid: () => uuid
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/event-emitter.ts
+function isArrayOfListeners(listeners) {
+  return Array.isArray(listeners);
+}
+function isOnlyListener(listeners) {
+  return !Array.isArray(listeners);
+}
+var EventEmitter = class {
+  _events;
+  constructor() {
+    this._events = {};
+  }
+  addListener(type, listener) {
+    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, listener) {
+    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) {
+    if (!this._events) {
+      return;
+    } else if (type === void 0) {
+      delete this._events;
+    } else {
+      delete this._events[type];
+    }
+  }
+  emit(type, ...args) {
+    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, listener) {
+    const handler = (evtName, message) => {
+      this.removeListener(evtName, handler);
+      listener(evtName, message);
+    };
+    this.on(type, handler);
+  }
+  on(type, listener) {
+    return this.addListener(type, listener);
+  }
+};
+function invokeHandler(handler, type, args) {
+  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;
+      default:
+        handler.call(null, type, ...args);
+    }
+  }
+}
+
+// src/array-utils.ts
+function arrayOfIndices(length2) {
+  const result = Array(length2);
+  for (let i = 0; i < length2; i++) {
+    result[i] = i;
+  }
+  return result;
+}
+function partition(array, test, pass = [], fail = []) {
+  for (let i = 0, len = array.length; i < len; i++) {
+    (test(array[i], i) ? pass : fail).push(array[i]);
+  }
+  return [pass, fail];
+}
+
+// src/column-utils.ts
+var SORT_ASC = "asc";
+function mapSortCriteria(sortCriteria, columnMap, metadataOffset = 0) {
+  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");
+    }
+  });
+}
+function isKeyedColumn(column) {
+  return typeof column.key === "number";
+}
+var toColumnDescriptor = (name) => ({
+  name
+});
+var toKeyedColumn = (column, key) => {
+  if (typeof column === "string") {
+    return { key, name: column };
+  }
+  if (isKeyedColumn(column)) {
+    return column;
+  }
+  return { ...column, key };
+};
+var EMPTY_COLUMN_MAP = {};
+function buildColumnMap(columns) {
+  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;
+    }, {});
+  } else {
+    return EMPTY_COLUMN_MAP;
+  }
+}
+function projectUpdates(updates) {
+  const results = [];
+  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;
+}
+function projectColumns(tableRowColumnMap, columns) {
+  const columnCount = columns.length;
+  const { IDX, RENDER_IDX, DEPTH, COUNT, KEY: KEY2, SELECTED, count } = metadataKeys;
+  return (startIdx, offset, selectedRows = []) => (row, i) => {
+    const baseRowIdx = row[IDX];
+    const out = [];
+    for (let i2 = 0; i2 < columnCount; i2++) {
+      const colIdx = tableRowColumnMap[columns[i2].name];
+      out[count + i2] = row[colIdx];
+    }
+    out[IDX] = startIdx + i + offset;
+    out[RENDER_IDX] = 0;
+    out[DEPTH] = 0;
+    out[COUNT] = 0;
+    out[KEY2] = row[tableRowColumnMap.KEY];
+    out[SELECTED] = selectedRows.includes(baseRowIdx) ? 1 : 0;
+    return out;
+  };
+}
+var metadataKeys = {
+  IDX: 0,
+  RENDER_IDX: 1,
+  IS_LEAF: 2,
+  IS_EXPANDED: 3,
+  DEPTH: 4,
+  COUNT: 5,
+  KEY: 6,
+  SELECTED: 7,
+  count: 8,
+  PARENT_IDX: "parent_idx",
+  IDX_POINTER: "idx_pointer",
+  FILTER_COUNT: "filter_count",
+  NEXT_FILTER_IDX: "next_filter_idx"
+};
+
+// src/range-utils.ts
+function getFullRange({ from, to }, bufferSize = 0, rowCount = Number.MAX_SAFE_INTEGER) {
+  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 };
+    }
+  }
+}
+function resetRange({ from, to, bufferSize = 0 }) {
+  return {
+    from: 0,
+    to: to - from,
+    bufferSize,
+    reset: true
+  };
+}
+var WindowRange = class {
+  from;
+  to;
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+  }
+  isWithin(index) {
+    return index >= this.from && index < this.to;
+  }
+  overlap(from, to) {
+    return from >= this.to || to < this.from ? [0, 0] : [Math.max(from, this.from), Math.min(to, this.to)];
+  }
+  copy() {
+    return new WindowRange(this.from, this.to);
+  }
+};
+
+// src/DataWindow.ts
+var { KEY } = metadataKeys;
+var log = (message) => console.log(`%c[DataWindow] ${message}`, "color: purple;font-weight: bold;");
+var DataWindow = class {
+  range;
+  data;
+  rowCount = 0;
+  constructor({ from, to }) {
+    log(`constructor ${from} - ${to}`);
+    this.range = new WindowRange(from, to);
+    this.data = new Array(to - from);
+  }
+  setRowCount = (rowCount) => {
+    if (rowCount < this.data.length) {
+      this.data.length = rowCount;
+    }
+    this.rowCount = rowCount;
+  };
+  add(data) {
+    const [index] = data;
+    if (this.isWithinRange(index)) {
+      const internalIndex = index - this.range.from;
+      const isUpdate = this.data[internalIndex] !== void 0;
+      this.data[internalIndex] = data;
+      return isUpdate;
+    } else {
+      return false;
+    }
+  }
+  getAtIndex(index) {
+    return this.range.isWithin(index) && this.data[index - this.range.from] != null ? this.data[index - this.range.from] : void 0;
+  }
+  getByKey(key) {
+    return this.data.find((row) => row[KEY] === key);
+  }
+  isWithinRange(index) {
+    return this.range.isWithin(index) && index <= this.rowCount;
+  }
+  setRange(from, to) {
+    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, to) {
+    const offset = this.range.from;
+    const start = from - offset;
+    const end = Math.min(to - offset - 1, this.rowCount - 1);
+    return this.data[start] !== void 0 && this.data[end] !== void 0;
+  }
+  getData(from, to) {
+    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);
+  }
+};
+
+// src/data-utils.ts
+var UP1 = "up1";
+var UP2 = "up2";
+var DOWN1 = "down1";
+var DOWN2 = "down2";
+var isValidNumber = (n) => typeof n === "number" && isFinite(n);
+function getMovingValueDirection(newValue, direction, prevValue, decimalPlaces) {
+  if (!isFinite(newValue) || prevValue === void 0 || direction === void 0) {
+    return "";
+  } else {
+    let diff = newValue - prevValue;
+    if (diff) {
+      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 "";
+    }
+  }
+}
+
+// src/date-utils.ts
+var formatDate = (date, format) => {
+  return date.toUTCString();
+};
+
+// src/getUniqueId.ts
+var getUniqueId = () => `hw-${Math.round(Math.random() * 1e5)}`;
+
+// src/input-utils.ts
+var actionKeys = {
+  Enter: "Enter",
+  Delete: "Delete"
+};
+var navigationKeys = {
+  Home: "Home",
+  End: "End",
+  ArrowRight: "ArrowRight",
+  ArrowLeft: "ArrowLeft",
+  ArrowDown: "ArrowDown",
+  ArrowUp: "ArrowUp",
+  Tab: "Tab"
+};
+var 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"
+};
+var specialKeys = {
+  ...actionKeys,
+  ...navigationKeys,
+  ...functionKeys
+};
+var isSpecialKey = (key) => key in specialKeys;
+var isCharacterKey = (evt) => {
+  if (isSpecialKey(evt.key)) {
+    return false;
+  }
+  if (typeof evt.which === "number" && evt.which > 0) {
+    return !evt.ctrlKey && !evt.metaKey && !evt.altKey && evt.which !== 8;
+  }
+};
+var isQuoteKey = (evt) => {
+  return evt.key === '"' || evt.key === "'";
+};
+
+// src/invariant.ts
+function invariant(condition, message) {
+  if (!condition) {
+    const error = new Error(message);
+    error.name = "Invariant Violation";
+    error.framesToPop = 1;
+    throw error;
+  }
+}
+
+// src/nanoid/index.ts
+var uuid = (size = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size));
+  while (size--) {
+    let byte = bytes[size] & 63;
+    if (byte < 36) {
+      id += byte.toString(36);
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase();
+    } else if (byte < 63) {
+      id += "_";
+    } else {
+      id += "-";
+    }
+  }
+  return id;
+};
+
+// src/constants.ts
+var DataTypes = {
+  ROW_DATA: "rowData",
+  FILTER_DATA: "filterData",
+  FILTER_BINS: "filterBins"
+};
+var ASC = "asc";
+var DSC = "dsc";
+
+// src/row-utils.ts
+function addRowsToIndex(rows, index, indexField) {
+  for (let idx = 0, len = rows.length; idx < len; idx++) {
+    index[rows[idx][indexField]] = idx;
+  }
+  return index;
+}
+function indexRows(rows, indexField) {
+  return addRowsToIndex(rows, {}, indexField);
+}
+function isEmptyRow(row) {
+  return row[0] === void 0;
+}
+function update(rows, updates) {
+  const results = rows.slice();
+  const [[offsetIdx]] = rows;
+  for (let i = 0; i < updates.length; i++) {
+    const idx = updates[i][0] - offsetIdx;
+    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;
+}
+
+// src/text-utils.ts
+var lastWord = (text) => {
+  const trimmedText = text.trim();
+  const pos = trimmedText.lastIndexOf(" ");
+  if (pos === -1) {
+    return trimmedText;
+  } else {
+    return trimmedText.slice(pos + 1);
+  }
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuu-ui/vuu-utils",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "author": "heswell",
   "license": "Apache-2.0",
   "scripts": {
@@ -18,5 +18,6 @@
     "index.js.map",
     "/src"
   ],
-  "module": "esm/index.js"
+  "module": "esm/index.js",
+  "main": "cjs/index.js"
 }

package/src/index.ts

@@ -11,5 +11,4 @@ export * from "./nanoid";
 export * from "./constants";
 export * from "./range-utils";
 export * from "./row-utils";
-export * from "./simple-store";
 export * from "./text-utils";

package/src/simple-store.ts

@@ -1,33 +0,0 @@
-// intended use is singleton storage atom within a hook, see useViewserver for examples
-import { EventEmitter } from "./event-emitter";
-
-type StoreStatus = "" | "ready" | "loaded" | "loading";
-
-export class SimpleStore<T = unknown> extends EventEmitter {
-  private _value: T;
-  private _status: StoreStatus = "";
-
-  constructor(value: T, status: StoreStatus = "") {
-    super();
-    this._value = value;
-    this._status = status;
-  }
-
-  set value(value: T) {
-    this._value = value;
-    this._status = "ready";
-    this.emit("loaded", value);
-  }
-
-  get value(): T {
-    return this._value;
-  }
-
-  set status(status: StoreStatus) {
-    this._status = status;
-  }
-
-  get status() {
-    return this._status;
-  }
-}