@data-navigator/bokeh-wrapper 0.2.0

package/dist/index.cjs

@@ -0,0 +1,781 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  addDataNavigator: () => addDataNavigator,
+  buildChartDescription: () => buildChartDescription,
+  buildNodeLabel: () => buildNodeLabel,
+  prepareNodeSemantics: () => prepareNodeSemantics
+});
+module.exports = __toCommonJS(src_exports);
+var import_data_navigator = __toESM(require("data-navigator"), 1);
+
+// src/structure-builder.ts
+function resolveEl(ref) {
+  if (typeof ref === "string")
+    return document.getElementById(ref);
+  return ref instanceof HTMLElement ? ref : null;
+}
+function safeId(s) {
+  return String(s).replace(/\s+/g, "-").replace(/[^\w-]/g, "");
+}
+function isNumericField(data, field) {
+  return data.some((d) => d[field] != null && !isNaN(Number(d[field])));
+}
+function hasMultiplePerX(data, xField) {
+  var _a;
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of data) {
+    const v = d[xField];
+    counts.set(v, ((_a = counts.get(v)) != null ? _a : 0) + 1);
+  }
+  return Array.from(counts.values()).some((c) => c > 1);
+}
+function resolveChartType(type, data, xField, yField, groupField) {
+  if (type && type !== "auto")
+    return type;
+  if (!data.length)
+    return "bar";
+  if (groupField && xField && yField) {
+    return hasMultiplePerX(data, xField) ? "stacked_bar" : "multiline";
+  }
+  if (xField && yField) {
+    if (isNumericField(data, xField) && isNumericField(data, yField))
+      return "cartesian";
+    if (!isNumericField(data, xField))
+      return "bar";
+    return "line";
+  }
+  if (xField) {
+    return isNumericField(data, xField) ? "line" : "bar";
+  }
+  return "bar";
+}
+var exitEdge = {
+  edgeId: "dn-exit",
+  edge: {
+    source: (_d, c) => c,
+    target: () => "",
+    navigationRules: ["exit"]
+  }
+};
+var baseNavRules = {
+  // Primary (x-axis) navigation
+  left: { key: "ArrowLeft", direction: "source" },
+  right: { key: "ArrowRight", direction: "target" },
+  // Secondary encoding (y-axis / group) navigation
+  up: { key: "ArrowUp", direction: "source" },
+  down: { key: "ArrowDown", direction: "target" },
+  // Tertiary encoding navigation  ([  /  ])
+  backward: { key: "BracketLeft", direction: "source" },
+  forward: { key: "BracketRight", direction: "target" },
+  // Hierarchy traversal
+  child: { key: "Enter", direction: "target" },
+  parent: { key: "Backspace", direction: "source" },
+  undo: { key: "Delete", direction: "source" },
+  // Encoding-specific parent shortcuts (W = x-axis parent, J = y-axis parent, \ = tertiary parent)
+  xParent: { key: "KeyW", direction: "source" },
+  yParent: { key: "KeyJ", direction: "source" },
+  zParent: { key: "Backslash", direction: "source" },
+  // Exit and help
+  exit: { key: "Escape", direction: "target" },
+  help: { key: "KeyY", direction: "target" }
+};
+function buildFlatStructure(data, xField, idField) {
+  const sorted = xField ? [...data].sort((a, b) => {
+    const av = a[xField];
+    const bv = b[xField];
+    if (typeof av === "number" && typeof bv === "number")
+      return av - bv;
+    return String(av) < String(bv) ? -1 : 1;
+  }) : [...data];
+  const ids = sorted.map(
+    (d, i) => idField && d[idField] != null ? safeId(d[idField]) : `dn-item-${i}`
+  );
+  const augmented = sorted.map((d, i) => __spreadProps(__spreadValues({}, d), { _dnId: ids[i] }));
+  return {
+    data: augmented,
+    idKey: "_dnId",
+    navigationRules: baseNavRules,
+    genericEdges: [
+      {
+        edgeId: "dn-right",
+        edge: {
+          source: (_d, c) => c,
+          target: (_d, c) => {
+            const i = ids.indexOf(c);
+            return ids[(i + 1) % ids.length];
+          },
+          navigationRules: ["right"]
+        }
+      },
+      {
+        edgeId: "dn-left",
+        edge: {
+          source: (_d, c) => {
+            const i = ids.indexOf(c);
+            return ids[(i - 1 + ids.length) % ids.length];
+          },
+          target: (_d, c) => c,
+          navigationRules: ["left"]
+        }
+      },
+      exitEdge
+    ]
+  };
+}
+function buildCrosslineStructure(data, xField, groupField) {
+  const augNavRules = __spreadValues({}, baseNavRules);
+  augNavRules.up = { key: "ArrowUp", direction: "target" };
+  augNavRules.down = { key: "ArrowDown", direction: "source" };
+  return {
+    data,
+    idKey: "id",
+    addIds: true,
+    navigationRules: augNavRules,
+    dimensions: {
+      values: [
+        {
+          dimensionKey: xField,
+          type: "categorical",
+          behavior: {
+            extents: "circular",
+            childmostNavigation: "across"
+          },
+          // left/right siblings at this dimension level; W drills back up
+          navigationRules: {
+            sibling_sibling: ["left", "right"],
+            parent_child: ["xParent", "child"]
+          }
+        },
+        {
+          dimensionKey: groupField,
+          type: "categorical",
+          behavior: {
+            extents: "circular",
+            childmostNavigation: "across"
+          },
+          // up/down siblings at this dimension level; J drills back up
+          navigationRules: {
+            sibling_sibling: ["up", "down"],
+            parent_child: ["yParent", "child"]
+          }
+        }
+      ]
+    },
+    genericEdges: [exitEdge]
+  };
+}
+function buildCartesianStructure(data, xField, yField, idField) {
+  const augmented = data.map((d, i) => {
+    const baseId = idField && d[idField] != null ? safeId(String(d[idField])) : d["id"] != null ? safeId(String(d["id"])) : `dn-pt-${i}`;
+    return __spreadProps(__spreadValues({}, d), { id: baseId });
+  });
+  const autoSubdivs = (_key, values) => Math.min(12, Math.max(3, Math.ceil(Math.sqrt(Object.keys(values).length))));
+  const augNavRules = __spreadValues({}, baseNavRules);
+  augNavRules.up = { key: "ArrowUp", direction: "target" };
+  augNavRules.down = { key: "ArrowDown", direction: "source" };
+  return {
+    data: augmented,
+    idKey: "id",
+    navigationRules: augNavRules,
+    dimensions: {
+      values: [
+        {
+          dimensionKey: xField,
+          type: "numerical",
+          behavior: {
+            extents: "terminal"
+          },
+          operations: { createNumericalSubdivisions: autoSubdivs },
+          navigationRules: {
+            sibling_sibling: ["left", "right"],
+            parent_child: ["xParent", "child"]
+          }
+        },
+        {
+          dimensionKey: yField,
+          type: "numerical",
+          behavior: {
+            extents: "terminal"
+          },
+          operations: {
+            createNumericalSubdivisions: autoSubdivs
+            // sortFunction: (a:any,b:any) => {
+            //     console.log("sorting dim",yField,a,b)
+            //     return b[yField] - a[yField]
+            // }
+          },
+          // divisionOptions: {
+          //     sortFunction: (a:any,b:any) => {
+          //         console.log("sorting div",yField,a,b)
+          //         return b[yField] - a[yField]
+          //     }
+          // },
+          navigationRules: {
+            sibling_sibling: ["down", "up"],
+            parent_child: ["yParent", "child"]
+          }
+        }
+      ]
+    },
+    genericEdges: [exitEdge]
+  };
+}
+function buildCartesianGroupedStructure(data, xField, yField, groupField, idField) {
+  const augmented = data.map((d, i) => {
+    const baseId = idField && d[idField] != null ? safeId(String(d[idField])) : d["id"] != null ? safeId(String(d["id"])) : `dn-pt-${i}`;
+    return __spreadProps(__spreadValues({}, d), { id: baseId });
+  });
+  const autoSubdivs = (_key, values) => Math.min(12, Math.max(3, Math.ceil(Math.sqrt(Object.keys(values).length))));
+  const augNavRules = __spreadValues({}, baseNavRules);
+  augNavRules.up = { key: "ArrowUp", direction: "target" };
+  augNavRules.down = { key: "ArrowDown", direction: "source" };
+  return {
+    data: augmented,
+    idKey: "id",
+    navigationRules: augNavRules,
+    dimensions: {
+      values: [
+        {
+          dimensionKey: xField,
+          type: "numerical",
+          behavior: { extents: "terminal" },
+          operations: { createNumericalSubdivisions: autoSubdivs },
+          navigationRules: {
+            sibling_sibling: ["left", "right"],
+            parent_child: ["xParent", "child"]
+          }
+        },
+        {
+          dimensionKey: yField,
+          type: "numerical",
+          behavior: { extents: "terminal" },
+          operations: { createNumericalSubdivisions: autoSubdivs },
+          navigationRules: {
+            sibling_sibling: ["down", "up"],
+            parent_child: ["yParent", "child"]
+          }
+        },
+        {
+          dimensionKey: groupField,
+          type: "categorical",
+          behavior: { extents: "circular" },
+          navigationRules: {
+            sibling_sibling: ["backward", "forward"],
+            parent_child: ["zParent", "child"]
+          }
+        }
+      ]
+    },
+    genericEdges: [exitEdge]
+  };
+}
+function buildDimensionStructure(data, dimensionKey, idField, compositeKey, compressSparseDivisions) {
+  let idKey;
+  let augmented = data;
+  if (compositeKey) {
+    augmented = data.map((d) => __spreadProps(__spreadValues({}, d), {
+      _dnId: `${safeId(d[dimensionKey])}-${safeId(d[compositeKey])}`
+    }));
+    idKey = "_dnId";
+  } else if (idField) {
+    idKey = idField;
+  } else {
+    idKey = dimensionKey;
+  }
+  return {
+    data: augmented,
+    idKey,
+    navigationRules: baseNavRules,
+    dimensions: {
+      values: [
+        {
+          dimensionKey,
+          type: "categorical",
+          behavior: { extents: "circular" },
+          // Explicitly name rules so edge tags match keys in baseNavRules.
+          // Without this, data-navigator auto-generates 'parent_<dimensionKey>'
+          // (e.g. 'parent_city'), which won't match the 'parent' rule.
+          operations: {
+            compressSparseDivisions: compressSparseDivisions || false
+          },
+          navigationRules: {
+            sibling_sibling: ["left", "right"],
+            parent_child: ["parent", "child"]
+          }
+        }
+      ]
+    },
+    genericEdges: [exitEdge]
+  };
+}
+var humanChartType = {
+  bar: "bar chart",
+  hbar: "horizontal bar chart",
+  scatter: "scatter plot",
+  cartesian: "scatter plot",
+  line: "line chart",
+  multiline: "multi-line chart",
+  crossline: "cross-navigable multi-line chart",
+  stacked_bar: "stacked bar chart"
+};
+function buildChartDescription(options, dimensionCount = 1) {
+  var _a;
+  const { data, type, xField, yField, groupField, title } = options;
+  const chartType = resolveChartType(type, data, xField, yField, groupField);
+  const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  } else if (xField && yField) {
+    parts.push(`${cap(xField)} and ${cap(yField)}`);
+  } else if (xField) {
+    parts.push(cap(xField));
+  }
+  parts.push((_a = humanChartType[chartType]) != null ? _a : chartType);
+  if (xField) {
+    const axisType = isNumericField(data, xField) ? "numerical" : "categorical";
+    parts.push(`${xField} along x axis (${axisType})`);
+  }
+  if (yField) {
+    const axisType = isNumericField(data, yField) ? "numerical" : "categorical";
+    parts.push(`${yField} along y axis (${axisType})`);
+  }
+  if (groupField) {
+    parts.push(`grouped by ${groupField}`);
+  }
+  const total = data.length;
+  if (dimensionCount > 1) {
+    parts.push(`contains ${dimensionCount} dimensions and ${total} total data points`);
+  } else {
+    let divisionKey;
+    if (chartType === "bar" || chartType === "hbar")
+      divisionKey = xField;
+    else if (chartType === "stacked_bar")
+      divisionKey = xField;
+    else if (chartType === "multiline")
+      divisionKey = groupField;
+    if (divisionKey) {
+      const divisions = new Set(data.map((d) => d[divisionKey])).size;
+      if (divisions !== total) {
+        parts.push(`contains ${divisions} divisions and ${total} total data points`);
+      } else {
+        parts.push(`contains ${total} total data points`);
+      }
+    } else {
+      parts.push(`contains ${total} total data points`);
+    }
+  }
+  return parts.map(cap).join(". ") + ".";
+}
+function buildStructureOptions(options) {
+  var _a;
+  const { data, type, xField, yField, groupField, idField, structureOptions = {} } = options;
+  const chartType = resolveChartType(type, data, xField, yField, groupField);
+  let base;
+  switch (chartType) {
+    case "scatter":
+    case "line":
+      base = buildFlatStructure(data, xField, idField);
+      break;
+    case "bar":
+    case "hbar": {
+      const catField = xField || Object.keys((_a = data[0]) != null ? _a : {}).find((k) => !isNumericField(data, k)) || "x";
+      base = buildDimensionStructure(data, catField, idField, "", options.compressSparseDivisions);
+      break;
+    }
+    case "stacked_bar": {
+      const stackX = xField || "x";
+      const stackGroup = groupField || "group";
+      base = buildCrosslineStructure(data, stackX, stackGroup);
+      break;
+    }
+    case "multiline": {
+      const lineGroup = groupField || "series";
+      base = buildDimensionStructure(data, lineGroup, idField, xField, options.compressSparseDivisions);
+      break;
+    }
+    case "cartesian": {
+      const cartX = xField || "x";
+      const cartY = yField || "y";
+      if (groupField) {
+        base = buildCartesianGroupedStructure(data, cartX, cartY, groupField, idField);
+      } else {
+        base = buildCartesianStructure(data, cartX, cartY, idField);
+      }
+      break;
+    }
+    case "crossline": {
+      const crossX = xField || "x";
+      const crossGroup = groupField || "series";
+      base = buildCrosslineStructure(data, crossX, crossGroup);
+      break;
+    }
+    default:
+      base = buildFlatStructure(data, xField, idField);
+  }
+  return __spreadValues(__spreadValues({}, base), structureOptions);
+}
+function buildCommandLabels(options) {
+  const { data, type, xField, yField, groupField, commandLabels = {} } = options;
+  const chartType = resolveChartType(type, data, xField, yField, groupField);
+  const auto = {};
+  switch (chartType) {
+    case "bar":
+    case "hbar":
+      auto.left = `Move to previous ${xField != null ? xField : "category"}`;
+      auto.right = `Move to next ${xField != null ? xField : "category"}`;
+      auto.child = `Drill into ${xField != null ? xField : "category"} detail`;
+      auto.parent = "Go back up";
+      auto.undo = "Go back up";
+      break;
+    case "scatter":
+    case "line":
+      auto.left = `Move to previous ${xField != null ? xField : "point"}`;
+      auto.right = `Move to next ${xField != null ? xField : "point"}`;
+      break;
+    case "stacked_bar":
+      auto.left = `Move to previous ${xField != null ? xField : "category"}`;
+      auto.right = `Move to next ${xField != null ? xField : "category"}`;
+      auto.up = `Move to previous ${groupField != null ? groupField : "group"}`;
+      auto.down = `Move to next ${groupField != null ? groupField : "group"}`;
+      auto.child = "Drill in";
+      auto.xParent = `Go up to ${xField != null ? xField : "category"} level`;
+      auto.yParent = `Go up to ${groupField != null ? groupField : "group"} level`;
+      break;
+    case "multiline":
+      auto.left = `Move to previous ${groupField != null ? groupField : "series"}`;
+      auto.right = `Move to next ${groupField != null ? groupField : "series"}`;
+      auto.child = `Drill into ${groupField != null ? groupField : "series"} data`;
+      auto.parent = "Go back up";
+      auto.undo = "Go back up";
+      break;
+    case "cartesian":
+      auto.left = `Move to previous ${xField != null ? xField : "x"} range`;
+      auto.right = `Move to next ${xField != null ? xField : "x"} range`;
+      auto.up = `Move to higher ${yField != null ? yField : "y"} range`;
+      auto.down = `Move to lower ${yField != null ? yField : "y"} range`;
+      auto.child = "Drill in";
+      auto.xParent = `Go up to ${xField != null ? xField : "x"} level`;
+      auto.yParent = `Go up to ${yField != null ? yField : "y"} level`;
+      if (groupField) {
+        auto.backward = `Move to previous ${groupField} group`;
+        auto.forward = `Move to next ${groupField} group`;
+        auto.zParent = `Go up to ${groupField} level`;
+      }
+      break;
+    case "crossline":
+      auto.left = `Move to previous ${xField != null ? xField : "x-axis point"}`;
+      auto.right = `Move to next ${xField != null ? xField : "x-axis point"}`;
+      auto.up = `Move to previous ${groupField != null ? groupField : "series"}`;
+      auto.down = `Move to next ${groupField != null ? groupField : "series"}`;
+      auto.child = "Drill in";
+      auto.xParent = `Go up to ${xField != null ? xField : "x-axis"} level`;
+      auto.yParent = `Go up to ${groupField != null ? groupField : "series"} level`;
+      break;
+  }
+  return __spreadValues(__spreadValues({}, auto), commandLabels);
+}
+function buildNodeLabel(node) {
+  const data = node.data;
+  if (!data)
+    return String(node.id);
+  if (typeof data.dimensionKey === "string" && data.divisions != null) {
+    const divCount = Object.keys(data.divisions).length;
+    return `${data.dimensionKey} dimension. Contains ${divCount} division${divCount !== 1 ? "s" : ""}.`;
+  }
+  if (data.values != null && typeof data.values === "object" && !Array.isArray(data.values)) {
+    const dimKey = node.derivedNode;
+    const dimValue = dimKey ? data[dimKey] : null;
+    if (dimValue != null) {
+      const childCount = Object.keys(data.values).length;
+      return `${dimValue}. Contains ${childCount} data point${childCount !== 1 ? "s" : ""}.`;
+    }
+    return String(node.id);
+  }
+  const parts = Object.entries(data).filter(
+    ([k, v]) => !k.startsWith("_") && v != null && typeof v !== "object" && typeof v !== "function"
+  ).map(([k, v]) => `${k}: ${v}`);
+  return parts.length > 0 ? parts.join(". ") + "." : String(node.id);
+}
+function prepareNodeSemantics(structure) {
+  var _a, _b;
+  for (const node of Object.values(structure.nodes)) {
+    const n = node;
+    if (!((_a = n.semantics) == null ? void 0 : _a.label)) {
+      n.semantics = __spreadProps(__spreadValues({}, (_b = n.semantics) != null ? _b : {}), { label: buildNodeLabel(n) });
+    }
+  }
+}
+
+// src/index.ts
+function resolveChatContainer(options, plotEl) {
+  var _a, _b;
+  if (options.chatContainer) {
+    const el = resolveEl(options.chatContainer);
+    if (el)
+      return { el, owned: false };
+  }
+  const div = document.createElement("div");
+  div.className = "dn-bokeh-wrapper";
+  (_b = (_a = plotEl.parentElement) == null ? void 0 : _a.insertBefore(div, plotEl.nextSibling)) != null ? _b : document.body.appendChild(div);
+  return { el: div, owned: true };
+}
+function setupKeyboardMode(structure, plotEl, options, entryPoint) {
+  var _a, _b;
+  const { onNavigate, onExit, renderingOptions = {} } = options;
+  const width = plotEl.clientWidth || 400;
+  const height = plotEl.clientHeight || 300;
+  let current = null;
+  let previous = null;
+  const resolvedEntry = entryPoint != null ? entryPoint : Object.keys(structure.nodes)[0];
+  const suffixId = `dn-bokeh-${Math.random().toString(36).slice(2, 6)}`;
+  const rendering = import_data_navigator.default.rendering({
+    elementData: structure.nodes,
+    defaults: __spreadValues({
+      cssClass: "dn-node",
+      spatialProperties: { x: 0, y: 0, width, height }
+    }, renderingOptions.defaults),
+    suffixId,
+    root: {
+      id: typeof options.plotContainer === "string" ? options.plotContainer : options.plotContainer.id || "dn-bokeh-root",
+      description: "Accessible data navigation",
+      width: "100%",
+      height: 0
+    },
+    entryButton: { include: true, callbacks: { click: enter } },
+    exitElement: { include: true }
+  });
+  rendering.initialize();
+  if (rendering.entryButton) {
+    rendering.entryButton.addEventListener("keydown", (e) => {
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        if (!current)
+          enter();
+      }
+    });
+  }
+  const input = import_data_navigator.default.input({
+    structure,
+    navigationRules: (_a = structure.navigationRules) != null ? _a : {},
+    entryPoint: resolvedEntry,
+    exitPoint: (_b = rendering.exitElement) == null ? void 0 : _b.id
+  });
+  function enter() {
+    const node = input.enter();
+    if (!node)
+      return;
+    navigate(node);
+  }
+  function navigate(node) {
+    if (!node.renderId)
+      node.renderId = node.id;
+    if (!node.spatialProperties) {
+      node.spatialProperties = { x: 0, y: 0, width, height };
+    }
+    if (previous)
+      rendering.remove(previous);
+    const el = rendering.render({ renderId: node.renderId, datum: node });
+    if (!el)
+      return;
+    el.style.width = "100%";
+    el.style.height = "100%";
+    el.style.top = "0";
+    el.style.left = "0";
+    el.addEventListener("keydown", (e) => {
+      const direction = input.keydownValidator(e);
+      if (direction) {
+        e.preventDefault();
+        if (direction === "exit") {
+          if (rendering.exitElement) {
+            rendering.exitElement.style.display = "block";
+            input.focus(rendering.exitElement.id);
+          }
+        } else {
+          const next = input.move(current, direction);
+          if (next)
+            navigate(next);
+        }
+      }
+    });
+    el.addEventListener("focus", () => {
+      if (onNavigate)
+        onNavigate(node);
+    });
+    input.focus(node.renderId);
+    previous = current;
+    current = node.id;
+  }
+  if (rendering.exitElement) {
+    rendering.exitElement.addEventListener("focus", () => {
+      if (current)
+        rendering.remove(current);
+      current = null;
+      if (onExit)
+        onExit();
+    });
+  }
+  return {
+    destroy() {
+      var _a2, _b2, _c, _d;
+      try {
+        (_b2 = (_a2 = rendering.wrapper) == null ? void 0 : _a2.remove) == null ? void 0 : _b2.call(_a2);
+      } catch (_) {
+      }
+      try {
+        (_d = (_c = rendering.exitElement) == null ? void 0 : _c.remove) == null ? void 0 : _d.call(_c);
+      } catch (_) {
+      }
+    },
+    getCurrentNode() {
+      var _a2;
+      return current ? (_a2 = structure.nodes[current]) != null ? _a2 : null : null;
+    }
+  };
+}
+function addDataNavigator(options) {
+  var _a, _b, _c, _d, _e;
+  const { mode = "text", onNavigate, onExit, onClick, onHover, llm } = options;
+  const plotEl = resolveEl(options.plotContainer);
+  if (!plotEl) {
+    throw new Error(
+      `@data-navigator/bokeh-wrapper: plotContainer "${options.plotContainer}" not found.`
+    );
+  }
+  const didSetInert = mode === "text";
+  if (didSetInert) {
+    plotEl.setAttribute("inert", "true");
+  }
+  const structOpts = buildStructureOptions(options);
+  const dimCount = (_c = (_b = (_a = structOpts.dimensions) == null ? void 0 : _a.values) == null ? void 0 : _b.length) != null ? _c : 0;
+  const resolveDescription = () => {
+    if (typeof options.describeRoot === "function")
+      return options.describeRoot(options);
+    if (typeof options.describeRoot === "string")
+      return options.describeRoot;
+    return buildChartDescription(options, dimCount);
+  };
+  if (dimCount > 1) {
+    const dims = structOpts.dimensions;
+    if (!dims.parentOptions)
+      dims.parentOptions = {};
+    if (!dims.parentOptions.addLevel0) {
+      const plotId = typeof options.plotContainer === "string" ? options.plotContainer.replace(/[^a-zA-Z0-9_-]/g, "") : "dn";
+      dims.parentOptions.addLevel0 = {
+        id: `${plotId}-chart-root`,
+        edges: [],
+        semantics: { label: resolveDescription() }
+      };
+    }
+  }
+  const structure = import_data_navigator.default.structure(structOpts);
+  if (dimCount === 1 && structure.dimensions) {
+    const desc = resolveDescription();
+    for (const dim of Object.values(structure.dimensions)) {
+      const node = structure.nodes[dim.nodeId];
+      if (node)
+        node.semantics = { label: desc };
+    }
+  }
+  prepareNodeSemantics(structure);
+  const level0Node = Object.values(structure.nodes).find((n) => n.dimensionLevel === 0);
+  const resolvedEntryPoint = (_e = level0Node == null ? void 0 : level0Node.id) != null ? _e : structure.dimensions ? (_d = structure.dimensions[Object.keys(structure.dimensions)[0]]) == null ? void 0 : _d.nodeId : void 0;
+  const cleanups = [];
+  let textChatInstance = null;
+  if (mode === "text" || mode === "both") {
+    const { el: chatEl, owned } = resolveChatContainer(options, plotEl);
+    textChatInstance = import_data_navigator.default.textChat({
+      structure,
+      container: chatEl,
+      entryPoint: resolvedEntryPoint,
+      data: options.data,
+      commandLabels: buildCommandLabels(options),
+      onNavigate,
+      onExit,
+      onClick,
+      onHover,
+      llm
+    });
+    if (owned) {
+      cleanups.push(() => {
+        var _a2;
+        try {
+          (_a2 = chatEl.parentElement) == null ? void 0 : _a2.removeChild(chatEl);
+        } catch (_) {
+        }
+      });
+    }
+  }
+  let keyboardMode = null;
+  if (mode === "keyboard" || mode === "both") {
+    keyboardMode = setupKeyboardMode(structure, plotEl, options, resolvedEntryPoint);
+    cleanups.push(() => keyboardMode == null ? void 0 : keyboardMode.destroy());
+  }
+  return {
+    destroy() {
+      textChatInstance == null ? void 0 : textChatInstance.destroy();
+      for (const cleanup of cleanups)
+        cleanup();
+      if (didSetInert)
+        plotEl.removeAttribute("inert");
+    },
+    getCurrentNode() {
+      var _a2, _b2;
+      return (_b2 = (_a2 = textChatInstance == null ? void 0 : textChatInstance.getCurrentNode()) != null ? _a2 : keyboardMode == null ? void 0 : keyboardMode.getCurrentNode()) != null ? _b2 : null;
+    },
+    structure
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addDataNavigator,
+  buildChartDescription,
+  buildNodeLabel,
+  prepareNodeSemantics
+});