data-navigator 1.2.4 → 2.0.1

package/dist/index.js

@@ -40,9 +40,37 @@ function _object_spread(target) {
     }
     return target;
 }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -106,6 +134,15 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 // 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",
@@ -116,44 +153,96 @@ 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",
@@ -194,7 +283,7 @@ var GenericLimitedNavigationRules = {
 };
 var NodeElementDefaults = {
     cssClass: "",
-    dimensions: {
+    spatialProperties: {
         x: 0,
         y: 0,
         width: 0,
@@ -214,8 +303,8 @@ var NodeElementDefaults = {
         attributes: void 0
     },
     existingElement: {
-        useForDimensions: false,
-        dimensions: void 0
+        useForSpatialProperties: false,
+        spatialProperties: void 0
     }
 };
 // src/utilities.ts
@@ -228,13 +317,15 @@ var describeNode = function(d, descriptionOptions) {
     description += descriptionOptions && descriptionOptions.semanticLabel || "Data point.";
     return description;
 };
+var createValidId = function(s) {
+    return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
+};
 // src/structure.ts
 var structure_default = function(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 = function(options) {
@@ -380,11 +471,11 @@ var buildNodeStructureFromVegaLite = function(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(function(key) {
@@ -423,6 +514,583 @@ var buildNodeStructureFromVegaLite = function(options) {
         navigationRules: navigationRules
     };
 };
+var addSimpleDataIDs = function(options) {
+    var i = 0;
+    var keyCounter = {};
+    options.data.forEach(function(d) {
+        var id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
+        d[id] = "_" + i;
+        if (options.keysForIdGeneration) {
+            options.keysForIdGeneration.forEach(function(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 buildNodes = function(options) {
+    var nodes = {};
+    options.data.forEach(function(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.");
+        }
+        var idKey = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
+        var id = d[idKey];
+        if (!id) {
+            console.error("Building nodes. Each datum in options.data must contain an id. When matching the id key string ".concat(idKey, ", this datum has no id: ").concat(JSON.stringify(d), "."));
+            return;
+        }
+        if (!nodes[id]) {
+            var renderIdKey = typeof options.renderIdKey === "function" ? options.renderIdKey(d) : options.renderIdKey;
+            nodes[id] = {
+                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: ".concat(id, "."));
+            return;
+        }
+    });
+    return nodes;
+};
+var scaffoldDimensions = function(options, nodes) {
+    var _options_dimensions_parentOptions, _options_dimensions;
+    var dimensions = {};
+    if ((_options_dimensions = options.dimensions) === null || _options_dimensions === void 0 ? void 0 : (_options_dimensions_parentOptions = _options_dimensions.parentOptions) === null || _options_dimensions_parentOptions === void 0 ? void 0 : _options_dimensions_parentOptions.addLevel0) {
+        var level0 = options.dimensions.parentOptions.addLevel0;
+        nodes[level0.id] = _object_spread_props(_object_spread({}, level0), {
+            dimensionLevel: 0
+        });
+    }
+    var rules = _to_consumable_array(GenericFullNavigationDimensions);
+    var setExtents = function(val, dim) {
+        var min = dim.numericalExtents[0];
+        var max = dim.numericalExtents[1];
+        dim.numericalExtents[0] = min < val ? min : val;
+        dim.numericalExtents[1] = max > val ? max : val;
+    };
+    options.data.forEach(function(d) {
+        var ods = options.dimensions.values || [];
+        var i = 0;
+        ods.forEach(function(dim) {
+            if (!dim.dimensionKey) {
+                console.error("Building nodes, parsing dimensions. Each dimension in options.dimensions must contain a dimensionKey. This dimension has no key: ".concat(JSON.stringify(dim), "."));
+                return;
+            }
+            if (dim.dimensionKey in d) {
+                var _dim_operations;
+                var value = d[dim.dimensionKey];
+                var keepValue = typeof ((_dim_operations = dim.operations) === null || _dim_operations === void 0 ? void 0 : _dim_operations.filterFunction) === "function" ? dim.operations.filterFunction(d, dim) : true;
+                if (value !== void 0 && keepValue) {
+                    if (!dim.type) {
+                        dim.type = (typeof value === "undefined" ? "undefined" : _type_of(value)) === "bigint" || typeof value === "number" ? "numerical" : "categorical";
+                    }
+                    if (!dimensions[dim.dimensionKey]) {
+                        var _dim_operations1;
+                        var id2 = typeof dim.nodeId === "function" ? dim.nodeId(dim, options.data) : dim.nodeId || createValidId(dim.dimensionKey);
+                        var 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_operations1 = dim.operations) === null || _dim_operations1 === void 0 ? void 0 : _dim_operations1.sortFunction) || void 0,
+                            behavior: dim.behavior || {
+                                extents: "circular"
+                            },
+                            navigationRules: dim.navigationRules || {
+                                sibling_sibling: rules.length ? _to_consumable_array(rules.shift()) : [
+                                    "previous_" + dim.dimensionKey,
+                                    "next_" + dim.dimensionKey
+                                ],
+                                parent_child: [
+                                    "parent_" + dim.dimensionKey,
+                                    "child"
+                                ]
+                            }
+                        };
+                        nodes[id2] = {
+                            id: id2,
+                            renderId: renderId,
+                            derivedNode: dim.dimensionKey,
+                            edges: [],
+                            dimensionLevel: 1,
+                            data: dimensions[dim.dimensionKey],
+                            renderingStrategy: dim.renderingStrategy || "singleSquare"
+                        };
+                    }
+                    var dimension = dimensions[dim.dimensionKey];
+                    var targetDivision = null;
+                    if (dim.type === "categorical") {
+                        var _dim_divisionOptions;
+                        var divisionId = typeof ((_dim_divisionOptions = dim.divisionOptions) === null || _dim_divisionOptions === void 0 ? void 0 : _dim_divisionOptions.divisionNodeIds) === "function" ? dim.divisionOptions.divisionNodeIds(dim.dimensionKey, value, i) : createValidId(dimension.nodeId + "_" + value);
+                        targetDivision = dimension.divisions[divisionId];
+                        if (!targetDivision) {
+                            var _dim_divisionOptions1, _dim_divisionOptions2, _dim_divisionOptions3;
+                            targetDivision = dimension.divisions[divisionId] = {
+                                id: divisionId,
+                                sortFunction: ((_dim_divisionOptions1 = dim.divisionOptions) === null || _dim_divisionOptions1 === void 0 ? void 0 : _dim_divisionOptions1.sortFunction) || void 0,
+                                values: {}
+                            };
+                            var divisionRenderId = typeof ((_dim_divisionOptions2 = dim.divisionOptions) === null || _dim_divisionOptions2 === void 0 ? void 0 : _dim_divisionOptions2.divisionRenderIds) === "function" ? dim.divisionOptions.divisionRenderIds(dim.dimensionKey, value, i) : divisionId;
+                            nodes[divisionId] = {
+                                id: divisionId,
+                                renderId: divisionRenderId,
+                                derivedNode: dim.dimensionKey,
+                                edges: [],
+                                dimensionLevel: 2,
+                                data: _object_spread({}, targetDivision),
+                                renderingStrategy: ((_dim_divisionOptions3 = dim.divisionOptions) === null || _dim_divisionOptions3 === void 0 ? void 0 : _dim_divisionOptions3.renderingStrategy) || "singleSquare"
+                            };
+                            nodes[divisionId].data[dim.dimensionKey] = value;
+                        }
+                    } else {
+                        targetDivision = dimension.divisions[dimension.nodeId];
+                        if (!targetDivision) {
+                            var _dim_divisionOptions4;
+                            targetDivision = dimension.divisions[dimension.nodeId] = {
+                                id: dimension.nodeId,
+                                sortFunction: ((_dim_divisionOptions4 = dim.divisionOptions) === null || _dim_divisionOptions4 === void 0 ? void 0 : _dim_divisionOptions4.sortFunction) || void 0,
+                                values: {}
+                            };
+                        }
+                        if (!dim.operations) {
+                            dim.operations = {};
+                        }
+                        var 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);
+                        }
+                    }
+                    var id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
+                    targetDivision.values[d[id]] = d;
+                }
+            }
+            i++;
+        });
+    });
+    Object.keys(dimensions).forEach(function(s) {
+        var dimension = dimensions[s];
+        var divisions = dimension.divisions;
+        if (dimension.type === "numerical") {
+            divisions[dimension.nodeId].values = Object.fromEntries(Object.entries(divisions[dimension.nodeId].values).sort(function(a, b) {
+                return typeof dimension.sortFunction === "function" ? dimension.sortFunction(a[1], b[1], dimension) : a[1][s] - b[1][s];
+            }));
+            var values = divisions[dimension.nodeId].values;
+            if (dimension.numericalExtents[0] !== Infinity && dimension.subdivisions !== 1) {
+                var valueKeys = Object.keys(values);
+                var subDivisions = typeof dimension.subdivisions === "function" ? dimension.subdivisions(s, values) : dimension.subdivisions;
+                var range = dimension.numericalExtents[1] - dimension.numericalExtents[0];
+                var interval = range / subDivisions;
+                var i = dimension.numericalExtents[0] + interval;
+                var divisionCount = 0;
+                var index = 0;
+                for(i = dimension.numericalExtents[0] + interval; i <= dimension.numericalExtents[1]; i += interval){
+                    var _dimension_divisionOptions, _dimension_divisionOptions1, _dimension_divisionOptions2, _dimension_divisionOptions3;
+                    var divisionId = typeof ((_dimension_divisionOptions = dimension.divisionOptions) === null || _dimension_divisionOptions === void 0 ? void 0 : _dimension_divisionOptions.divisionNodeIds) === "function" ? dimension.divisionOptions.divisionNodeIds(s, i, i) : dimension.nodeId + "_" + i;
+                    dimension.divisions[divisionId] = {
+                        id: divisionId,
+                        sortFunction: ((_dimension_divisionOptions1 = dimension.divisionOptions) === null || _dimension_divisionOptions1 === void 0 ? void 0 : _dimension_divisionOptions1.sortFunction) || void 0,
+                        values: {}
+                    };
+                    var divisionRenderId = typeof ((_dimension_divisionOptions2 = dimension.divisionOptions) === null || _dimension_divisionOptions2 === void 0 ? void 0 : _dimension_divisionOptions2.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_divisionOptions3 = dimension.divisionOptions) === null || _dimension_divisionOptions3 === void 0 ? void 0 : _dimension_divisionOptions3.renderingStrategy) || "singleSquare"
+                    };
+                    var limit = false;
+                    while(!limit && index < valueKeys.length){
+                        var node = values[valueKeys[index]];
+                        var 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(function(a, b) {
+                return dimension.sortFunction(a[1], b[1], dimension);
+            }));
+        }
+        var divisionKeys = Object.keys(dimension.divisions);
+        divisionKeys.forEach(function(d) {
+            var division = dimension.divisions[d];
+            if (typeof division.sortFunction === "function") {
+                division.values = Object.fromEntries(Object.entries(division.values).sort(function(a, b) {
+                    return dimension.sortFunction(a[1], b[1], division);
+                }));
+            }
+        });
+    });
+    if (options.dimensions.adjustDimensions) {
+        dimensions = options.dimensions.adjustDimensions(dimensions);
+    }
+    return dimensions;
+};
+var buildEdges = function(options, nodes, dimensions) {
+    var edges = {};
+    var addEdgeToNode = function(nodeId, edgeId) {
+        if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
+            nodes[nodeId].edges.push(edgeId);
+        }
+    };
+    var createEdge = function(source, target, rules, addTo) {
+        var id = "".concat(source, "-").concat(target);
+        var targetId = !options.useDirectedEdges ? id : "".concat(target, "-").concat(id);
+        var addToSource = !addTo || addTo === "source";
+        var addToTarget = !addTo || addTo === "target";
+        var checkEdgeRules = function(eId) {
+            if (edges[eId]) {
+                var _edges_eId_navigationRules;
+                (_edges_eId_navigationRules = edges[eId].navigationRules).push.apply(_edges_eId_navigationRules, _to_consumable_array(rules || []));
+            } else {
+                edges[eId] = {
+                    source: source,
+                    target: target,
+                    navigationRules: rules ? _to_consumable_array(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) {
+        var _options_dimensions_parentOptions_level1Options, _options_dimensions_parentOptions, _options_dimensions, _options_dimensions1, _po_level1Options_behavior, _po_level1Options, _po_level1Options_navigationRules, _po_level1Options1, _po_level1Options_navigationRules1, _po_level1Options2;
+        var dimensionKeys = Object.keys(dimensions);
+        var hasOrder = (_options_dimensions = options.dimensions) === null || _options_dimensions === void 0 ? void 0 : (_options_dimensions_parentOptions = _options_dimensions.parentOptions) === null || _options_dimensions_parentOptions === void 0 ? void 0 : (_options_dimensions_parentOptions_level1Options = _options_dimensions_parentOptions.level1Options) === null || _options_dimensions_parentOptions_level1Options === void 0 ? void 0 : _options_dimensions_parentOptions_level1Options.order;
+        var order = hasOrder || dimensionKeys;
+        var l = 0;
+        var po = ((_options_dimensions1 = options.dimensions) === null || _options_dimensions1 === void 0 ? void 0 : _options_dimensions1.parentOptions) || {};
+        var extents = ((_po_level1Options = po.level1Options) === null || _po_level1Options === void 0 ? void 0 : (_po_level1Options_behavior = _po_level1Options.behavior) === null || _po_level1Options_behavior === void 0 ? void 0 : _po_level1Options_behavior.extents) || "terminal";
+        var level0 = po.addLevel0;
+        var parentRules = level0 ? ((_po_level1Options1 = po.level1Options) === null || _po_level1Options1 === void 0 ? void 0 : (_po_level1Options_navigationRules = _po_level1Options1.navigationRules) === null || _po_level1Options_navigationRules === void 0 ? void 0 : _po_level1Options_navigationRules.parent_child) || [
+            "parent",
+            "child"
+        ] : [];
+        var siblingRules = ((_po_level1Options2 = po.level1Options) === null || _po_level1Options2 === void 0 ? void 0 : (_po_level1Options_navigationRules1 = _po_level1Options2.navigationRules) === null || _po_level1Options_navigationRules1 === void 0 ? void 0 : _po_level1Options_navigationRules1.sibling_sibling) || [
+            "left",
+            "right"
+        ];
+        var 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(function(n) {
+            var 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) {
+                var 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(function(s) {
+            var _dimension_behavior;
+            var dimension = dimensions[s];
+            var extents2 = ((_dimension_behavior = dimension.behavior) === null || _dimension_behavior === void 0 ? void 0 : _dimension_behavior.extents) || "circular";
+            if (!dimension.divisions) {
+                console.error("Parsing dimensions. The dimension using the key ".concat(s, " is missing the divisions property. dimension.divisions should be supplied. ").concat(JSON.stringify(dimension), "."));
+            }
+            var divisionKeys = Object.keys(dimension.divisions);
+            var firstDivision = dimension.divisions[divisionKeys[0]];
+            if (divisionKeys.length !== 1) {
+                createEdge(dimension.nodeId, firstDivision.id, dimension.navigationRules.parent_child, "source");
+            } else {
+                var valueKeys = Object.keys(firstDivision.values);
+                var 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");
+            }
+            var j = 0;
+            divisionKeys.forEach(function(d) {
+                var 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);
+                }
+                var 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");
+                }
+                var 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");
+                var i = 0;
+                if (valueKeys.length > 1) {
+                    valueKeys.forEach(function(vk) {
+                        var v = division.values[vk];
+                        var id = typeof options.idKey === "function" ? options.idKey(v) : options.idKey;
+                        var 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") {
+                            var 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) {
+                                var targetId1 = 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]][targetId1], dimension.navigationRules.sibling_sibling);
+                            } else {
+                                var targetId2 = 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]][targetId2], 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) {
+                            var targetId3 = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[i + 1]]) : options.idKey;
+                            createEdge(v[id], division.values[valueKeys[i + 1]][targetId3], dimension.navigationRules.sibling_sibling);
+                        }
+                        if (!i && extents2 === "bridgedCousins") {
+                            if (j !== 0) {
+                                var targetId4 = 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]][targetId4], v[id], dimension.navigationRules.sibling_sibling);
+                            } else {
+                                var targetId5 = 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]][targetId5], 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(function(nodeKey) {
+        var _options_genericEdges;
+        var node = nodes[nodeKey];
+        if ((_options_genericEdges = options.genericEdges) === null || _options_genericEdges === void 0 ? void 0 : _options_genericEdges.length) {
+            options.genericEdges.forEach(function(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 = function(options, edges, dimensions) {
+    var rules = options.navigationRules;
+    if (!rules) {
+        var 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 ".concat(dimKeys.length, ". Dimensions counted: ").concat(dimKeys.join(", "), "."));
+        }
+        var importedRules = {};
+        var used = {};
+        var needsKeys = {};
+        var sparePairs = _to_consumable_array(TypicallyUnreservedKeyPairs);
+        var spareKeys = _to_consumable_array(TypicallyUnreservedKeys);
+        var checkKeys = function(k1, k2) {
+            var isPair = k1 && k2;
+            var k1Assigned = false;
+            var k2Assigned = false;
+            if (importedRules[k1] || used[k1]) {
+                used[k1] = _object_spread({}, importedRules[k1]);
+                k1Assigned = true;
+            }
+            if (k2 && (importedRules[k2] || used[k2])) {
+                used[k2] = _object_spread({}, 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.");
+                }
+                var pair = _to_consumable_array(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) {
+                    var key = spareKeys.shift();
+                    var newPairs = [];
+                    sparePairs.forEach(function(p) {
+                        if (key !== p[0] && key !== p[1]) {
+                            newPairs.push(p);
+                        }
+                    });
+                    sparePairs = newPairs;
+                    used[k1] = {
+                        direction: options.useDirectedEdges ? "target" : "source",
+                        key: key
+                    };
+                }
+                if (k2 && !used[k2] && spareKeys.length) {
+                    var key1 = spareKeys.shift();
+                    var newPairs1 = [];
+                    sparePairs.forEach(function(p) {
+                        if (key1 !== p[0] && key1 !== p[1]) {
+                            newPairs1.push(p);
+                        }
+                    });
+                    sparePairs = newPairs1;
+                    used[k2] = {
+                        direction: "target",
+                        key: key1
+                    };
+                }
+                if (!spareKeys.length) {
+                    if (!used[k1]) {
+                        needsKeys[k1] = k1;
+                    }
+                    if (k2 && !used[k2]) {
+                        needsKeys[k2] = k2;
+                    }
+                }
+            }
+        };
+        Object.keys(GenericFullNavigationRules).forEach(function(r) {
+            var rule = _object_spread({}, GenericFullNavigationRules[r]);
+            if (options.useDirectedEdges) {
+                rule.direction = "target";
+            }
+            importedRules[r] = rule;
+        });
+        if (dimKeys.length) {
+            var _options_dimensions_parentOptions, _options_dimensions;
+            if ((_options_dimensions = options.dimensions) === null || _options_dimensions === void 0 ? void 0 : (_options_dimensions_parentOptions = _options_dimensions.parentOptions) === null || _options_dimensions_parentOptions === void 0 ? void 0 : _options_dimensions_parentOptions.addLevel0) {
+                var _options_dimensions_parentOptions_level1Options_navigationRules, _options_dimensions_parentOptions_level1Options;
+                var rules2 = ((_options_dimensions_parentOptions_level1Options = options.dimensions.parentOptions.level1Options) === null || _options_dimensions_parentOptions_level1Options === void 0 ? void 0 : (_options_dimensions_parentOptions_level1Options_navigationRules = _options_dimensions_parentOptions_level1Options.navigationRules) === null || _options_dimensions_parentOptions_level1Options_navigationRules === void 0 ? void 0 : _options_dimensions_parentOptions_level1Options_navigationRules.parent_child) || [
+                    "parent",
+                    "child"
+                ];
+                checkKeys(rules2[0], rules2[1]);
+            }
+            dimKeys.forEach(function(d) {
+                var pc = dimensions[d].navigationRules.parent_child;
+                var ss = dimensions[d].navigationRules.sibling_sibling;
+                checkKeys(pc[0], pc[1]);
+                checkKeys(ss[0], ss[1]);
+            });
+        }
+        Object.keys(edges).forEach(function(e) {
+            edges[e].navigationRules.forEach(function(rule) {
+                if (!used[rule]) {
+                    checkKeys(rule);
+                }
+            });
+        });
+        if (Object.keys(needsKeys).length) {
+            var usedKeys = {};
+            Object.keys(used).forEach(function(k) {
+                usedKeys[used[k].key] = used[k].key;
+            });
+            Object.keys(importedRules).forEach(function(r) {
+                if (!usedKeys[importedRules[r].key] && !SemanticKeys[importedRules[r].key]) {
+                    spareKeys.push(importedRules[r].key);
+                }
+            });
+            var recheckKeys = _object_spread({}, needsKeys);
+            needsKeys = {};
+            Object.keys(recheckKeys).forEach(function(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: ".concat(Object.keys(needsKeys).join(", "), "."));
+            }
+        }
+        rules = used;
+    }
+    return rules;
+};
+var buildStructure = function(options) {
+    if (options.addIds) {
+        addSimpleDataIDs(options);
+    }
+    var nodes = buildNodes(options);
+    var dimensions = scaffoldDimensions(options, nodes);
+    var edges = buildEdges(options, nodes, dimensions);
+    var navigationRules = buildRules(options, edges, dimensions);
+    return {
+        nodes: nodes,
+        edges: edges,
+        dimensions: dimensions,
+        navigationRules: navigationRules
+    };
+};
 // src/input.ts
 var input_default = function(options) {
     var inputHandler = {};
@@ -533,14 +1201,14 @@ var rendering_default = function(options) {
     var initialized = false;
     var defaults = {
         cssClass: NodeElementDefaults.cssClass,
-        dimensions: _object_spread({}, NodeElementDefaults.dimensions),
+        spatialProperties: _object_spread({}, NodeElementDefaults.spatialProperties),
         semantics: _object_spread({}, NodeElementDefaults.semantics),
         parentSemantics: _object_spread({}, NodeElementDefaults.parentSemantics),
         existingElement: _object_spread({}, NodeElementDefaults.existingElement)
     };
     if (options.defaults) {
         defaults.cssClass = options.defaults.cssClass || defaults.cssClass;
-        defaults.dimensions = options.defaults.dimensions ? _object_spread({}, defaults.dimensions, options.defaults.dimensions) : defaults.dimensions;
+        defaults.spatialProperties = options.defaults.spatialProperties ? _object_spread({}, defaults.spatialProperties, options.defaults.spatialProperties) : defaults.spatialProperties;
         defaults.semantics = options.defaults.semantics ? _object_spread({}, defaults.semantics, options.defaults.semantics) : defaults.semantics;
         defaults.parentSemantics = options.defaults.parentSemantics ? _object_spread({}, defaults.parentSemantics, options.defaults.parentSemantics) : defaults.parentSemantics;
         defaults.existingElement = options.defaults.existingElement ? _object_spread({}, defaults.existingElement, options.defaults.existingElement) : defaults.existingElement;
@@ -628,19 +1296,19 @@ var rendering_default = function(options) {
             return;
         }
         var useExisting = false;
-        var existingDimensions = {};
+        var existingSpatialProperties = {};
         var resolveProp = function(prop, subprop, checkExisting) {
             var p1 = d[prop] || defaults[prop];
-            var s1 = !(checkExisting && useExisting) ? p1[subprop] : existingDimensions[subprop];
+            var s1 = !(checkExisting && useExisting) ? p1[subprop] : existingSpatialProperties[subprop];
             var 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");
-        var width = parseFloat(resolveProp("dimensions", "width", true) || 0);
-        var height = parseFloat(resolveProp("dimensions", "height", true) || 0);
-        var x = parseFloat(resolveProp("dimensions", "x", true) || 0);
-        var y = parseFloat(resolveProp("dimensions", "y", true) || 0);
+        useExisting = resolveProp("existingElement", "useForSpatialProperties");
+        existingSpatialProperties = resolveProp("existingElement", "spatialProperties");
+        var width = parseFloat(resolveProp("spatialProperties", "width", true) || 0);
+        var height = parseFloat(resolveProp("spatialProperties", "height", true) || 0);
+        var x = parseFloat(resolveProp("spatialProperties", "x", true) || 0);
+        var y = parseFloat(resolveProp("spatialProperties", "y", true) || 0);
         var node = document.createElement(resolveProp("parentSemantics", "elementType"));
         var wrapperAttrs = resolveProp("parentSemantics", "attributes");
         if (typeof wrapperAttrs === "object") {
@@ -677,7 +1345,7 @@ var rendering_default = function(options) {
         }
         nodeText.setAttribute("aria-label", label);
         node.appendChild(nodeText);
-        var hasPath = resolveProp("dimensions", "path");
+        var hasPath = resolveProp("spatialProperties", "path");
         if (hasPath) {
             var totalWidth = width + x + 10;
             var totalHeight = height + y + 10;