@vuu-ui/vuu-utils 0.0.26

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2015 UBS
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@vuu-ui/vuu-utils",
+  "version": "0.0.26",
+  "author": "heswell",
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "node ../../scripts/run-build.mjs",
+    "test": "vitest run",
+    "type-defs": "node ../../scripts/build-type-defs.mjs"
+  },
+  "devDependencies": {},
+  "peerDependencies": {
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2"
+  },
+  "files": [
+    "index.js",
+    "index.js.map",
+    "/src"
+  ],
+  "module": "esm/index.js"
+}

package/src/DataWindow.ts

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,22 @@
+export function arrayOfIndices(length: number): number[] {
+  // not the neatest, but far and away the fastest way to do this ...
+  const result = Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = i;
+  }
+  return result;
+}
+
+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];
+}

package/src/column-utils.ts

@@ -0,0 +1,133 @@
+import {
+  ColumnDescriptor,
+  KeyedColumnDescriptor,
+} from "@finos/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/constants.ts

@@ -0,0 +1,8 @@
+export const DataTypes = {
+  ROW_DATA: 'rowData',
+  FILTER_DATA: 'filterData',
+  FILTER_BINS: 'filterBins'
+};
+
+export const ASC = 'asc';
+export const DSC = 'dsc';

package/src/data-utils.ts

@@ -0,0 +1,60 @@
+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

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

package/src/event-emitter.ts

@@ -0,0 +1,139 @@
+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

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

package/src/index.ts

@@ -0,0 +1,15 @@
+export { EventEmitter } from "./event-emitter";
+export * from "./array-utils";
+export * from "./column-utils";
+export * from "./DataWindow";
+export * from "./data-utils";
+export * from "./date-utils";
+export * from "./getUniqueId";
+export * from "./input-utils";
+export * from "./invariant";
+export * from "./nanoid";
+export * from "./constants";
+export * from "./range-utils";
+export * from "./row-utils";
+export * from "./simple-store";
+export * from "./text-utils";

package/src/input-utils.ts

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,30 @@
+// 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

@@ -0,0 +1,72 @@
+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/row-utils.ts

@@ -0,0 +1,44 @@
+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/simple-store.ts

@@ -0,0 +1,33 @@
+// 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;
+  }
+}

package/src/text-utils.ts

@@ -0,0 +1,9 @@
+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);
+  }
+};