data-navigator 3.0.0 → 3.2.1

package/dist/index.cjs

@@ -86,7 +86,9 @@ __export(src_exports, {
   default: () => src_default,
   describeNode: () => describeNode,
   expandHull: () => expandHull,
+  getGenericCommandsFromNavRules: () => getGenericCommandsFromNavRules,
   grahamScan: () => grahamScan,
+  keyLabel: () => keyLabel,
   offsetLinePath: () => offsetLinePath,
   unionOfRectPaths: () => unionOfRectPaths
 });
@@ -112,9 +114,9 @@ var defaultKeyBindings = {
   Escape: "drill-out",
   Enter: "drill-in"
 };
-var TypicallyUnreservedKeys = ["KeyW", "KeyJ", "LeftBracket", "RightBracket", "Slash", "Backslash"];
+var TypicallyUnreservedKeys = ["KeyW", "KeyJ", "BracketLeft", "BracketRight", "Slash", "Backslash"];
 var TypicallyUnreservedKeyPairs = [
-  ["LeftBracket", "RightBracket"],
+  ["BracketLeft", "BracketRight"],
   ["Slash", "Backslash"]
 ];
 var GenericFullNavigationRules = {
@@ -241,6 +243,27 @@ var NodeElementDefaults = {
     spatialProperties: void 0
   }
 };
+var KeyLabels = {
+  ArrowLeft: "\u2190",
+  ArrowRight: "\u2192",
+  ArrowUp: "\u2191",
+  ArrowDown: "\u2193",
+  Enter: "Enter",
+  Backspace: "Backspace",
+  Escape: "Esc",
+  Space: "Space",
+  Tab: "Tab",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Backslash: "\\",
+  Slash: "/",
+  Comma: ",",
+  Period: ".",
+  Semicolon: ";",
+  Quote: "'",
+  Minus: "-",
+  Equal: "="
+};
 var GenericNavigationRuleCommands = {
   "drill-in": { label: "Enter", description: "Drill in" },
   "drill-out": { label: "Backspace", description: "Drill out" },
@@ -275,13 +298,423 @@ var describeNode = (d, descriptionOptions) => {
 var createValidId = (s) => {
   return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
 };
-function getGenericCommandsFromNavRules(navigationRules) {
+var keyLabel = (code) => {
+  if (!code)
+    return "";
+  return KeyLabels[code] || code.replace(/^Key/, "").replace(/^Digit/, "");
+};
+var humanizeRule = (navId) => {
+  const text = navId.replace(/[-_]+/g, " ").trim();
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+function getGenericCommandsFromNavRules(navigationRules, descriptions) {
   if (!navigationRules) {
     return [];
   }
-  return Object.keys(navigationRules).map((navId) => GenericNavigationRuleCommands[navId]).filter(Boolean);
+  return Object.keys(navigationRules).map((navId) => {
+    const rule = navigationRules[navId];
+    const generic = GenericNavigationRuleCommands[navId];
+    return {
+      label: (rule == null ? void 0 : rule.key) ? keyLabel(rule.key) : (generic == null ? void 0 : generic.label) || "",
+      description: (descriptions == null ? void 0 : descriptions[navId]) || (generic == null ? void 0 : generic.description) || humanizeRule(navId),
+      command: navId
+    };
+  });
 }
 
+// src/edge-utils.ts
+var makeEdgeCreator = (nodes, edges, useDirectedEdges) => {
+  const addEdgeToNode = (nodeId, edgeId) => {
+    const node = nodes[nodeId];
+    if (!node) {
+      console.error(`Building edges. Node ${nodeId} does not exist, so edge ${edgeId} was not added to it.`);
+      return;
+    }
+    if (!node.edges) {
+      node.edges = [];
+    }
+    if (node.edges.indexOf(edgeId) === -1) {
+      node.edges.push(edgeId);
+    }
+  };
+  return (source, target, rules, addTo) => {
+    if (!source || !target || source === target) {
+      return;
+    }
+    const id = `${source}-${target}`;
+    const targetId = !useDirectedEdges ? id : `${target}-${id}`;
+    const addToSource = !addTo || addTo === "source";
+    const addToTarget = !addTo || addTo === "target";
+    const checkEdgeRules = (eId) => {
+      if (edges[eId]) {
+        (rules || []).forEach((r) => {
+          if (edges[eId].navigationRules.indexOf(r) === -1) {
+            edges[eId].navigationRules.push(r);
+          }
+        });
+      } else {
+        edges[eId] = {
+          source,
+          target,
+          navigationRules: rules ? [...rules] : []
+        };
+      }
+    };
+    checkEdgeRules(id);
+    if (useDirectedEdges && addToTarget) {
+      checkEdgeRules(targetId);
+    }
+    if (addToSource) {
+      addEdgeToNode(source, id);
+    }
+    if (addToTarget) {
+      addEdgeToNode(target, targetId);
+    }
+  };
+};
+var chain = (createEdge, ids, rules, extents = "terminal") => {
+  for (let i = 0; i < ids.length - 1; i++) {
+    createEdge(ids[i], ids[i + 1], rules);
+  }
+  if (extents === "circular" && ids.length > 1) {
+    createEdge(ids[ids.length - 1], ids[0], rules);
+  }
+};
+
+// src/frame.ts
+var prepareFrameOptions = (options) => {
+  var _a, _b, _c;
+  const f = options.frame;
+  const dimCount = ((_b = (_a = options.dimensions) == null ? void 0 : _a.values) == null ? void 0 : _b.length) || 0;
+  if (!f || dimCount < 2 || ((_c = options.dimensions.parentOptions) == null ? void 0 : _c.addLevel0)) {
+    return options;
+  }
+  const data = f.data || { id: "data", edges: [], semantics: { label: "Data" } };
+  return __spreadProps(__spreadValues({}, options), {
+    dimensions: __spreadProps(__spreadValues({}, options.dimensions), {
+      parentOptions: __spreadProps(__spreadValues({}, options.dimensions.parentOptions || {}), {
+        addLevel0: __spreadProps(__spreadValues({}, data), { edges: data.edges || [] })
+      })
+    })
+  });
+};
+var buildFrame = (options, nodes, edges, topId) => {
+  var _a, _b, _c;
+  const f = options.frame;
+  if (!f)
+    return;
+  if (!topId || !nodes[topId]) {
+    console.error("Building frame. No top data node was found to place under the frame.");
+    return;
+  }
+  const createEdge = makeEdgeCreator(nodes, edges, options.useDirectedEdges);
+  const siblingRules = ((_a = f.navigationRules) == null ? void 0 : _a.sibling_sibling) || ["left", "right"];
+  const parentRules = ((_b = f.navigationRules) == null ? void 0 : _b.parent_child) || ["drill-out", "drill-in"];
+  const extents = ((_c = f.behavior) == null ? void 0 : _c.extents) || "circular";
+  const root = f.root;
+  nodes[root.id] = __spreadProps(__spreadValues({}, root), { edges: [...root.edges || []], depth: 0, frameRole: "root" });
+  const elementIds = (f.elements || []).map((e) => {
+    nodes[e.id] = __spreadProps(__spreadValues({}, e), {
+      edges: [...e.edges || []],
+      depth: 1,
+      parentId: root.id,
+      frameRole: "element"
+    });
+    return e.id;
+  });
+  let dataId = topId;
+  if (f.data && f.data.id !== topId) {
+    nodes[f.data.id] = __spreadProps(__spreadValues({}, f.data), { edges: [...f.data.edges || []] });
+    createEdge(f.data.id, topId, parentRules, "source");
+    createEdge(f.data.id, topId, parentRules, "target");
+    nodes[topId].parentId = f.data.id;
+    dataId = f.data.id;
+  }
+  const dataNode = nodes[dataId];
+  dataNode.frameRole = "data";
+  dataNode.depth = 1;
+  dataNode.parentId = root.id;
+  const children = [...elementIds, dataId];
+  createEdge(root.id, children[0], parentRules, "source");
+  children.forEach((c) => createEdge(root.id, c, parentRules, "target"));
+  chain(createEdge, children, siblingRules, extents);
+  return { rootId: root.id, elementIds, dataId, parentRules };
+};
+
+// src/spatial-grid.ts
+var buildSpatialGrid = (options, nodes, edges) => {
+  var _a, _b, _c;
+  const g = options.spatialGrid;
+  if (!g)
+    return;
+  const createEdge = makeEdgeCreator(nodes, edges, options.useDirectedEdges);
+  const xRules = ((_a = g.navigationRules) == null ? void 0 : _a.x) || ["left", "right"];
+  const yRules = ((_b = g.navigationRules) == null ? void 0 : _b.y) || ["up", "down"];
+  const parentRules = ((_c = g.navigationRules) == null ? void 0 : _c.parent_child) || ["drill-out", "drill-in"];
+  const extents = g.extents || "terminal";
+  const across = g.levelNavigation !== "within";
+  const skipEmpty = g.skipEmpty !== false;
+  const leafMode = g.leaves || "points";
+  const idOf = (d) => d[typeof options.idKey === "function" ? options.idKey(d) : options.idKey];
+  const rows = options.data.filter((d) => typeof d[g.xKey] === "number" && typeof d[g.yKey] === "number");
+  const ext = (key, given) => {
+    if (given)
+      return given;
+    let min = Infinity;
+    let max = -Infinity;
+    rows.forEach((d) => {
+      min = Math.min(min, d[key]);
+      max = Math.max(max, d[key]);
+    });
+    return [min, max];
+  };
+  const xExtent = ext(g.xKey, g.xExtent);
+  const yExtent = ext(g.yKey, g.yExtent);
+  const indexOf = (v, [lo, hi], n) => {
+    if (hi === lo)
+      return 0;
+    return Math.max(0, Math.min(n - 1, Math.floor((v - lo) / (hi - lo) * n)));
+  };
+  const rootDefaults = { id: "grid", edges: [], semantics: { label: "Grid" } };
+  const root = __spreadValues(__spreadValues({}, rootDefaults), g.root || {});
+  root.edges = root.edges || [];
+  root.depth = 0;
+  root.data = __spreadProps(__spreadValues({}, root.data || {}), {
+    xKey: g.xKey,
+    yKey: g.yKey,
+    xExtent,
+    yExtent,
+    levels: g.levels,
+    count: rows.length
+  });
+  nodes[root.id] = root;
+  const cellId = (level, col, row) => g.cellIds ? g.cellIds(level, col, row) : createValidId(`${root.id}_L${level}_${col}_${row}`);
+  const cellsByLevel = [];
+  g.levels.forEach((n, level) => {
+    const cells = {};
+    const add = (col, row) => {
+      const key = `${col}_${row}`;
+      if (cells[key])
+        return cells[key];
+      const id = cellId(level, col, row);
+      const xStep = (xExtent[1] - xExtent[0]) / n;
+      const yStep = (yExtent[1] - yExtent[0]) / n;
+      let parent = root.id;
+      if (level > 0) {
+        const pn = g.levels[level - 1];
+        const parentCell = cellsByLevel[level - 1][`${Math.floor(col * pn / n)}_${Math.floor(row * pn / n)}`];
+        parent = parentCell == null ? void 0 : parentCell.id;
+        parentCell == null ? void 0 : parentCell.children.push(id);
+      }
+      cells[key] = { id, col, row, parent, children: [] };
+      nodes[id] = {
+        id,
+        renderId: id,
+        edges: [],
+        depth: level + 1,
+        parentId: parent,
+        data: {
+          level,
+          col,
+          row,
+          cellsPerAxis: n,
+          xExtent: [xExtent[0] + col * xStep, xExtent[0] + (col + 1) * xStep],
+          yExtent: [yExtent[0] + row * yStep, yExtent[0] + (row + 1) * yStep],
+          count: 0
+        }
+      };
+      return cells[key];
+    };
+    if (!skipEmpty) {
+      for (let c = 0; c < n; c++)
+        for (let r = 0; r < n; r++)
+          add(c, r);
+    }
+    rows.forEach((d) => add(indexOf(d[g.xKey], xExtent, n), indexOf(d[g.yKey], yExtent, n)));
+    cellsByLevel.push(cells);
+  });
+  const finest = cellsByLevel[cellsByLevel.length - 1];
+  const fn = g.levels[g.levels.length - 1];
+  const leafIds = [];
+  const leafParent = {};
+  rows.forEach((d) => {
+    const id = idOf(d);
+    if (!nodes[id])
+      return;
+    g.levels.forEach((n, level) => {
+      const c = cellsByLevel[level][`${indexOf(d[g.xKey], xExtent, n)}_${indexOf(d[g.yKey], yExtent, n)}`];
+      nodes[c.id].data.count++;
+    });
+    const cell = finest[`${indexOf(d[g.xKey], xExtent, fn)}_${indexOf(d[g.yKey], yExtent, fn)}`];
+    cell.children.push(id);
+    leafParent[id] = cell.id;
+    leafIds.push(id);
+    nodes[id].parentId = cell.id;
+    nodes[id].depth = g.levels.length + 1;
+  });
+  const topLeftFirst = (a, b) => b.row - a.row || a.col - b.col;
+  const rootChildren = Object.values(cellsByLevel[0]).sort(topLeftFirst);
+  if (rootChildren.length)
+    createEdge(root.id, rootChildren[0].id, parentRules, "source");
+  rootChildren.forEach((c) => createEdge(root.id, c.id, parentRules, "target"));
+  const pos = (id) => nodes[id].data;
+  cellsByLevel.forEach((cells, level) => {
+    Object.values(cells).forEach((c) => {
+      if (!c.children.length)
+        return;
+      let first;
+      if (level === cellsByLevel.length - 1) {
+        first = [...c.children].sort((a, b) => leafOrderX(a, b))[0];
+      } else {
+        first = [...c.children].sort((a, b) => topLeftFirst(pos(a), pos(b)))[0];
+      }
+      createEdge(c.id, first, parentRules, "source");
+      c.children.forEach((k) => createEdge(c.id, k, parentRules, "target"));
+    });
+  });
+  const linkCells = (ids) => {
+    const byRow = {};
+    const byCol = {};
+    ids.forEach((id) => {
+      const p = pos(id);
+      (byRow[p.row] = byRow[p.row] || []).push(id);
+      (byCol[p.col] = byCol[p.col] || []).push(id);
+    });
+    Object.values(byRow).forEach(
+      (r) => chain(
+        createEdge,
+        r.sort((a, b) => pos(a).col - pos(b).col),
+        xRules,
+        extents
+      )
+    );
+    Object.values(byCol).forEach(
+      (c) => chain(
+        createEdge,
+        c.sort((a, b) => pos(b).row - pos(a).row),
+        yRules,
+        extents
+      )
+    );
+  };
+  cellsByLevel.forEach((cells, level) => {
+    const list = Object.values(cells);
+    if (across || level === 0) {
+      linkCells(list.map((c) => c.id));
+    } else {
+      const groups = {};
+      list.forEach((c) => (groups[c.parent] = groups[c.parent] || []).push(c.id));
+      Object.values(groups).forEach(linkCells);
+    }
+  });
+  function leafOrderX(a, b) {
+    const da = nodes[a].data;
+    const db = nodes[b].data;
+    return da[g.xKey] - db[g.xKey] || db[g.yKey] - da[g.yKey];
+  }
+  const leafOrderY = (a, b) => {
+    const da = nodes[a].data;
+    const db = nodes[b].data;
+    return db[g.yKey] - da[g.yKey] || da[g.xKey] - db[g.xKey];
+  };
+  const linkLeaves = (ids) => {
+    if (leafMode === "cells") {
+      const byY = {};
+      const byX = {};
+      ids.forEach((id) => {
+        const d = nodes[id].data;
+        (byY[d[g.yKey]] = byY[d[g.yKey]] || []).push(id);
+        (byX[d[g.xKey]] = byX[d[g.xKey]] || []).push(id);
+      });
+      Object.values(byY).forEach((r) => chain(createEdge, r.sort(leafOrderX), xRules, extents));
+      Object.values(byX).forEach((c) => chain(createEdge, c.sort(leafOrderY), yRules, extents));
+    } else {
+      chain(createEdge, [...ids].sort(leafOrderX), xRules, extents);
+      chain(createEdge, [...ids].sort(leafOrderY), yRules, extents);
+    }
+  };
+  if (across) {
+    linkLeaves(leafIds);
+  } else {
+    Object.values(finest).forEach((c) => linkLeaves(c.children));
+  }
+  return {
+    rootId: root.id,
+    levels: g.levels,
+    cellsByLevel: cellsByLevel.map((cells) => Object.values(cells).map((c) => c.id)),
+    leafIds,
+    parentRules
+  };
+};
+
+// src/hierarchy.ts
+var buildHierarchy = (options, nodes, edges) => {
+  var _a, _b;
+  const h = options.hierarchy;
+  if (!h)
+    return;
+  const createEdge = makeEdgeCreator(nodes, edges, options.useDirectedEdges);
+  const siblingRules = ((_a = h.navigationRules) == null ? void 0 : _a.sibling_sibling) || ["left", "right"];
+  const parentRules = ((_b = h.navigationRules) == null ? void 0 : _b.parent_child) || ["drill-out", "drill-in"];
+  const extents = h.extents || "circular";
+  const idOf = (d) => d[typeof options.idKey === "function" ? options.idKey(d) : options.idKey];
+  const children = {};
+  let rootId;
+  options.data.forEach((d) => {
+    const id = idOf(d);
+    const parent = d[h.parentKey];
+    if (parent === void 0 || parent === null || parent === "") {
+      if (rootId) {
+        console.error(
+          `Building hierarchy. More than one root was found: ${rootId} and ${id}. Using ${rootId}.`
+        );
+        return;
+      }
+      rootId = id;
+    } else {
+      if (!children[parent])
+        children[parent] = [];
+      children[parent].push(d);
+    }
+  });
+  if (!rootId) {
+    console.error("Building hierarchy. No root row was found. One row must have an empty parent.");
+    return;
+  }
+  const byDepth = [];
+  const visit = (id, parentId, depth) => {
+    const node = nodes[id];
+    if (!node) {
+      console.error(`Building hierarchy. Row ${id} has no node. Check idKey.`);
+      return;
+    }
+    node.depth = depth;
+    if (parentId)
+      node.parentId = parentId;
+    if (!byDepth[depth])
+      byDepth[depth] = [];
+    byDepth[depth].push(id);
+    let kids = children[id] || [];
+    if (h.sortFunction)
+      kids = [...kids].sort((a, b) => h.sortFunction(a, b));
+    const kidIds = kids.map(idOf);
+    node.childCount = kidIds.length;
+    if (kidIds.length) {
+      createEdge(id, kidIds[0], parentRules, "source");
+      kidIds.forEach((k) => createEdge(id, k, parentRules, "target"));
+      if (h.levelNavigation !== "across") {
+        chain(createEdge, kidIds, siblingRules, extents);
+      }
+    }
+    kidIds.forEach((k) => visit(k, id, depth + 1));
+  };
+  visit(rootId, void 0, 0);
+  if (h.levelNavigation === "across") {
+    byDepth.forEach((ids) => chain(createEdge, ids, siblingRules, extents));
+  }
+  return { rootId, depthCount: byDepth.length, parentRules };
+};
+
 // src/structure.ts
 var structure_default = (options) => {
   if (options.dataType === "vega-lite" || options.dataType === "vl" || options.dataType === "Vega-Lite") {
@@ -758,9 +1191,9 @@ var scaffoldDimensions = (options, nodes) => {
   }
   return dimensions;
 };
-var buildEdges = (options, nodes, dimensions) => {
+var buildEdges = (options, nodes, dimensions, existingEdges) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-  let edges = {};
+  let edges = existingEdges || {};
   const addEdgeToNode = (nodeId, edgeId) => {
     if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
       nodes[nodeId].edges.push(edgeId);
@@ -834,7 +1267,7 @@ var buildEdges = (options, nodes, dimensions) => {
         createEdge(level1Node.id, nextLevel1Node.id, siblingRules);
       }
       if (!l && extents === "bridgedCustom") {
-        createEdge(po.level1Options.behavior.customBridgePost, level1Node.id, siblingRules);
+        createEdge(po.level1Options.behavior.customBridgePrevious, level1Node.id, siblingRules);
       }
       l++;
     });
@@ -1021,7 +1454,7 @@ var buildEdges = (options, nodes, dimensions) => {
   return edges;
 };
 var buildRules = (options, edges, dimensions) => {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
   let rules = options.navigationRules;
   if (!rules) {
     let dimKeys = Object.keys(dimensions || {});
@@ -1125,6 +1558,20 @@ var buildRules = (options, edges, dimensions) => {
         checkKeys(ss[0], ss[1]);
       });
     }
+    const extraPairs = [
+      (_f = (_e = options.frame) == null ? void 0 : _e.navigationRules) == null ? void 0 : _f.parent_child,
+      (_h = (_g = options.frame) == null ? void 0 : _g.navigationRules) == null ? void 0 : _h.sibling_sibling,
+      (_j = (_i = options.spatialGrid) == null ? void 0 : _i.navigationRules) == null ? void 0 : _j.x,
+      (_l = (_k = options.spatialGrid) == null ? void 0 : _k.navigationRules) == null ? void 0 : _l.y,
+      (_n = (_m = options.spatialGrid) == null ? void 0 : _m.navigationRules) == null ? void 0 : _n.parent_child,
+      (_p = (_o = options.hierarchy) == null ? void 0 : _o.navigationRules) == null ? void 0 : _p.parent_child,
+      (_r = (_q = options.hierarchy) == null ? void 0 : _q.navigationRules) == null ? void 0 : _r.sibling_sibling
+    ];
+    extraPairs.forEach((pair) => {
+      if (pair && !used[pair[0]] && !used[pair[1]]) {
+        checkKeys(pair[0], pair[1]);
+      }
+    });
     Object.keys(edges).forEach((e) => {
       edges[e].navigationRules.forEach((rule) => {
         if (!used[rule]) {
@@ -1159,20 +1606,38 @@ var buildRules = (options, edges, dimensions) => {
   }
   return rules;
 };
-var buildStructure = (options) => {
-  if (options.addIds) {
-    addSimpleDataIDs(options);
+var buildStructure = (inputOptions) => {
+  var _a, _b, _c;
+  if (inputOptions.addIds) {
+    addSimpleDataIDs(inputOptions);
   }
+  const options = prepareFrameOptions(inputOptions);
   let nodes = buildNodes(options);
   let dimensions = scaffoldDimensions(options, nodes);
-  let edges = buildEdges(options, nodes, dimensions);
+  let edges = {};
+  const spatialGrid = buildSpatialGrid(options, nodes, edges);
+  const hierarchy = buildHierarchy(options, nodes, edges);
+  let frame;
+  if (options.frame) {
+    const dimKeys = Object.keys(dimensions || {});
+    const topId = (spatialGrid == null ? void 0 : spatialGrid.rootId) || (hierarchy == null ? void 0 : hierarchy.rootId) || ((_c = (_b = (_a = options.dimensions) == null ? void 0 : _a.parentOptions) == null ? void 0 : _b.addLevel0) == null ? void 0 : _c.id) || (dimKeys.length === 1 ? dimensions[dimKeys[0]].nodeId : void 0);
+    frame = buildFrame(options, nodes, edges, topId);
+  }
+  edges = buildEdges(options, nodes, dimensions, edges);
   let navigationRules = buildRules(options, edges, dimensions);
-  return {
+  const structure = {
     nodes,
     edges,
     dimensions,
     navigationRules
   };
+  if (frame)
+    structure.frame = frame;
+  if (spatialGrid)
+    structure.spatialGrid = spatialGrid;
+  if (hierarchy)
+    structure.hierarchy = hierarchy;
+  return structure;
 };
 
 // src/input.ts
@@ -1405,11 +1870,12 @@ var rendering_default = (options) => {
     parentSemantics: __spreadValues({}, NodeElementDefaults.parentSemantics),
     existingElement: __spreadValues({}, NodeElementDefaults.existingElement)
   };
+  const mergeDefault = (base, o) => typeof o === "function" ? o : __spreadValues(__spreadValues({}, base), o);
   if (options.defaults) {
     defaults.cssClass = options.defaults.cssClass || defaults.cssClass;
-    defaults.spatialProperties = options.defaults.spatialProperties ? __spreadValues(__spreadValues({}, defaults.spatialProperties), options.defaults.spatialProperties) : defaults.spatialProperties;
-    defaults.semantics = options.defaults.semantics ? __spreadValues(__spreadValues({}, defaults.semantics), options.defaults.semantics) : defaults.semantics;
-    defaults.parentSemantics = options.defaults.parentSemantics ? __spreadValues(__spreadValues({}, defaults.parentSemantics), options.defaults.parentSemantics) : defaults.parentSemantics;
+    defaults.spatialProperties = options.defaults.spatialProperties ? mergeDefault(defaults.spatialProperties, options.defaults.spatialProperties) : defaults.spatialProperties;
+    defaults.semantics = options.defaults.semantics ? mergeDefault(defaults.semantics, options.defaults.semantics) : defaults.semantics;
+    defaults.parentSemantics = options.defaults.parentSemantics ? mergeDefault(defaults.parentSemantics, options.defaults.parentSemantics) : defaults.parentSemantics;
     defaults.existingElement = options.defaults.existingElement ? __spreadValues(__spreadValues({}, defaults.existingElement), options.defaults.existingElement) : defaults.existingElement;
   }
   renderer.initialize = () => {
@@ -1503,12 +1969,16 @@ var rendering_default = (options) => {
     }
     let useExisting = false;
     let existingSpatialProperties = {};
-    const resolveProp = (prop, subprop, checkExisting) => {
+    const resolve = (v) => {
       var _a;
-      const p1 = d[prop] || defaults[prop];
+      return typeof v === "function" ? v(d, (_a = nodeData.datum) != null ? _a : nodeData.data) : v;
+    };
+    const resolveProp = (prop, subprop, checkExisting) => {
+      var _a, _b, _c;
+      const p1 = resolve(d[prop] || defaults[prop]);
       const s1 = !(checkExisting && useExisting) ? p1 == null ? void 0 : p1[subprop] : existingSpatialProperties[subprop];
-      const s2 = (_a = defaults[prop]) == null ? void 0 : _a[subprop];
-      return typeof p1 === "function" ? p1(d, nodeData.datum) : typeof s1 === "function" ? s1(d, nodeData.datum) : s1 || s2 || (!subprop ? p1 : void 0);
+      const s2 = (_c = (_a = resolve(defaults[prop])) == null ? void 0 : _a[subprop]) != null ? _c : (_b = NodeElementDefaults[prop]) == null ? void 0 : _b[subprop];
+      return resolve(s1) || resolve(s2) || (!subprop ? p1 : void 0);
     };
     useExisting = resolveProp("existingElement", "useForSpatialProperties");
     existingSpatialProperties = resolveProp("existingElement", "spatialProperties");
@@ -1538,15 +2008,15 @@ var rendering_default = (options) => {
     const attributes = resolveProp("semantics", "attributes");
     if (typeof attributes === "object") {
       Object.keys(attributes).forEach((attribute) => {
-        node.setAttribute(attribute, attributes[attribute]);
+        nodeText.setAttribute(attribute, attributes[attribute]);
       });
     }
     nodeText.setAttribute("role", resolveProp("semantics", "role"));
     nodeText.classList.add("dn-node-text");
+    const label = resolveProp("semantics", "label");
     if (d.showText) {
-      nodeText.innerText = d.semantics.label;
+      nodeText.innerText = label;
     }
-    const label = resolveProp("semantics", "label");
     if (!label) {
       console.error(
         "Accessibility error: a label must be supplied to every rendered element using semantics.label."
@@ -1601,7 +2071,10 @@ var rendering_default = (options) => {
       return;
     }
     const optionsCommands = commandOptions.commands;
-    const genericCommandsFromRules = getGenericCommandsFromNavRules(commandOptions.navigationRules);
+    const genericCommandsFromRules = getGenericCommandsFromNavRules(
+      commandOptions.navigationRules,
+      commandOptions.descriptions
+    );
     const commands = optionsCommands ? typeof optionsCommands === "function" ? optionsCommands(genericCommandsFromRules) : optionsCommands : genericCommandsFromRules;
     if (!customElements.get("dn-commands-table")) {
       customElements.define("dn-commands-table", CommandsTable);
@@ -1793,7 +2266,7 @@ var searchNodes = (query, structure, describeFn, limit = 10) => {
   return results;
 };
 var text_chat_default = (options) => {
-  var _a;
+  var _a, _b, _c, _d;
   const {
     structure,
     container,
@@ -1811,7 +2284,9 @@ var text_chat_default = (options) => {
   if (!rootEl) {
     throw new Error(`textChat: container "${container}" not found`);
   }
-  const resolvedEntryPoint = entryPoint || (structure.dimensions ? (_a = structure.dimensions[Object.keys(structure.dimensions)[0]]) == null ? void 0 : _a.nodeId : Object.keys(structure.nodes)[0]);
+  const level0Id = Object.keys(structure.nodes).find((id) => structure.nodes[id].dimensionLevel === 0);
+  const firstDimensionId = structure.dimensions ? (_a = structure.dimensions[Object.keys(structure.dimensions)[0]]) == null ? void 0 : _a.nodeId : void 0;
+  const resolvedEntryPoint = entryPoint || ((_b = structure.frame) == null ? void 0 : _b.rootId) || level0Id || ((_c = structure.spatialGrid) == null ? void 0 : _c.rootId) || ((_d = structure.hierarchy) == null ? void 0 : _d.rootId) || firstDimensionId || Object.keys(structure.nodes)[0];
   const inputHandler = input_default({
     structure,
     navigationRules: structure.navigationRules || {},
@@ -2369,7 +2844,9 @@ var src_default = { structure: structure_default, input: input_default, renderin
   createValidId,
   describeNode,
   expandHull,
+  getGenericCommandsFromNavRules,
   grahamScan,
+  keyLabel,
   offsetLinePath,
   unionOfRectPaths
 });