wunderbaum 0.0.1-0

package/src/common.ts

@@ -0,0 +1,198 @@
+/*!
+ * Wunderbaum - common
+ * Copyright (c) 2021-2022, Martin Wendt. Released under the MIT license.
+ * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
+ */
+
+import { escapeRegex } from "./util";
+import { WunderbaumNode } from "./wb_node";
+import { Wunderbaum } from "./wunderbaum";
+
+// export type WunderbaumOptions = any;
+export type MatcherType = (node: WunderbaumNode) => boolean;
+export type BoolOptionResolver = (node: WunderbaumNode) => boolean;
+
+export const DEFAULT_DEBUGLEVEL = 4; // Replaced by rollup script
+export const ROW_HEIGHT = 22;
+export const ICON_WIDTH = 20;
+export const ROW_EXTRA_PAD = 7; // 2x $col-padding-x + 3px rounding errors
+export const RENDER_MIN_PREFETCH = 5;
+export const RENDER_MAX_PREFETCH = 5;
+export const TEST_IMG = new RegExp(/\.|\//); // strings are considered image urls if they contain '.' or '/'
+// export const RECURSIVE_REQUEST_ERROR = "$recursive_request";
+// export const INVALID_REQUEST_TARGET_ERROR = "$request_target_invalid";
+
+export type NodeAnyCallback = (node: WunderbaumNode) => any;
+
+export type NodeVisitResponse = "skip" | boolean | void;
+export type NodeVisitCallback = (node: WunderbaumNode) => NodeVisitResponse;
+
+// type WithWildcards<T> = T & { [key: string]: unknown };
+export type WbEventType = {
+  name: string;
+  event: Event;
+  tree: Wunderbaum;
+  // node?: WunderbaumNode;
+  [key: string]: unknown;
+};
+export type WbNodeEventType = WbEventType & {
+  node: WunderbaumNode;
+};
+
+export type WbCallbackType = (e: WbEventType) => any;
+export type WbNodeCallbackType = (e: WbNodeEventType) => any;
+
+export type FilterModeType = null | "dim" | "hide";
+export type ApplyCommandType =
+  | "moveUp"
+  | "moveDown"
+  | "indent"
+  | "outdent"
+  | "remove"
+  | "rename"
+  | "addChild"
+  | "addSibling"
+  | "cut"
+  | "copy"
+  | "paste"
+  | "down"
+  | "first"
+  | "last"
+  | "left"
+  | "pageDown"
+  | "pageUp"
+  | "parent"
+  | "right"
+  | "up";
+export type NodeFilterResponse = "skip" | "branch" | boolean | void;
+export type NodeFilterCallback = (node: WunderbaumNode) => NodeFilterResponse;
+
+export type AddNodeType = "before" | "after" | "prependChild" | "appendChild";
+
+export type DndModeType = "before" | "after" | "over";
+
+export enum ChangeType {
+  any = "any",
+  row = "row",
+  structure = "structure",
+  status = "status",
+}
+
+export enum NodeStatusType {
+  ok = "ok",
+  loading = "loading",
+  error = "error",
+  noData = "noData",
+  // paging = "paging",
+}
+
+/**Define the subregion of a node, where an event occurred. */
+export enum TargetType {
+  unknown = "",
+  checkbox = "checkbox",
+  column = "column",
+  expander = "expander",
+  icon = "icon",
+  prefix = "prefix",
+  title = "title",
+}
+
+export let iconMap = {
+  error: "bi bi-exclamation-triangle",
+  // loading: "bi bi-hourglass-split",
+  loading: "bi bi-arrow-repeat wb-spin",
+  // loading: '<div class="spinner-border spinner-border-sm" role="status"> <span class="visually-hidden">Loading...</span> </div>',
+  // noData: "bi bi-search",
+  noData: "bi bi-question-circle",
+  expanderExpanded: "bi bi-chevron-down",
+  // expanderExpanded: "bi bi-dash-square",
+  expanderCollapsed: "bi bi-chevron-right",
+  // expanderCollapsed: "bi bi-plus-square",
+  expanderLazy: "bi bi-chevron-right wb-helper-lazy-expander",
+  // expanderLazy: "bi bi-chevron-bar-right",
+  checkChecked: "bi bi-check-square",
+  checkUnchecked: "bi bi-square",
+  checkUnknown: "bi dash-square-dotted",
+  radioChecked: "bi bi-circle-fill",
+  radioUnchecked: "bi bi-circle",
+  radioUnknown: "bi bi-circle-dotted",
+  folder: "bi bi-folder2",
+  folderOpen: "bi bi-folder2-open",
+  doc: "bi bi-file-earmark",
+};
+
+export const KEY_NODATA = "__not_found__";
+
+export enum NavigationModeOption {
+  startRow = "startRow", // Start with row mode, but allow cell-nav mode
+  cell = "cell", // Cell-nav mode only
+  startCell = "startCell", // Start in cell-nav mode, but allow row mode
+  row = "row", // Row mode only
+}
+
+export enum NavigationMode {
+  row = "row",
+  cellNav = "cellNav",
+  cellEdit = "cellEdit",
+}
+
+/** Define which keys are handled by embedded <input> control, and should
+ * *not* be passed to tree navigation handler in cell-edit mode: */
+export const INPUT_KEYS = {
+  text: ["left", "right", "home", "end", "backspace"],
+  number: ["up", "down", "left", "right", "home", "end", "backspace"],
+  checkbox: [],
+  link: [],
+  radiobutton: ["up", "down"],
+  "select-one": ["up", "down"],
+  "select-multiple": ["up", "down"],
+};
+
+/** Key codes that trigger grid navigation, even when inside an input element. */
+export const NAVIGATE_IN_INPUT_KEYS: Set<string> = new Set([
+  "ArrowDown",
+  "ArrowUp",
+  "Enter",
+  "Escape",
+]);
+
+/** Map `KeyEvent.key` to navigation action. */
+export const KEY_TO_ACTION_DICT: { [key: string]: string } = {
+  " ": "toggleSelect",
+  "+": "expand",
+  Add: "expand",
+  ArrowDown: "down",
+  ArrowLeft: "left",
+  ArrowRight: "right",
+  ArrowUp: "up",
+  Backspace: "parent",
+  "/": "collapseAll",
+  Divide: "collapseAll",
+  End: "lastCol",
+  Home: "firstCol",
+  "Control+End": "last",
+  "Control+Home": "first",
+  "*": "expandAll",
+  Multiply: "expandAll",
+  PageDown: "pageDown",
+  PageUp: "pageUp",
+  "-": "collapse",
+  Subtract: "collapse",
+};
+
+/** */
+export function makeNodeTitleMatcher(s: string): MatcherType {
+  s = escapeRegex(s.toLowerCase());
+  return function (node: WunderbaumNode) {
+    return node.title.toLowerCase().indexOf(s) >= 0;
+  };
+}
+
+/** */
+export function makeNodeTitleStartMatcher(s: string): MatcherType {
+  s = escapeRegex(s);
+  const reMatch = new RegExp("^" + s, "i");
+  return function (node: WunderbaumNode) {
+    return reMatch.test(node.title);
+  };
+}

package/src/debounce.ts

@@ -0,0 +1,365 @@
+/*!
+ * debounce & throttle, taken from https://github.com/lodash/lodash v4.17.21
+ * MIT License: https://raw.githubusercontent.com/lodash/lodash/4.17.21-npm/LICENSE
+ * Modified for TypeScript type annotations.
+ */
+
+/* --- Custom defiitions for TypeScript --- */
+type Procedure = (...args: any[]) => any;
+
+type DebounceOptions = {
+  leading?: boolean;
+  maxWait?: number;
+  trailing?: boolean;
+};
+
+type ThrottleOptions = {
+  leading?: boolean;
+  trailing?: boolean;
+};
+
+export interface DebouncedFunction<F extends Procedure> {
+  (this: ThisParameterType<F>, ...args: Parameters<F>): ReturnType<F>;
+  cancel: () => void;
+  flush: () => any;
+  pending: () => boolean;
+}
+
+/* --- */
+/** Detect free variable `global` from Node.js. */
+const freeGlobal =
+  typeof global === "object" &&
+  global !== null &&
+  global.Object === Object &&
+  global;
+
+/** Detect free variable `globalThis` */
+const freeGlobalThis =
+  typeof globalThis === "object" &&
+  globalThis !== null &&
+  globalThis.Object == Object &&
+  globalThis;
+
+/** Detect free variable `self`. */
+const freeSelf =
+  typeof self === "object" && self !== null && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+const root =
+  freeGlobalThis || freeGlobal || freeSelf || Function("return this")();
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * isObject({})
+ * // => true
+ *
+ * isObject([1, 2, 3])
+ * // => true
+ *
+ * isObject(Function)
+ * // => true
+ *
+ * isObject(null)
+ * // => false
+ */
+function isObject(value: any) {
+  const type = typeof value;
+  return value != null && (type === "object" || type === "function");
+}
+
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked, or until the next browser frame is drawn. The debounced function
+ * comes with a `cancel` method to cancel delayed `func` invocations and a
+ * `flush` method to immediately invoke them. Provide `options` to indicate
+ * whether `func` should be invoked on the leading and/or trailing edge of the
+ * `wait` timeout. The `func` is invoked with the last arguments provided to the
+ * debounced function. Subsequent calls to the debounced function return the
+ * result of the last `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
+ * invocation will be deferred until the next frame is drawn (typically about
+ * 16ms).
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `debounce` and `throttle`.
+ *
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0]
+ *  The number of milliseconds to delay; if omitted, `requestAnimationFrame` is
+ *  used (if available).
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', debounce(calculateLayout, 150))
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', debounce(sendMail, 300, {
+ *   'leading': true,
+ *   'trailing': false
+ * }))
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * const debounced = debounce(batchLog, 250, { 'maxWait': 1000 })
+ * const source = new EventSource('/stream')
+ * jQuery(source).on('message', debounced)
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel)
+ *
+ * // Check for pending invocations.
+ * const status = debounced.pending() ? "Pending..." : "Ready"
+ */
+export function debounce<F extends Procedure>(
+  func: F,
+  wait = 0,
+  options: DebounceOptions = {}
+): DebouncedFunction<F> {
+  let lastArgs: any,
+    lastThis: any,
+    maxWait: number | undefined,
+    result: any,
+    timerId: number | undefined,
+    lastCallTime: number | undefined;
+
+  let lastInvokeTime = 0;
+  let leading = false;
+  let maxing = false;
+  let trailing = true;
+
+  // Bypass `requestAnimationFrame` by explicitly setting `wait=0`.
+  const useRAF =
+    !wait && wait !== 0 && typeof root.requestAnimationFrame === "function";
+
+  if (typeof func !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  wait = +wait || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? Math.max(+options.maxWait! || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+
+  function invokeFunc(time: number) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+
+    lastArgs = lastThis = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+
+  function startTimer(pendingFunc: any, wait: number) {
+    if (useRAF) {
+      root.cancelAnimationFrame(timerId);
+      return root.requestAnimationFrame(pendingFunc);
+    }
+    return setTimeout(pendingFunc, wait);
+  }
+
+  function cancelTimer(id: number) {
+    if (useRAF) {
+      return root.cancelAnimationFrame(id);
+    }
+    clearTimeout(id);
+  }
+
+  function leadingEdge(time: number) {
+    // Reset any `maxWait` timer.
+    lastInvokeTime = time;
+    // Start the timer for the trailing edge.
+    timerId = startTimer(timerExpired, wait);
+    // Invoke the leading edge.
+    return leading ? invokeFunc(time) : result;
+  }
+
+  function remainingWait(time: number) {
+    const timeSinceLastCall = time - lastCallTime!;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+
+    return maxing
+      ? Math.min(timeWaiting, maxWait! - timeSinceLastInvoke)
+      : timeWaiting;
+  }
+
+  function shouldInvoke(time: number) {
+    const timeSinceLastCall = time - lastCallTime!;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+
+    // Either this is the first call, activity has stopped and we're at the
+    // trailing edge, the system time has gone backwards and we're treating
+    // it as the trailing edge, or we've hit the `maxWait` limit.
+    return (
+      lastCallTime === undefined ||
+      timeSinceLastCall >= wait ||
+      timeSinceLastCall < 0 ||
+      (maxing && timeSinceLastInvoke >= maxWait!)
+    );
+  }
+
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    // Restart the timer.
+    timerId = startTimer(timerExpired, remainingWait(time));
+  }
+
+  function trailingEdge(time: number) {
+    timerId = undefined;
+
+    // Only invoke if we have `lastArgs` which means `func` has been
+    // debounced at least once.
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+
+  function cancel() {
+    if (timerId !== undefined) {
+      cancelTimer(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(Date.now());
+  }
+
+  function pending() {
+    return timerId !== undefined;
+  }
+
+  function debounced(this: any, ...args: any[]) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        // Handle invocations in a tight loop.
+        timerId = startTimer(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      timerId = startTimer(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  debounced.pending = pending;
+  return debounced;
+}
+
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds (or once per browser frame). The throttled function
+ * comes with a `cancel` method to cancel delayed `func` invocations and a
+ * `flush` method to immediately invoke them. Provide `options` to indicate
+ * whether `func` should be invoked on the leading and/or trailing edge of the
+ * `wait` timeout. The `func` is invoked with the last arguments provided to the
+ * throttled function. Subsequent calls to the throttled function return the
+ * result of the last `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the throttled function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
+ * invocation will be deferred until the next frame is drawn (typically about
+ * 16ms).
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `throttle` and `debounce`.
+ *
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to throttle.
+ * @param {number} [wait=0]
+ *  The number of milliseconds to throttle invocations to; if omitted,
+ *  `requestAnimationFrame` is used (if available).
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=true]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // Avoid excessively updating the position while scrolling.
+ * jQuery(window).on('scroll', throttle(updatePosition, 100))
+ *
+ * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
+ * const throttled = throttle(renewToken, 300000, { 'trailing': false })
+ * jQuery(element).on('click', throttled)
+ *
+ * // Cancel the trailing throttled invocation.
+ * jQuery(window).on('popstate', throttled.cancel)
+ */
+export function throttle<F extends Procedure>(
+  func: F,
+  wait = 0,
+  options: ThrottleOptions = {}
+) {
+  let leading = true;
+  let trailing = true;
+
+  if (typeof func !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  if (isObject(options)) {
+    leading = "leading" in options ? !!options.leading : leading;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  return debounce(func, wait, {
+    leading,
+    trailing,
+    maxWait: wait,
+  });
+}

package/src/deferred.ts

@@ -0,0 +1,50 @@
+/*!
+ * Wunderbaum - deferred
+ * Copyright (c) 2021-2022, Martin Wendt. Released under the MIT license.
+ * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
+ */
+
+type PromiseCallbackType = (val: any) => void;
+type finallyCallbackType = () => void;
+
+/**
+ * Deferred is a ES6 Promise, that exposes the resolve() and reject()` method.
+ *
+ * Loosely mimics [`jQuery.Deferred`](https://api.jquery.com/category/deferred-object/).
+ */
+export class Deferred {
+  private _promise: Promise<any>;
+  protected _resolve: any;
+  protected _reject: any;
+
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  /** Resolve the [[Promise]]. */
+  resolve(value?: any) {
+    this._resolve(value);
+  }
+  /** Reject the [[Promise]]. */
+  reject(reason?: any) {
+    this._reject(reason);
+  }
+  /** Return the native [[Promise]] instance.*/
+  promise() {
+    return this._promise;
+  }
+  /** Call [[Promise.then]] on the embedded promise instance.*/
+  then(cb: PromiseCallbackType) {
+    return this._promise.then(cb);
+  }
+  /** Call [[Promise.catch]] on the embedded promise instance.*/
+  catch(cb: PromiseCallbackType) {
+    return this._promise.catch(cb);
+  }
+  /** Call [[Promise.finally]] on the embedded promise instance.*/
+  finally(cb: finallyCallbackType) {
+    return this._promise.finally(cb);
+  }
+}