data-navigator 1.2.4 → 2.0.0

package/dist/index.mjs

@@ -1,4 +1,13 @@
 // src/consts.ts
+var SemanticKeys = {
+  Escape: true,
+  Enter: true,
+  Backspace: true,
+  ArrowLeft: true,
+  ArrowRight: true,
+  ArrowUp: true,
+  ArrowDown: true
+};
 var defaultKeyBindings = {
   ArrowLeft: "left",
   ArrowRight: "right",
@@ -9,44 +18,71 @@ var defaultKeyBindings = {
   Escape: "parent",
   Enter: "child"
 };
+var TypicallyUnreservedKeys = ["KeyW", "KeyJ", "LeftBracket", "RightBracket", "Slash", "Backslash"];
+var TypicallyUnreservedKeyPairs = [
+  ["LeftBracket", "RightBracket"],
+  ["Slash", "Backslash"]
+];
 var GenericFullNavigationRules = {
-  down: {
-    keyCode: "ArrowDown",
-    direction: "target"
-  },
   left: {
-    keyCode: "ArrowLeft",
+    key: "ArrowLeft",
     direction: "source"
   },
   right: {
-    keyCode: "ArrowRight",
+    key: "ArrowRight",
     direction: "target"
   },
   up: {
-    keyCode: "ArrowUp",
+    key: "ArrowUp",
     direction: "source"
   },
-  backward: {
-    keyCode: "Comma",
-    direction: "source"
+  down: {
+    key: "ArrowDown",
+    direction: "target"
   },
   child: {
-    keyCode: "Enter",
+    key: "Enter",
     direction: "target"
   },
   parent: {
-    keyCode: "Backspace",
+    key: "Backspace",
+    direction: "source"
+  },
+  backward: {
+    key: "Comma",
     direction: "source"
   },
   forward: {
-    keyCode: "Period",
+    key: "Period",
+    direction: "target"
+  },
+  previous: {
+    key: "Semicolon",
+    direction: "source"
+  },
+  next: {
+    key: "Quote",
     direction: "target"
   },
   exit: {
-    keyCode: "Escape",
+    key: "Escape",
+    direction: "target"
+  },
+  help: {
+    key: "KeyY",
+    direction: "target"
+  },
+  undo: {
+    key: "KeyZ",
     direction: "target"
   }
 };
+var GenericFullNavigationDimensions = [
+  ["left", "right"],
+  ["up", "down"],
+  ["backward", "forward"],
+  ["previous", "next"]
+];
 var GenericLimitedNavigationRules = {
   right: {
     key: "ArrowRight",
@@ -87,7 +123,7 @@ var GenericLimitedNavigationRules = {
 };
 var NodeElementDefaults = {
   cssClass: "",
-  dimensions: {
+  spatialProperties: {
     x: 0,
     y: 0,
     width: 0,
@@ -107,8 +143,8 @@ var NodeElementDefaults = {
     attributes: void 0
   },
   existingElement: {
-    useForDimensions: false,
-    dimensions: void 0
+    useForSpatialProperties: false,
+    spatialProperties: void 0
   }
 };
 
@@ -128,10 +164,7 @@ var structure_default = (options) => {
   if (options.dataType === "vega-lite" || options.dataType === "vl" || options.dataType === "Vega-Lite") {
     return buildNodeStructureFromVegaLite(options);
   } else {
-    console.warn(
-      "Apologies, we currently only have structure scaffolding for Vega-Lite, generic scaffolding coming soon!"
-    );
-    return;
+    return buildStructure(options);
   }
 };
 var buildNodeStructureFromVegaLite = (options) => {
@@ -252,11 +285,11 @@ var buildNodeStructureFromVegaLite = (options) => {
     nodes[id].parent = parent;
     elementData[renderId] = {};
     elementData[renderId].renderId = renderId;
-    elementData[renderId].dimensions = {};
-    elementData[renderId].dimensions.x = item.bounds.x1 + o[0];
-    elementData[renderId].dimensions.y = item.bounds.y1 + o[1];
-    elementData[renderId].dimensions.width = item.bounds.x2 - item.bounds.x1;
-    elementData[renderId].dimensions.height = item.bounds.y2 - item.bounds.y1;
+    elementData[renderId].spatialProperties = {};
+    elementData[renderId].spatialProperties.x = item.bounds.x1 + o[0];
+    elementData[renderId].spatialProperties.y = item.bounds.y1 + o[1];
+    elementData[renderId].spatialProperties.width = item.bounds.x2 - item.bounds.x1;
+    elementData[renderId].spatialProperties.height = item.bounds.y2 - item.bounds.y1;
     elementData[renderId].cssClass = "dn-vega-lite-node";
     if (item.datum) {
       Object.keys(item.datum).forEach((key) => {
@@ -295,6 +328,647 @@ var buildNodeStructureFromVegaLite = (options) => {
     navigationRules
   };
 };
+var createValidId = (s) => {
+  return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
+};
+var addSimpleDataIDs = (options) => {
+  let i = 0;
+  let keyCounter = {};
+  options.data.forEach((d) => {
+    const id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
+    d[id] = "_" + i;
+    if (options.keysForIdGeneration) {
+      options.keysForIdGeneration.forEach((k) => {
+        if (k in d) {
+          if (typeof d[k] === "string") {
+            if (!keyCounter[k]) {
+              keyCounter[k] = 0;
+            }
+            if (!keyCounter[d[k]]) {
+              keyCounter[d[k]] = 0;
+            }
+            d[id] += "_" + k + keyCounter[k] + "_" + d[k] + keyCounter[d[k]];
+            keyCounter[k]++;
+            keyCounter[d[k]]++;
+          } else {
+            if (!keyCounter[k]) {
+              keyCounter[k] = 0;
+            }
+            d[id] += "_" + k + keyCounter[k];
+            keyCounter[k]++;
+          }
+        }
+      });
+    }
+    i++;
+  });
+};
+var bulidNodes = (options) => {
+  let nodes = {};
+  options.data.forEach((d) => {
+    if (!options.idKey) {
+      console.error(
+        `Building nodes. A key string must be supplied in options.idKey to specify the id keys of every node.`
+      );
+    }
+    const idKey = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
+    const id = d[idKey];
+    if (!id) {
+      console.error(
+        `Building nodes. Each datum in options.data must contain an id. When matching the id key string ${idKey}, this datum has no id: ${JSON.stringify(
+          d
+        )}.`
+      );
+      return;
+    }
+    if (!nodes[id]) {
+      const renderIdKey = typeof options.renderIdKey === "function" ? options.renderIdKey(d) : options.renderIdKey;
+      nodes[id] = {
+        id,
+        edges: [],
+        renderId: renderIdKey ? d[renderIdKey] || "" : d.renderIdKey || "",
+        data: d
+      };
+    } else {
+      console.error(
+        `Building nodes. Each id for data in options.data must be unique. This id is not unique: ${id}.`
+      );
+      return;
+    }
+  });
+  return nodes;
+};
+var scaffoldDimensions = (options, nodes) => {
+  let dimensions = {};
+  if (options.dimensions?.parentOptions?.addLevel0) {
+    let level0 = options.dimensions.parentOptions.addLevel0;
+    nodes[level0.id] = { ...level0, dimensionLevel: 0 };
+  }
+  let rules = [...GenericFullNavigationDimensions];
+  const setExtents = (val, dim) => {
+    let min = dim.numericalExtents[0];
+    let max = dim.numericalExtents[1];
+    dim.numericalExtents[0] = min < val ? min : val;
+    dim.numericalExtents[1] = max > val ? max : val;
+  };
+  options.data.forEach((d) => {
+    let ods = options.dimensions.values || [];
+    let i = 0;
+    ods.forEach((dim) => {
+      if (!dim.dimensionKey) {
+        console.error(
+          `Building nodes, parsing dimensions. Each dimension in options.dimensions must contain a dimensionKey. This dimension has no key: ${JSON.stringify(
+            dim
+          )}.`
+        );
+        return;
+      }
+      if (dim.dimensionKey in d) {
+        let value = d[dim.dimensionKey];
+        let keepValue = typeof dim.operations?.filterFunction === "function" ? dim.operations.filterFunction(d, dim) : true;
+        if (value !== void 0 && keepValue) {
+          if (!dim.type) {
+            dim.type = typeof value === "bigint" || typeof value === "number" ? "numerical" : "categorical";
+          }
+          if (!dimensions[dim.dimensionKey]) {
+            let id2 = typeof dim.nodeId === "function" ? dim.nodeId(dim, options.data) : dim.nodeId || createValidId(dim.dimensionKey);
+            let renderId = typeof dim.renderId === "function" ? dim.renderId(dim, options.data) : dim.renderId || id2;
+            dimensions[dim.dimensionKey] = {
+              dimensionKey: dim.dimensionKey,
+              nodeId: id2,
+              divisions: {},
+              numericalExtents: [Infinity, -Infinity],
+              type: dim.type,
+              sortFunction: dim.operations?.sortFunction || void 0,
+              behavior: dim.behavior || {
+                extents: "circular"
+              },
+              navigationRules: dim.navigationRules || {
+                sibling_sibling: rules.length ? [...rules.shift()] : ["previous_" + dim.dimensionKey, "next_" + dim.dimensionKey],
+                parent_child: ["parent_" + dim.dimensionKey, "child"]
+              }
+            };
+            nodes[id2] = {
+              id: id2,
+              renderId,
+              derivedNode: dim.dimensionKey,
+              edges: [],
+              dimensionLevel: 1,
+              data: dimensions[dim.dimensionKey],
+              renderingStrategy: dim.renderingStrategy || "singleSquare"
+              // not sure what defaults we want yet
+            };
+          }
+          let dimension = dimensions[dim.dimensionKey];
+          let targetDivision = null;
+          if (dim.type === "categorical") {
+            let divisionId = typeof dim.divisionOptions?.divisionNodeIds === "function" ? dim.divisionOptions.divisionNodeIds(dim.dimensionKey, value, i) : dimension.nodeId + "_" + value;
+            targetDivision = dimension.divisions[divisionId];
+            if (!targetDivision) {
+              targetDivision = dimension.divisions[divisionId] = {
+                id: divisionId,
+                sortFunction: dim.divisionOptions?.sortFunction || void 0,
+                values: {}
+              };
+              let divisionRenderId = typeof dim.divisionOptions?.divisionRenderIds === "function" ? dim.divisionOptions.divisionRenderIds(dim.dimensionKey, value, i) : divisionId;
+              nodes[divisionId] = {
+                id: divisionId,
+                renderId: divisionRenderId,
+                derivedNode: dim.dimensionKey,
+                edges: [],
+                dimensionLevel: 2,
+                data: { ...targetDivision },
+                renderingStrategy: dim.divisionOptions?.renderingStrategy || "singleSquare"
+                // not sure what defaults we want yet
+              };
+              nodes[divisionId].data[dim.dimensionKey] = value;
+            }
+          } else {
+            targetDivision = dimension.divisions[dimension.nodeId];
+            if (!targetDivision) {
+              targetDivision = dimension.divisions[dimension.nodeId] = {
+                id: dimension.nodeId,
+                sortFunction: dim.divisionOptions?.sortFunction || void 0,
+                values: {}
+              };
+            }
+            if (!dim.operations) {
+              dim.operations = {};
+            }
+            let subdivs = dim.operations.createNumericalSubdivisions;
+            dimension.subdivisions = typeof subdivs === "number" && subdivs < 1 ? 1 : subdivs || 1;
+            if (subdivs !== 1) {
+              if (!dimension.divisionOptions) {
+                dimension.divisionOptions = dim.divisionOptions;
+              }
+              setExtents(value, dimension);
+            }
+          }
+          const id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
+          targetDivision.values[d[id]] = d;
+        }
+      }
+      i++;
+    });
+  });
+  Object.keys(dimensions).forEach((s) => {
+    let dimension = dimensions[s];
+    let divisions = dimension.divisions;
+    if (dimension.type === "numerical") {
+      divisions[dimension.nodeId].values = Object.fromEntries(
+        Object.entries(divisions[dimension.nodeId].values).sort((a, b) => {
+          return typeof dimension.sortFunction === "function" ? dimension.sortFunction(a[1], b[1], dimension) : a[1][s] - b[1][s];
+        })
+      );
+      let values = divisions[dimension.nodeId].values;
+      if (dimension.numericalExtents[0] !== Infinity && dimension.subdivisions !== 1) {
+        let valueKeys = Object.keys(values);
+        let subDivisions = typeof dimension.subdivisions === "function" ? dimension.subdivisions(s, values) : dimension.subdivisions;
+        let range = dimension.numericalExtents[1] - dimension.numericalExtents[0];
+        let interval = range / subDivisions;
+        let i = dimension.numericalExtents[0] + interval;
+        let divisionCount = 0;
+        let index = 0;
+        for (i = dimension.numericalExtents[0] + interval; i <= dimension.numericalExtents[1]; i += interval) {
+          let divisionId = typeof dimension.divisionOptions?.divisionNodeIds === "function" ? dimension.divisionOptions.divisionNodeIds(s, i, i) : dimension.nodeId + "_" + i;
+          dimension.divisions[divisionId] = {
+            id: divisionId,
+            sortFunction: dimension.divisionOptions?.sortFunction || void 0,
+            values: {}
+          };
+          let divisionRenderId = typeof dimension.divisionOptions?.divisionRenderIds === "function" ? dimension.divisionOptions.divisionRenderIds(s, i, i) : divisionId;
+          nodes[divisionId] = {
+            id: divisionId,
+            renderId: divisionRenderId,
+            derivedNode: s,
+            edges: [],
+            data: dimension.divisions[divisionId],
+            dimensionLevel: 2,
+            renderingStrategy: dimension.divisionOptions?.renderingStrategy || "singleSquare"
+            // not sure what defaults we want yet
+          };
+          let limit = false;
+          while (!limit && index < valueKeys.length) {
+            let node = values[valueKeys[index]];
+            let value = node[s];
+            if (value <= i) {
+              dimension.divisions[divisionId].values[node.id] = node;
+            } else {
+              i += interval;
+              limit = true;
+            }
+            index++;
+          }
+          divisionCount++;
+        }
+        delete divisions[s];
+      }
+    } else if (typeof dimension.sortFunction === "function") {
+      dimension.divisions = Object.fromEntries(
+        Object.entries(divisions).sort((a, b) => {
+          return dimension.sortFunction(a[1], b[1], dimension);
+        })
+      );
+    }
+    let divisionKeys = Object.keys(dimension.divisions);
+    divisionKeys.forEach((d) => {
+      let division = dimension.divisions[d];
+      if (typeof division.sortFunction === "function") {
+        division.values = Object.fromEntries(
+          Object.entries(division.values).sort((a, b) => {
+            return dimension.sortFunction(a[1], b[1], division);
+          })
+        );
+      }
+    });
+  });
+  if (options.dimensions.adjustDimensions) {
+    dimensions = options.dimensions.adjustDimensions(dimensions);
+  }
+  return dimensions;
+};
+var buildEdges = (options, nodes, dimensions) => {
+  let edges = {};
+  const addEdgeToNode = (nodeId, edgeId) => {
+    if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
+      nodes[nodeId].edges.push(edgeId);
+    }
+  };
+  const createEdge = (source, target, rules, addTo) => {
+    const id = `${source}-${target}`;
+    let targetId = !options.useDirectedEdges ? id : `${target}-${id}`;
+    let addToSource = !addTo || addTo === "source";
+    let addToTarget = !addTo || addTo === "target";
+    const checkEdgeRules = (eId) => {
+      if (edges[eId]) {
+        edges[eId].navigationRules.push(...rules || []);
+      } else {
+        edges[eId] = {
+          source,
+          target,
+          navigationRules: rules ? [...rules] : []
+        };
+      }
+    };
+    checkEdgeRules(id);
+    if (options.useDirectedEdges && addToTarget) {
+      checkEdgeRules(targetId);
+    }
+    if (addToSource) {
+      addEdgeToNode(source, id);
+    }
+    if (addToTarget) {
+      addEdgeToNode(target, targetId);
+    }
+  };
+  if (dimensions && Object.keys(dimensions).length) {
+    const dimensionKeys = Object.keys(dimensions);
+    const hasOrder = options.dimensions?.parentOptions?.level1Options?.order;
+    let order = hasOrder || dimensionKeys;
+    let l = 0;
+    let po = options.dimensions?.parentOptions || {};
+    let extents = po.level1Options?.behavior?.extents || "terminal";
+    let level0 = po.addLevel0;
+    let parentRules = level0 ? po.level1Options?.navigationRules?.parent_child || ["parent", "child"] : [];
+    let siblingRules = po.level1Options?.navigationRules?.sibling_sibling || ["left", "right"];
+    let firstLevel1Node = typeof order[0] === "string" ? hasOrder ? nodes[order[0]] : nodes[dimensions[order[0]].nodeId] : order[0];
+    if (level0) {
+      createEdge(level0.id, firstLevel1Node.id, parentRules, "source");
+    }
+    order.forEach((n) => {
+      let level1Node = typeof n === "string" ? hasOrder ? nodes[n] : nodes[dimensions[n].nodeId] : n;
+      if (level1Node === n && !nodes[level1Node.id]) {
+        nodes[level1Node.id] = level1Node;
+      }
+      if (level0) {
+        if (!options.useDirectedEdges) {
+          createEdge(level0.id, level1Node.id, parentRules, "target");
+        } else {
+          createEdge(level1Node.id, level0.id, parentRules, "source");
+        }
+      }
+      if (l === order.length - 1 && extents === "circular") {
+        createEdge(level1Node.id, firstLevel1Node.id, siblingRules);
+      } else if (l === order.length - 1 && extents === "bridgedCustom") {
+        createEdge(level1Node.id, po.level1Options.behavior.customBridgePost, siblingRules);
+      } else if (l < order.length - 1) {
+        let nextLevel1Node = typeof order[l + 1] === "string" ? hasOrder ? (
+          // @ts-ignore: for some reason the same use of conditional check works above for order[0] (firstLevel1Node) but not for l+1 here
+          nodes[order[l + 1]]
+        ) : (
+          // @ts-ignore: for some reason the same use of conditional check works above for order[0] (firstLevel1Node) but not for l+1 here
+          nodes[dimensions[order[l + 1]].nodeId]
+        ) : order[l + 1];
+        createEdge(level1Node.id, nextLevel1Node.id, siblingRules);
+      }
+      if (!l && extents === "bridgedCustom") {
+        createEdge(po.level1Options.behavior.customBridgePost, level1Node.id, siblingRules);
+      }
+      l++;
+    });
+    dimensionKeys.forEach((s) => {
+      const dimension = dimensions[s];
+      let extents2 = dimension.behavior?.extents || "circular";
+      if (!dimension.divisions) {
+        console.error(
+          `Parsing dimensions. The dimension using the key ${s} is missing the divisions property. dimension.divisions should be supplied. ${JSON.stringify(
+            dimension
+          )}.`
+        );
+      }
+      let divisionKeys = Object.keys(dimension.divisions);
+      const firstDivision = dimension.divisions[divisionKeys[0]];
+      if (divisionKeys.length !== 1) {
+        createEdge(dimension.nodeId, firstDivision.id, dimension.navigationRules.parent_child, "source");
+      } else {
+        let valueKeys = Object.keys(firstDivision.values);
+        let firstChildId = typeof options.idKey === "function" ? options.idKey(firstDivision.values[valueKeys[0]]) : options.idKey;
+        createEdge(
+          dimension.nodeId,
+          firstDivision.values[valueKeys[0]][firstChildId],
+          dimension.navigationRules.parent_child,
+          "source"
+        );
+      }
+      let j = 0;
+      divisionKeys.forEach((d) => {
+        let division = dimension.divisions[d];
+        if (j === divisionKeys.length - 1 && (extents2 === "circular" || extents2 === "bridgedCousins" || extents2 === "bridgedCustom")) {
+          createEdge(
+            division.id,
+            dimension.divisions[divisionKeys[0]].id,
+            dimension.navigationRules.sibling_sibling
+          );
+        } else if (j < divisionKeys.length - 1) {
+          createEdge(
+            division.id,
+            dimension.divisions[divisionKeys[j + 1]].id,
+            dimension.navigationRules.sibling_sibling
+          );
+        }
+        let valueKeys = Object.keys(division.values);
+        if (!options.useDirectedEdges) {
+          createEdge(dimension.nodeId, division.id, dimension.navigationRules.parent_child, "target");
+        } else {
+          createEdge(division.id, dimension.nodeId, dimension.navigationRules.parent_child, "source");
+        }
+        const firstChildId = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[0]]) : options.idKey;
+        createEdge(
+          division.id,
+          division.values[valueKeys[0]][firstChildId],
+          dimension.navigationRules.parent_child,
+          "source"
+        );
+        let i = 0;
+        if (valueKeys.length > 1) {
+          valueKeys.forEach((vk) => {
+            let v = division.values[vk];
+            const id = typeof options.idKey === "function" ? options.idKey(v) : options.idKey;
+            let parentId = divisionKeys.length !== 1 ? division.id : dimension.nodeId;
+            if (!options.useDirectedEdges) {
+              createEdge(parentId, v[id], dimension.navigationRules.parent_child, "target");
+            } else {
+              createEdge(v[id], parentId, dimension.navigationRules.parent_child, "source");
+            }
+            if (i === valueKeys.length - 1 && extents2 === "circular") {
+              const targetId = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[0]]) : options.idKey;
+              createEdge(
+                v[id],
+                division.values[valueKeys[0]][targetId],
+                dimension.navigationRules.sibling_sibling
+              );
+            } else if (i === valueKeys.length - 1 && extents2 === "bridgedCousins") {
+              if (j !== divisionKeys.length - 1) {
+                const targetId = typeof options.idKey === "function" ? options.idKey(dimension.divisions[divisionKeys[j + 1]].values[valueKeys[0]]) : options.idKey;
+                createEdge(
+                  v[id],
+                  dimension.divisions[divisionKeys[j + 1]].values[valueKeys[0]][targetId],
+                  dimension.navigationRules.sibling_sibling
+                );
+              } else {
+                const targetId = typeof options.idKey === "function" ? options.idKey(dimension.divisions[divisionKeys[0]].values[valueKeys[0]]) : options.idKey;
+                createEdge(
+                  v[id],
+                  dimension.divisions[divisionKeys[0]].values[valueKeys[0]][targetId],
+                  dimension.navigationRules.sibling_sibling
+                );
+              }
+            } else if (i === valueKeys.length - 1 && extents2 === "bridgedCustom") {
+              createEdge(
+                v[id],
+                dimension.behavior.customBridgePost,
+                dimension.navigationRules.sibling_sibling
+              );
+            } else if (i < valueKeys.length - 1) {
+              const targetId = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[i + 1]]) : options.idKey;
+              createEdge(
+                v[id],
+                division.values[valueKeys[i + 1]][targetId],
+                dimension.navigationRules.sibling_sibling
+              );
+            }
+            if (!i && extents2 === "bridgedCousins") {
+              if (j !== 0) {
+                const targetId = typeof options.idKey === "function" ? options.idKey(
+                  dimension.divisions[divisionKeys[j - 1]].values[valueKeys[valueKeys.length - 1]]
+                ) : options.idKey;
+                createEdge(
+                  dimension.divisions[divisionKeys[j - 1]].values[valueKeys[valueKeys.length - 1]][targetId],
+                  v[id],
+                  dimension.navigationRules.sibling_sibling
+                );
+              } else {
+                const targetId = typeof options.idKey === "function" ? options.idKey(
+                  dimension.divisions[divisionKeys[divisionKeys.length - 1]].values[valueKeys[valueKeys.length - 1]]
+                ) : options.idKey;
+                createEdge(
+                  dimension.divisions[divisionKeys[divisionKeys.length - 1]].values[valueKeys[valueKeys.length - 1]][targetId],
+                  v[id],
+                  dimension.navigationRules.sibling_sibling
+                );
+              }
+            } else if (!i && extents2 === "bridgedCustom") {
+              createEdge(
+                dimension.behavior.customBridgePrevious,
+                v[id],
+                dimension.navigationRules.sibling_sibling
+              );
+            }
+            i++;
+          });
+        }
+        j++;
+      });
+    });
+  }
+  Object.keys(nodes).forEach((nodeKey) => {
+    const node = nodes[nodeKey];
+    if (options.genericEdges?.length) {
+      options.genericEdges.forEach((e) => {
+        if (!edges[e.edgeId]) {
+          edges[e.edgeId] = e.edge;
+        }
+        if (!e.conditional || e.conditional && e.conditional(node, e)) {
+          node.edges.push(e.edgeId);
+        }
+      });
+    }
+  });
+  return edges;
+};
+var buildRules = (options, edges, dimensions) => {
+  let rules = options.navigationRules;
+  if (!rules) {
+    let dimKeys = Object.keys(dimensions || {});
+    if (dimKeys.length > 6) {
+      console.error(
+        `Building navigationRules. Dimension count is too high to automatically generate key commands. It is recommend you reduce your dimensions to 6 or fewer for end-user experience. If not, you must provide your own navigation rules in options.navigationRules. Details: Count is ${dimKeys.length}. Dimensions counted: ${dimKeys.join(", ")}.`
+      );
+    }
+    let importedRules = {};
+    let used = {};
+    let needsKeys = {};
+    let sparePairs = [...TypicallyUnreservedKeyPairs];
+    let spareKeys = [...TypicallyUnreservedKeys];
+    const checkKeys = (k1, k2) => {
+      let isPair = k1 && k2;
+      let k1Assigned = false;
+      let k2Assigned = false;
+      if (importedRules[k1] || used[k1]) {
+        used[k1] = { ...importedRules[k1] };
+        k1Assigned = true;
+      }
+      if (k2 && (importedRules[k2] || used[k2])) {
+        used[k2] = { ...importedRules[k2] };
+        k2Assigned = true;
+      }
+      if (isPair && !k1Assigned && !k2Assigned) {
+        if (!sparePairs.length) {
+          console.error(
+            `Building navigationRules. Dimension count is too high to automatically generate key commands, we have run out of keyboard key pairs to assign. You must either provide your own navigation rules in options.navigationRules, provide rules when generating dimensions, or reduce dimension count.`
+          );
+        }
+        let pair = [...sparePairs.shift()];
+        spareKeys.splice(spareKeys.indexOf(pair[0]), 1);
+        spareKeys.splice(spareKeys.indexOf(pair[1]), 1);
+        used[k1] = {
+          direction: options.useDirectedEdges ? "target" : "source",
+          key: pair[0]
+        };
+        used[k2] = {
+          direction: "target",
+          key: pair[1]
+        };
+      } else {
+        if (!used[k1] && spareKeys.length) {
+          let key = spareKeys.shift();
+          let newPairs = [];
+          sparePairs.forEach((p) => {
+            if (key !== p[0] && key !== p[1]) {
+              newPairs.push(p);
+            }
+          });
+          sparePairs = newPairs;
+          used[k1] = {
+            direction: options.useDirectedEdges ? "target" : "source",
+            key
+          };
+        }
+        if (k2 && !used[k2] && spareKeys.length) {
+          let key = spareKeys.shift();
+          let newPairs = [];
+          sparePairs.forEach((p) => {
+            if (key !== p[0] && key !== p[1]) {
+              newPairs.push(p);
+            }
+          });
+          sparePairs = newPairs;
+          used[k2] = {
+            direction: "target",
+            key
+          };
+        }
+        if (!spareKeys.length) {
+          if (!used[k1]) {
+            needsKeys[k1] = k1;
+          }
+          if (k2 && !used[k2]) {
+            needsKeys[k2] = k2;
+          }
+        }
+      }
+    };
+    Object.keys(GenericFullNavigationRules).forEach((r) => {
+      let rule = { ...GenericFullNavigationRules[r] };
+      if (options.useDirectedEdges) {
+        rule.direction = "target";
+      }
+      importedRules[r] = rule;
+    });
+    if (dimKeys.length) {
+      if (options.dimensions?.parentOptions?.addLevel0) {
+        let rules2 = options.dimensions.parentOptions.level1Options?.navigationRules?.parent_child || [
+          "parent",
+          "child"
+        ];
+        checkKeys(rules2[0], rules2[1]);
+      }
+      dimKeys.forEach((d) => {
+        let pc = dimensions[d].navigationRules.parent_child;
+        let ss = dimensions[d].navigationRules.sibling_sibling;
+        checkKeys(pc[0], pc[1]);
+        checkKeys(ss[0], ss[1]);
+      });
+    }
+    Object.keys(edges).forEach((e) => {
+      edges[e].navigationRules.forEach((rule) => {
+        if (!used[rule]) {
+          checkKeys(rule);
+        }
+      });
+    });
+    if (Object.keys(needsKeys).length) {
+      let usedKeys = {};
+      Object.keys(used).forEach((k) => {
+        usedKeys[used[k].key] = used[k].key;
+      });
+      Object.keys(importedRules).forEach((r) => {
+        if (!usedKeys[importedRules[r].key] && !SemanticKeys[importedRules[r].key]) {
+          spareKeys.push(importedRules[r].key);
+        }
+      });
+      let recheckKeys = { ...needsKeys };
+      needsKeys = {};
+      Object.keys(recheckKeys).forEach((key) => {
+        checkKeys(key);
+      });
+      if (Object.keys(needsKeys).length) {
+        console.error(
+          `Building navigationRules. There are no more keys left to assign automatically. Recommended fixes: use fewer dimensions, use fewer GenericEdges, or build your own navigationRules. Rules remaining without keyboard keys: ${Object.keys(
+            needsKeys
+          ).join(", ")}.`
+        );
+      }
+    }
+    rules = used;
+  }
+  return rules;
+};
+var buildStructure = (options) => {
+  if (options.addIds) {
+    addSimpleDataIDs(options);
+  }
+  let nodes = bulidNodes(options);
+  let dimensions = scaffoldDimensions(options, nodes);
+  let edges = buildEdges(options, nodes, dimensions);
+  let navigationRules = buildRules(options, edges, dimensions);
+  return {
+    nodes,
+    edges,
+    dimensions,
+    navigationRules
+  };
+};
 
 // src/input.ts
 var input_default = (options) => {
@@ -403,14 +1077,14 @@ var rendering_default = (options) => {
   let initialized = false;
   let defaults = {
     cssClass: NodeElementDefaults.cssClass,
-    dimensions: { ...NodeElementDefaults.dimensions },
+    spatialProperties: { ...NodeElementDefaults.spatialProperties },
     semantics: { ...NodeElementDefaults.semantics },
     parentSemantics: { ...NodeElementDefaults.parentSemantics },
     existingElement: { ...NodeElementDefaults.existingElement }
   };
   if (options.defaults) {
     defaults.cssClass = options.defaults.cssClass || defaults.cssClass;
-    defaults.dimensions = options.defaults.dimensions ? { ...defaults.dimensions, ...options.defaults.dimensions } : defaults.dimensions;
+    defaults.spatialProperties = options.defaults.spatialProperties ? { ...defaults.spatialProperties, ...options.defaults.spatialProperties } : defaults.spatialProperties;
     defaults.semantics = options.defaults.semantics ? { ...defaults.semantics, ...options.defaults.semantics } : defaults.semantics;
     defaults.parentSemantics = options.defaults.parentSemantics ? { ...defaults.parentSemantics, ...options.defaults.parentSemantics } : defaults.parentSemantics;
     defaults.existingElement = options.defaults.existingElement ? { ...defaults.existingElement, ...options.defaults.existingElement } : defaults.existingElement;
@@ -499,19 +1173,19 @@ var rendering_default = (options) => {
       return;
     }
     let useExisting = false;
-    let existingDimensions = {};
+    let existingSpatialProperties = {};
     const resolveProp = (prop, subprop, checkExisting) => {
       const p1 = d[prop] || defaults[prop];
-      const s1 = !(checkExisting && useExisting) ? p1[subprop] : existingDimensions[subprop];
+      const s1 = !(checkExisting && useExisting) ? p1[subprop] : existingSpatialProperties[subprop];
       const s2 = defaults[prop][subprop];
       return typeof p1 === "function" ? p1(d, nodeData.datum) : typeof s1 === "function" ? s1(d, nodeData.datum) : s1 || s2 || (!subprop ? p1 : void 0);
     };
-    useExisting = resolveProp("existingElement", "useForDimensions");
-    existingDimensions = resolveProp("existingElement", "dimensions");
-    const width = parseFloat(resolveProp("dimensions", "width", true) || 0);
-    const height = parseFloat(resolveProp("dimensions", "height", true) || 0);
-    const x = parseFloat(resolveProp("dimensions", "x", true) || 0);
-    const y = parseFloat(resolveProp("dimensions", "y", true) || 0);
+    useExisting = resolveProp("existingElement", "useForSpatialProperties");
+    existingSpatialProperties = resolveProp("existingElement", "spatialProperties");
+    const width = parseFloat(resolveProp("spatialProperties", "width", true) || 0);
+    const height = parseFloat(resolveProp("spatialProperties", "height", true) || 0);
+    const x = parseFloat(resolveProp("spatialProperties", "x", true) || 0);
+    const y = parseFloat(resolveProp("spatialProperties", "y", true) || 0);
     const node = document.createElement(resolveProp("parentSemantics", "elementType"));
     const wrapperAttrs = resolveProp("parentSemantics", "attributes");
     if (typeof wrapperAttrs === "object") {
@@ -550,7 +1224,7 @@ var rendering_default = (options) => {
     }
     nodeText.setAttribute("aria-label", label);
     node.appendChild(nodeText);
-    const hasPath = resolveProp("dimensions", "path");
+    const hasPath = resolveProp("spatialProperties", "path");
     if (hasPath) {
       const totalWidth = width + x + 10;
       const totalHeight = height + y + 10;