wunderbaum 0.0.7 → 0.0.8

package/src/common.ts

@@ -4,8 +4,8 @@
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 
-import { MatcherType } from "./types";
-import { escapeRegex } from "./util";
+import { MatcherCallback } from "./types";
+import * as util from "./util";
 import { WunderbaumNode } from "./wb_node";
 
 export const DEFAULT_DEBUGLEVEL = 4; // Replaced by rollup script
@@ -66,7 +66,8 @@ export const iconMap = {
 export const KEY_NODATA = "__not_found__";
 
 /** Define which keys are handled by embedded <input> control, and should
- * *not* be passed to tree navigation handler in cell-edit mode. */
+ * *not* be passed to tree navigation handler in cell-edit mode.
+ */
 export const INPUT_KEYS: { [key: string]: Array<string> } = {
   text: ["left", "right", "home", "end", "backspace"],
   number: ["up", "down", "left", "right", "home", "end", "backspace"],
@@ -79,14 +80,14 @@ export const INPUT_KEYS: { [key: string]: Array<string> } = {
 
 /** Dict keys that are evaluated by source loader (others are added to `tree.data` instead). */
 export const RESERVED_TREE_SOURCE_KEYS: Set<string> = new Set([
+  "_format", // reserved for future use
+  "_keyMap", // reserved for future use
+  "_positional", // reserved for future use
+  "_typeList", // reserved for future use
+  "_version", // reserved for future use
   "children",
   "columns",
-  "format", // reserved for future use
-  "keyMap", // reserved for future use
-  "positional", // reserved for future use
-  "typeList", // reserved for future use
   "types",
-  "version", // reserved for future use
 ]);
 
 // /** Key codes that trigger grid navigation, even when inside an input element. */
@@ -123,19 +124,160 @@ export const KEY_TO_ACTION_DICT: { [key: string]: string } = {
   Subtract: "collapse",
 };
 
-/** Return a callback that returns true if the node title contains a substring (case-insensitive). */
-export function makeNodeTitleMatcher(s: string): MatcherType {
-  s = escapeRegex(s.toLowerCase());
+/** Return a callback that returns true if the node title matches the string
+ * or regular expression.
+ * @see {@link WunderbaumNode.findAll}
+ */
+export function makeNodeTitleMatcher(match: string | RegExp): MatcherCallback {
+  if (match instanceof RegExp) {
+    return function (node: WunderbaumNode) {
+      return (<RegExp>match).test(node.title);
+    };
+  }
+  util.assert(typeof match === "string");
+
+  // s = escapeRegex(s.toLowerCase());
   return function (node: WunderbaumNode) {
-    return node.title.toLowerCase().indexOf(s) >= 0;
+    return node.title === match;
+    // console.log("match " + node, node.title.toLowerCase().indexOf(match))
+    // return node.title.toLowerCase().indexOf(match) >= 0;
   };
 }
 
 /** Return a callback that returns true if the node title starts with a string (case-insensitive). */
-export function makeNodeTitleStartMatcher(s: string): MatcherType {
-  s = escapeRegex(s);
+export function makeNodeTitleStartMatcher(s: string): MatcherCallback {
+  s = util.escapeRegex(s);
   const reMatch = new RegExp("^" + s, "i");
   return function (node: WunderbaumNode) {
     return reMatch.test(node.title);
   };
 }
+
+function unflattenSource(source: any): void {
+  const { _format, _keyMap, _positional, children } = source;
+
+  if (_format !== "flat") {
+    throw new Error(`Expected source._format: "flat", but got ${_format}`);
+  }
+  if (_positional && _positional.includes("children")) {
+    throw new Error(
+      `source._positional must not include "children": ${_positional}`
+    );
+  }
+  // Inverse keyMap:
+  let longToShort: any = {};
+  if (_keyMap) {
+    for (const [key, value] of Object.entries(_keyMap)) {
+      longToShort[<string>value] = key;
+    }
+  }
+  const positionalShort = _positional.map((e: string) => longToShort[e]);
+  const newChildren: any[] = [];
+  const keyToNodeMap: { [key: string]: number } = {};
+  const indexToNodeMap: { [key: number]: any } = {};
+  const keyAttrName = longToShort["key"] ?? "key";
+  const childrenAttrName = longToShort["children"] ?? "children";
+
+  for (const [index, node] of children.entries()) {
+    // Node entry format:
+    //   [PARENT_ID, [POSITIONAL_ARGS]]
+    // or
+    //   [PARENT_ID, [POSITIONAL_ARGS], {KEY_VALUE_ARGS}]
+    const [parentId, args, kwargs = {}] = node;
+
+    // Free up some memory as we go
+    node[1] = null;
+    if (node[2] != null) {
+      node[2] = null;
+    }
+    // console.log("flatten", parentId, args, kwargs)
+
+    // We keep `kwargs` as our new node definition. Then we add all positional
+    // values to this object:
+    args.forEach((val: string, positionalIdx: number) => {
+      kwargs[positionalShort[positionalIdx]] = val;
+    });
+
+    // Find the parent node. `null` means 'toplevel'. PARENT_ID may be the numeric
+    // index of the source.children list. If PARENT_ID is a string, we search
+    // a parent with node.key of this value.
+    indexToNodeMap[index] = kwargs;
+    const key = kwargs[keyAttrName];
+    if (key != null) {
+      keyToNodeMap[key] = kwargs;
+    }
+    let parentNode = null;
+    if (parentId === null) {
+      // top-level node
+    } else if (typeof parentId === "number") {
+      parentNode = indexToNodeMap[parentId];
+      if (parentNode === undefined) {
+        throw new Error(
+          `unflattenSource: Could not find parent node by index: ${parentId}.`
+        );
+      }
+    } else {
+      parentNode = keyToNodeMap[parentId];
+      if (parentNode === undefined) {
+        throw new Error(
+          `unflattenSource: Could not find parent node by key: ${parentId}`
+        );
+      }
+    }
+    if (parentNode) {
+      parentNode[childrenAttrName] ??= [];
+      parentNode[childrenAttrName].push(kwargs);
+    } else {
+      newChildren.push(kwargs);
+    }
+  }
+
+  delete source.children;
+  source.children = newChildren;
+}
+
+export function inflateSourceData(source: any): void {
+  const { _format, _keyMap, _typeList } = source;
+
+  if (_format === "flat") {
+    unflattenSource(source);
+  }
+  delete source._format;
+  delete source._version;
+  delete source._keyMap;
+  delete source._typeList;
+  delete source._positional;
+
+  function _iter(childList: any[]) {
+    for (let node of childList) {
+      // Expand short alias names
+      if (_keyMap) {
+        // Iterate over a list of names, because we modify inside the loop:
+        Object.getOwnPropertyNames(node).forEach((propName) => {
+          const long = _keyMap[propName] ?? propName;
+          if (long !== propName) {
+            node[long] = node[propName];
+            delete node[propName];
+          }
+        });
+      }
+      // `node` now has long attribute names
+
+      // Resolve node type indexes
+      const type = node.type;
+      if (_typeList && type != null && typeof type === "number") {
+        const newType = _typeList[type];
+        if (newType == null) {
+          throw new Error(`Expected typeList[${type}] entry in [${_typeList}]`);
+        }
+        node.type = newType;
+      }
+
+      // Recursion
+      if (node.children) {
+        _iter(node.children);
+      }
+    }
+  }
+  _iter(source.children);
+}

package/src/types.ts

@@ -7,9 +7,14 @@
 import { WunderbaumNode } from "./wb_node";
 import { Wunderbaum } from "./wunderbaum";
 
-// export type WunderbaumOptions = any;
-export type MatcherType = (node: WunderbaumNode) => boolean;
+/** Passed to find... methods. Should return true if node matches. */
+export type MatcherCallback = (node: WunderbaumNode) => boolean;
+/** When set as option, called when the value is needed (e.g. `colspan` type definition). */
 export type BoolOptionResolver = (node: WunderbaumNode) => boolean;
+/** When set as option, called when the value is needed (e.g. `icon` type definition). */
+export type BoolOrStringOptionResolver = (
+  node: WunderbaumNode
+) => boolean | string;
 
 export type NodeAnyCallback = (node: WunderbaumNode) => any;
 
@@ -72,13 +77,13 @@ export interface NodeTypeDefinition {
   // /** Type ID that matches `node.type`. */
   // id: string;
   /** En/disable checkbox for matching nodes.*/
-  checkbox?: boolean | BoolOptionResolver;
+  checkbox?: boolean | BoolOrStringOptionResolver;
   /** En/disable checkbox for matching nodes.*/
   colspan?: boolean | BoolOptionResolver;
   /** Optional class names that are added to all `div.wb-row` elements of matching nodes.*/
   classes?: string;
   /**Default icon for matching nodes.*/
-  icon?: boolean | string | BoolOptionResolver;
+  icon?: boolean | string | BoolOrStringOptionResolver;
   /**
    * See also {@link WunderbaumNode.getOption|WunderbaumNode.getOption()}
    * to evaluate `node.NAME` setting and `tree.types[node.type].NAME`.
@@ -215,22 +220,33 @@ export enum TargetType {
   title = "title",
 }
 
-/** Initial navigation mode and possible transition. */
-export enum NavigationOptions {
-  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
+/** Possible values for {@link WunderbaumNode.addChildren()}. */
+export interface AddChildrenOptions {
+  /** Insert children before this node (or index)
+   * @default undefined or null:  append as last child
+   */
+  before?: WunderbaumNode | number | null;
+  /**
+   * Set `node.expanded = true` according to tree.options.minExpandLevel.
+   * This does *not* load lazy nodes.
+   * @default true
+   */
+  applyMinExpanLevel?: boolean;
+  /** (@internal Internal use, do not set! ) */
+  _level?: number;
 }
 
-// /** Tree's current navigation mode (see `tree.setNavigationMode()`). */
-// export enum NavigationMode {
-//   row = "row",
-//   cellNav = "cellNav",
-//   // cellEdit = "cellEdit",
-// }
+/** Possible values for {@link Wunderbaum.expandAll()} and {@link WunderbaumNode.expandAll()}. */
+export interface ExpandAllOptions {
+  /** Restrict expand level @default 99 */
+  depth?: number;
+  /** Expand and load lazy nodes @default false  */
+  loadLazy?: boolean;
+  /** Ignore `minExpandLevel` option @default false */
+  force?: boolean;
+}
 
-/** Possible values for `node.makeVisible()`. */
+/** Possible values for {@link WunderbaumNode.makeVisible()}. */
 export interface MakeVisibleOptions {
   /** Do not animate expand (currently not implemented). @default false */
   noAnimation?: boolean;
@@ -240,7 +256,15 @@ export interface MakeVisibleOptions {
   noEvents?: boolean;
 }
 
-/** Possible values for `node.scrollIntoView()`. */
+/** Initial navigation mode and possible transition. */
+export enum NavigationOptions {
+  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
+}
+
+/** Possible values for {@link scrollIntoView()}. */
 export interface ScrollIntoViewOptions {
   /** Do not animate (currently not implemented). @default false */
   noAnimation?: boolean;
@@ -252,7 +276,7 @@ export interface ScrollIntoViewOptions {
   ofsY?: number;
 }
 
-/** Possible values for `tree.scrollTo()`. */
+/** Possible values for {@link Wunderbaum.scrollTo()}. */
 export interface ScrollToOptions extends ScrollIntoViewOptions {
   /** Which node to scroll into the viewport.*/
   node: WunderbaumNode;

package/src/util.ts

@@ -312,11 +312,16 @@ export function setValueToElem(elem: HTMLElement, value: any): void {
       case "week":
       case "datetime":
       case "datetime-local":
-        input.valueAsDate = value;
+        input.valueAsDate = new Date(value);
+        // input.valueAsDate = value;  // breaks in Edge?
         break;
       case "number":
       case "range":
-        input.valueAsNumber = value;
+        if (value == null) {
+          input.value = value;
+        } else {
+          input.valueAsNumber = value;
+        }
         break;
       case "radio":
         error("Not implemented");
@@ -333,7 +338,7 @@ export function setValueToElem(elem: HTMLElement, value: any): void {
         break;
       case "text":
       default:
-        input.value = value || "";
+        input.value = value ?? "";
     }
   } else if (tag === "SELECT") {
     const select = <HTMLSelectElement>elem;
@@ -669,7 +674,7 @@ export function toggleCheckbox(
 export function getOption(
   opts: any,
   name: string,
-  defaultValue = undefined
+  defaultValue: any = undefined
 ): any {
   let ext;