data-navigator 2.2.3 → 2.3.0

package/dist/index.js

@@ -1,3 +1,43 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
 // src/consts.ts
 var SemanticKeys = {
   Escape: true,
@@ -399,10 +439,11 @@ var buildNodes = (options) => {
   return nodes;
 };
 var scaffoldDimensions = (options, nodes) => {
+  var _a, _b;
   let dimensions = {};
-  if (options.dimensions?.parentOptions?.addLevel0) {
+  if ((_b = (_a = options.dimensions) == null ? void 0 : _a.parentOptions) == null ? void 0 : _b.addLevel0) {
     let level0 = options.dimensions.parentOptions.addLevel0;
-    nodes[level0.id] = { ...level0, dimensionLevel: 0 };
+    nodes[level0.id] = __spreadProps(__spreadValues({}, level0), { dimensionLevel: 0 });
   }
   let rules = [...GenericFullNavigationDimensions];
   const setExtents = (val, dim) => {
@@ -415,6 +456,7 @@ var scaffoldDimensions = (options, nodes) => {
     let ods = options.dimensions.values || [];
     let i = 0;
     ods.forEach((dim) => {
+      var _a2, _b2, _c, _d, _e, _f, _g, _h;
       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(
@@ -425,7 +467,7 @@ var scaffoldDimensions = (options, nodes) => {
       }
       if (dim.dimensionKey in d) {
         let value = d[dim.dimensionKey];
-        let keepValue = typeof dim.operations?.filterFunction === "function" ? dim.operations.filterFunction(d, dim) : true;
+        let keepValue = typeof ((_a2 = dim.operations) == null ? void 0 : _a2.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";
@@ -440,8 +482,8 @@ var scaffoldDimensions = (options, nodes) => {
               numericalExtents: [Infinity, -Infinity],
               type: dim.type,
               operations: {
-                compressSparseDivisions: dim.operations?.compressSparseDivisions || false,
-                sortFunction: dim.operations?.sortFunction || void 0
+                compressSparseDivisions: ((_b2 = dim.operations) == null ? void 0 : _b2.compressSparseDivisions) || false,
+                sortFunction: ((_c = dim.operations) == null ? void 0 : _c.sortFunction) || void 0
               },
               behavior: dim.behavior || {
                 extents: "circular"
@@ -465,23 +507,23 @@ var scaffoldDimensions = (options, nodes) => {
           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) : createValidId(dimension.nodeId + "_" + value);
+            let divisionId = typeof ((_d = dim.divisionOptions) == null ? void 0 : _d.divisionNodeIds) === "function" ? dim.divisionOptions.divisionNodeIds(dim.dimensionKey, value, i) : createValidId(dimension.nodeId + "_" + value);
             targetDivision = dimension.divisions[divisionId];
             if (!targetDivision) {
               targetDivision = dimension.divisions[divisionId] = {
                 id: divisionId,
-                sortFunction: dim.divisionOptions?.sortFunction || void 0,
+                sortFunction: ((_e = dim.divisionOptions) == null ? void 0 : _e.sortFunction) || void 0,
                 values: {}
               };
-              let divisionRenderId = typeof dim.divisionOptions?.divisionRenderIds === "function" ? dim.divisionOptions.divisionRenderIds(dim.dimensionKey, value, i) : divisionId;
+              let divisionRenderId = typeof ((_f = dim.divisionOptions) == null ? void 0 : _f.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"
+                data: __spreadValues({}, targetDivision),
+                renderingStrategy: ((_g = dim.divisionOptions) == null ? void 0 : _g.renderingStrategy) || "singleSquare"
                 // not sure what defaults we want yet
               };
               nodes[divisionId].data[dim.dimensionKey] = value;
@@ -491,7 +533,7 @@ var scaffoldDimensions = (options, nodes) => {
             if (!targetDivision) {
               targetDivision = dimension.divisions[dimension.nodeId] = {
                 id: dimension.nodeId,
-                sortFunction: dim.divisionOptions?.sortFunction || void 0,
+                sortFunction: ((_h = dim.divisionOptions) == null ? void 0 : _h.sortFunction) || void 0,
                 values: {}
               };
             }
@@ -515,12 +557,14 @@ var scaffoldDimensions = (options, nodes) => {
     });
   });
   Object.keys(dimensions).forEach((s) => {
+    var _a2, _b2, _c, _d, _e;
     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.operations?.sortFunction === "function" ? dimension.operations.sortFunction(a[1], b[1], dimension) : a[1][s] - b[1][s];
+          var _a3;
+          return typeof ((_a3 = dimension.operations) == null ? void 0 : _a3.sortFunction) === "function" ? dimension.operations.sortFunction(a[1], b[1], dimension) : a[1][s] - b[1][s];
         })
       );
       let values = divisions[dimension.nodeId].values;
@@ -533,13 +577,13 @@ var scaffoldDimensions = (options, nodes) => {
         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;
+          let divisionId = typeof ((_a2 = dimension.divisionOptions) == null ? void 0 : _a2.divisionNodeIds) === "function" ? dimension.divisionOptions.divisionNodeIds(s, i, i) : dimension.nodeId + "_" + i;
           dimension.divisions[divisionId] = {
             id: divisionId,
-            sortFunction: dimension.divisionOptions?.sortFunction || void 0,
+            sortFunction: ((_b2 = dimension.divisionOptions) == null ? void 0 : _b2.sortFunction) || void 0,
             values: {}
           };
-          let divisionRenderId = typeof dimension.divisionOptions?.divisionRenderIds === "function" ? dimension.divisionOptions.divisionRenderIds(s, i, i) : divisionId;
+          let divisionRenderId = typeof ((_c = dimension.divisionOptions) == null ? void 0 : _c.divisionRenderIds) === "function" ? dimension.divisionOptions.divisionRenderIds(s, i, i) : divisionId;
           nodes[divisionId] = {
             id: divisionId,
             renderId: divisionRenderId,
@@ -547,7 +591,7 @@ var scaffoldDimensions = (options, nodes) => {
             edges: [],
             data: dimension.divisions[divisionId],
             dimensionLevel: 2,
-            renderingStrategy: dimension.divisionOptions?.renderingStrategy || "singleSquare"
+            renderingStrategy: ((_d = dimension.divisionOptions) == null ? void 0 : _d.renderingStrategy) || "singleSquare"
             // not sure what defaults we want yet
           };
           let limit = false;
@@ -566,7 +610,7 @@ var scaffoldDimensions = (options, nodes) => {
         }
         delete divisions[s];
       }
-    } else if (typeof dimension.operations?.sortFunction === "function") {
+    } else if (typeof ((_e = dimension.operations) == null ? void 0 : _e.sortFunction) === "function") {
       dimension.divisions = Object.fromEntries(
         Object.entries(divisions).sort((a, b) => {
           return dimension.operations.sortFunction(a[1], b[1], dimension);
@@ -596,7 +640,7 @@ var scaffoldDimensions = (options, nodes) => {
         const valueKeys = Object.keys(division.values);
         if (valueKeys.length <= 1) {
           valueKeys.forEach((vk) => {
-            values[vk] = { ...division.values[vk] };
+            values[vk] = __spreadValues({}, division.values[vk]);
           });
         } else {
           sparse = false;
@@ -621,6 +665,7 @@ var scaffoldDimensions = (options, nodes) => {
   return dimensions;
 };
 var buildEdges = (options, nodes, dimensions) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   let edges = {};
   const addEdgeToNode = (nodeId, edgeId) => {
     if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
@@ -656,14 +701,14 @@ var buildEdges = (options, nodes, dimensions) => {
   };
   if (dimensions && Object.keys(dimensions).length) {
     const dimensionKeys = Object.keys(dimensions);
-    const hasOrder = options.dimensions?.parentOptions?.level1Options?.order;
+    const hasOrder = (_c = (_b = (_a = options.dimensions) == null ? void 0 : _a.parentOptions) == null ? void 0 : _b.level1Options) == null ? void 0 : _c.order;
     let order = hasOrder || dimensionKeys;
     let l = 0;
-    let po = options.dimensions?.parentOptions || {};
-    let extents = po.level1Options?.behavior?.extents || "terminal";
+    let po = ((_d = options.dimensions) == null ? void 0 : _d.parentOptions) || {};
+    let extents = ((_f = (_e = po.level1Options) == null ? void 0 : _e.behavior) == null ? void 0 : _f.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 parentRules = level0 ? ((_h = (_g = po.level1Options) == null ? void 0 : _g.navigationRules) == null ? void 0 : _h.parent_child) || ["parent", "child"] : [];
+    let siblingRules = ((_j = (_i = po.level1Options) == null ? void 0 : _i.navigationRules) == null ? void 0 : _j.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");
@@ -700,13 +745,14 @@ var buildEdges = (options, nodes, dimensions) => {
       l++;
     });
     dimensionKeys.forEach((s) => {
+      var _a2, _b2, _c2, _d2;
       const dimension = dimensions[s];
-      const strat = dimension.behavior?.childmostNavigation || "within";
-      const matchByIndex = (i, _a, _b, c) => {
+      const strat = ((_a2 = dimension.behavior) == null ? void 0 : _a2.childmostNavigation) || "within";
+      const matchByIndex = (i, _a3, _b3, c) => {
         return c.values[Object.keys(c.values)[i]] || void 0;
       };
-      const match = strat === "across" && dimension.behavior?.childmostMatching ? dimension.behavior?.childmostMatching : matchByIndex;
-      let extents2 = dimension.behavior?.extents || "circular";
+      const match = strat === "across" && ((_b2 = dimension.behavior) == null ? void 0 : _b2.childmostMatching) ? (_c2 = dimension.behavior) == null ? void 0 : _c2.childmostMatching : matchByIndex;
+      let extents2 = ((_d2 = dimension.behavior) == null ? void 0 : _d2.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(
@@ -758,7 +804,7 @@ var buildEdges = (options, nodes, dimensions) => {
           "source"
         );
         let i = 0;
-        if (valueKeys.length > 1) {
+        if (valueKeys.length >= 1) {
           valueKeys.forEach((vk) => {
             let v = division.values[vk];
             const id = typeof options.idKey === "function" ? options.idKey(v) : options.idKey;
@@ -867,8 +913,9 @@ var buildEdges = (options, nodes, dimensions) => {
     });
   }
   Object.keys(nodes).forEach((nodeKey) => {
+    var _a2;
     const node = nodes[nodeKey];
-    if (options.genericEdges?.length) {
+    if ((_a2 = options.genericEdges) == null ? void 0 : _a2.length) {
       options.genericEdges.forEach((e) => {
         if (!edges[e.edgeId]) {
           edges[e.edgeId] = e.edge;
@@ -882,6 +929,7 @@ var buildEdges = (options, nodes, dimensions) => {
   return edges;
 };
 var buildRules = (options, edges, dimensions) => {
+  var _a, _b, _c, _d;
   let rules = options.navigationRules;
   if (!rules) {
     let dimKeys = Object.keys(dimensions || {});
@@ -900,11 +948,11 @@ var buildRules = (options, edges, dimensions) => {
       let k1Assigned = false;
       let k2Assigned = false;
       if (importedRules[k1] || used[k1]) {
-        used[k1] = { ...importedRules[k1] };
+        used[k1] = __spreadValues({}, importedRules[k1]);
         k1Assigned = true;
       }
       if (k2 && (importedRules[k2] || used[k2])) {
-        used[k2] = { ...importedRules[k2] };
+        used[k2] = __spreadValues({}, importedRules[k2]);
         k2Assigned = true;
       }
       if (isPair && !k1Assigned && !k2Assigned) {
@@ -964,15 +1012,15 @@ var buildRules = (options, edges, dimensions) => {
       }
     };
     Object.keys(GenericFullNavigationRules).forEach((r) => {
-      let rule = { ...GenericFullNavigationRules[r] };
+      let rule = __spreadValues({}, 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 || [
+      if ((_b = (_a = options.dimensions) == null ? void 0 : _a.parentOptions) == null ? void 0 : _b.addLevel0) {
+        let rules2 = ((_d = (_c = options.dimensions.parentOptions.level1Options) == null ? void 0 : _c.navigationRules) == null ? void 0 : _d.parent_child) || [
           "parent",
           "child"
         ];
@@ -1002,7 +1050,7 @@ var buildRules = (options, edges, dimensions) => {
           spareKeys.push(importedRules[r].key);
         }
       });
-      let recheckKeys = { ...needsKeys };
+      let recheckKeys = __spreadValues({}, needsKeys);
       needsKeys = {};
       Object.keys(recheckKeys).forEach((key) => {
         checkKeys(key);
@@ -1142,19 +1190,20 @@ var rendering_default = (options) => {
   let initialized = false;
   let defaults = {
     cssClass: NodeElementDefaults.cssClass,
-    spatialProperties: { ...NodeElementDefaults.spatialProperties },
-    semantics: { ...NodeElementDefaults.semantics },
-    parentSemantics: { ...NodeElementDefaults.parentSemantics },
-    existingElement: { ...NodeElementDefaults.existingElement }
+    spatialProperties: __spreadValues({}, NodeElementDefaults.spatialProperties),
+    semantics: __spreadValues({}, NodeElementDefaults.semantics),
+    parentSemantics: __spreadValues({}, NodeElementDefaults.parentSemantics),
+    existingElement: __spreadValues({}, NodeElementDefaults.existingElement)
   };
   if (options.defaults) {
     defaults.cssClass = options.defaults.cssClass || defaults.cssClass;
-    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;
+    defaults.spatialProperties = options.defaults.spatialProperties ? __spreadValues(__spreadValues({}, defaults.spatialProperties), options.defaults.spatialProperties) : defaults.spatialProperties;
+    defaults.semantics = options.defaults.semantics ? __spreadValues(__spreadValues({}, defaults.semantics), options.defaults.semantics) : defaults.semantics;
+    defaults.parentSemantics = options.defaults.parentSemantics ? __spreadValues(__spreadValues({}, defaults.parentSemantics), options.defaults.parentSemantics) : defaults.parentSemantics;
+    defaults.existingElement = options.defaults.existingElement ? __spreadValues(__spreadValues({}, defaults.existingElement), options.defaults.existingElement) : defaults.existingElement;
   }
   renderer.initialize = () => {
+    var _a;
     if (initialized) {
       console.error(
         `The renderer wrapper has already been initialized successfully, RenderingOptions.suffixId is: ${options.suffixId}. No further action was taken.`
@@ -1199,7 +1248,7 @@ var rendering_default = (options) => {
       renderer.wrapper.appendChild(renderer.entryButton);
     }
     renderer.root.appendChild(renderer.wrapper);
-    if (options.exitElement?.include) {
+    if ((_a = options.exitElement) == null ? void 0 : _a.include) {
       renderer.exitElement = document.createElement("div");
       renderer.exitElement.id = "dn-exit-" + options.suffixId;
       renderer.exitElement.classList.add("dn-exit-position");
@@ -1209,15 +1258,17 @@ var rendering_default = (options) => {
       renderer.exitElement.setAttribute("tabindex", "-1");
       renderer.exitElement.style.display = "none";
       renderer.exitElement.addEventListener("focus", (e) => {
+        var _a2, _b;
         renderer.exitElement.style.display = "block";
         renderer.clearStructure();
-        if (options.exitElement?.callbacks?.focus) {
+        if ((_b = (_a2 = options.exitElement) == null ? void 0 : _a2.callbacks) == null ? void 0 : _b.focus) {
           options.exitElement.callbacks.focus(e);
         }
       });
       renderer.exitElement.addEventListener("blur", (e) => {
+        var _a2, _b;
         renderer.exitElement.style.display = "none";
-        if (options.exitElement?.callbacks?.blur) {
+        if ((_b = (_a2 = options.exitElement) == null ? void 0 : _a2.callbacks) == null ? void 0 : _b.blur) {
           options.exitElement.callbacks.blur(e);
         }
       });
@@ -1240,9 +1291,10 @@ var rendering_default = (options) => {
     let useExisting = false;
     let existingSpatialProperties = {};
     const resolveProp = (prop, subprop, checkExisting) => {
+      var _a;
       const p1 = d[prop] || defaults[prop];
-      const s1 = !(checkExisting && useExisting) ? p1?.[subprop] : existingSpatialProperties[subprop];
-      const s2 = defaults[prop]?.[subprop];
+      const s1 = !(checkExisting && useExisting) ? p1 == null ? void 0 : p1[subprop] : existingSpatialProperties[subprop];
+      const s2 = (_a = defaults[prop]) == null ? void 0 : _a[subprop];
       return typeof p1 === "function" ? p1(d, nodeData.datum) : typeof s1 === "function" ? s1(d, nodeData.datum) : s1 || s2 || (!subprop ? p1 : void 0);
     };
     useExisting = resolveProp("existingElement", "useForSpatialProperties");
@@ -1332,8 +1384,510 @@ var rendering_default = (options) => {
   return renderer;
 };
 
+// src/text-chat.ts
+var defaultDescribeNode = (node) => {
+  var _a, _b, _c, _d, _e;
+  if ((_a = node.semantics) == null ? void 0 : _a.label) {
+    const label = typeof node.semantics.label === "function" ? node.semantics.label() : node.semantics.label;
+    if (label)
+      return label;
+  }
+  if (!node.derivedNode) {
+    if (node.data) {
+      return Object.keys(node.data).map((key) => `${key}: ${node.data[key]}`).join(". ") + ". Data point.";
+    }
+    return node.id;
+  }
+  if ((_b = node.data) == null ? void 0 : _b.dimensionKey) {
+    let count = 0;
+    const divisions = Object.keys(node.data.divisions || {});
+    divisions.forEach((div) => {
+      count += Object.keys(node.data.divisions[div].values || {}).length;
+    });
+    let label = `${node.derivedNode}.`;
+    label += divisions.length && count ? ` ${divisions.length} division${divisions.length > 1 ? "s" : ""}, ${count} datapoint${count > 1 ? "s" : ""}.` : " No child data points.";
+    label += ` ${node.data.type} dimension.`;
+    return label;
+  }
+  return `${node.derivedNode}: ${(_c = node.data) == null ? void 0 : _c[node.derivedNode]}. ${Object.keys(((_d = node.data) == null ? void 0 : _d.values) || {}).length} child data point${Object.keys(((_e = node.data) == null ? void 0 : _e.values) || {}).length > 1 ? "s" : ""}. Division.`;
+};
+var getAvailableRules = (nodeId, node, structure) => {
+  const available = /* @__PURE__ */ new Set();
+  const navRules = structure.navigationRules || {};
+  if (node.edges) {
+    node.edges.forEach((edgeId) => {
+      const edge = structure.edges[edgeId];
+      if (!edge)
+        return;
+      edge.navigationRules.forEach((ruleName) => {
+        const navRule = navRules[ruleName];
+        if (!navRule)
+          return;
+        const endpoint = navRule.direction === "target" ? edge.target : edge.source;
+        const resolved = typeof endpoint === "function" ? endpoint(node, nodeId) : endpoint;
+        if (resolved && resolved !== nodeId) {
+          available.add(ruleName);
+        }
+      });
+    });
+  }
+  return Array.from(available);
+};
+var getAllRuleNames = (structure) => {
+  if (!structure.navigationRules)
+    return [];
+  return Object.keys(structure.navigationRules);
+};
+var levenshtein = (a, b) => {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array(n + 1);
+  for (let j = 0; j <= n; j++)
+    dp[j] = j;
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const temp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = temp;
+    }
+  }
+  return dp[n];
+};
+var maxTypoDistance = (len) => len <= 4 ? 1 : 2;
+var fuzzyMatch = (input, candidates, labels = {}) => {
+  const lower = input.toLowerCase().trim();
+  const exactName = candidates.find((c) => c.toLowerCase() === lower);
+  if (exactName)
+    return { match: exactName, ambiguous: [] };
+  const exactLabel = candidates.find(
+    (c) => labels[c] && labels[c].toLowerCase() === lower
+  );
+  if (exactLabel)
+    return { match: exactLabel, ambiguous: [] };
+  const namePrefix = candidates.filter((c) => c.toLowerCase().startsWith(lower));
+  if (namePrefix.length === 1)
+    return { match: namePrefix[0], ambiguous: [] };
+  const labelMatches = candidates.filter((c) => {
+    if (!labels[c])
+      return false;
+    const labelLower = labels[c].toLowerCase();
+    if (labelLower.startsWith(lower))
+      return true;
+    return labelLower.split(/\s+/).some((word) => word.startsWith(lower));
+  });
+  const combined = /* @__PURE__ */ new Set([...namePrefix, ...labelMatches]);
+  const all = Array.from(combined);
+  if (all.length === 1)
+    return { match: all[0], ambiguous: [] };
+  if (all.length > 1)
+    return { match: null, ambiguous: all };
+  const threshold = maxTypoDistance(lower.length);
+  const typoMatches = [];
+  for (let i = 0; i < candidates.length; i++) {
+    const c = candidates[i];
+    const nameDist = levenshtein(lower, c.toLowerCase());
+    if (nameDist <= threshold) {
+      typoMatches.push({ candidate: c, dist: nameDist });
+      continue;
+    }
+    if (labels[c]) {
+      const words = labels[c].toLowerCase().split(/\s+/);
+      for (let w = 0; w < words.length; w++) {
+        if (levenshtein(lower, words[w]) <= threshold) {
+          typoMatches.push({ candidate: c, dist: levenshtein(lower, words[w]) });
+          break;
+        }
+      }
+    }
+  }
+  if (typoMatches.length === 1)
+    return { match: typoMatches[0].candidate, ambiguous: [] };
+  if (typoMatches.length > 1) {
+    typoMatches.sort((a, b) => a.dist - b.dist);
+    if (typoMatches[0].dist < typoMatches[1].dist) {
+      return { match: typoMatches[0].candidate, ambiguous: [] };
+    }
+    return { match: null, ambiguous: typoMatches.map((t) => t.candidate) };
+  }
+  return { match: null, ambiguous: [] };
+};
+var formatRule = (ruleName, labels) => {
+  if (labels[ruleName])
+    return `${labels[ruleName]} (${ruleName})`;
+  return ruleName;
+};
+var searchNodes = (query, structure, describeFn, limit = 10) => {
+  const lower = query.toLowerCase();
+  const results = [];
+  const nodeIds = Object.keys(structure.nodes);
+  for (let i = 0; i < nodeIds.length && results.length < limit; i++) {
+    const nodeId = nodeIds[i];
+    const node = structure.nodes[nodeId];
+    let matched = false;
+    if (node.data && !matched) {
+      const dataKeys = Object.keys(node.data);
+      for (let j = 0; j < dataKeys.length && !matched; j++) {
+        const val = node.data[dataKeys[j]];
+        if (val != null && typeof val !== "object" && String(val).toLowerCase().includes(lower)) {
+          matched = true;
+        }
+      }
+    }
+    if (!matched && node.derivedNode && node.derivedNode.toLowerCase().includes(lower)) {
+      matched = true;
+    }
+    if (!matched && nodeId.toLowerCase().includes(lower)) {
+      matched = true;
+    }
+    if (matched) {
+      results.push({ nodeId, description: describeFn(node) });
+    }
+  }
+  return results;
+};
+var text_chat_default = (options) => {
+  var _a;
+  const {
+    structure,
+    container,
+    entryPoint,
+    describeNode: describeNode2 = defaultDescribeNode,
+    commandLabels = {},
+    onNavigate,
+    onExit,
+    llm,
+    data
+  } = options;
+  const rootEl = typeof container === "string" ? document.getElementById(container) : container;
+  if (!rootEl) {
+    throw new Error(`textChat: container "${container}" not found`);
+  }
+  const resolvedEntryPoint = entryPoint || (structure.dimensions ? (_a = structure.dimensions[Object.keys(structure.dimensions)[0]]) == null ? void 0 : _a.nodeId : Object.keys(structure.nodes)[0]);
+  const inputHandler = input_default({
+    structure,
+    navigationRules: structure.navigationRules || {},
+    entryPoint: resolvedEntryPoint
+  });
+  let currentNodeId = null;
+  const uid = Math.random().toString(36).slice(2, 8);
+  const history = [];
+  let historyIndex = -1;
+  let pendingChoices = null;
+  const llmHistory = [];
+  const buildSystemPrompt = () => {
+    let prompt = "You are a data assistant helping a user explore a dataset through a text-based navigation interface.\n\n";
+    if (data && data.length > 0) {
+      const columns = Object.keys(data[0]);
+      const sampleRows = data.slice(0, 3).map((r) => JSON.stringify(r)).join("\n  ");
+      prompt += `DATASET SUMMARY:
+- Columns: ${columns.join(", ")}
+- Rows: ${data.length}
+- Sample (first 3):
+  ${sampleRows}
+
+`;
+      prompt += "FULL DATASET (JSON):\n" + JSON.stringify(data) + "\n\n";
+    }
+    if (currentNodeId) {
+      const node = structure.nodes[currentNodeId];
+      prompt += `CURRENT POSITION: ${node ? describeNode2(node) : currentNodeId}
+
+`;
+    } else {
+      prompt += "CURRENT POSITION: Not yet navigated into the structure.\n\n";
+    }
+    prompt += "PRIORITY: Always prefer answers that can be verified against the dataset. For any statistical or quantitative claim (averages, comparisons, trends, extremes), briefly describe the method you used. Avoid open-ended or contextual claims that go beyond what the data can support \u2014 if the user asks something that cannot be checked against the dataset, say so and suggest they verify externally.\n\n";
+    prompt += "VERIFICATION: When the user asks you to verify a claim, write a short Python script (using the dataset as a JSON array) that computes the answer, and show the expected output. If the claim is too open-ended to verify with code, explain why and recommend external verification.\n\n";
+    prompt += 'IMPORTANT: Your responses may contain errors. The user has been told they can ask you to "verify" any answer, and you will attempt to provide a Python script to check it.';
+    return prompt;
+  };
+  const chatEl = document.createElement("div");
+  chatEl.className = "dn-text-chat";
+  const logEl = document.createElement("div");
+  logEl.className = "dn-text-chat-log";
+  logEl.setAttribute("role", "log");
+  logEl.setAttribute("aria-live", "polite");
+  chatEl.appendChild(logEl);
+  const controlsEl = document.createElement("div");
+  controlsEl.className = "dn-text-chat-controls";
+  const announceLabel = document.createElement("label");
+  const announceCheckbox = document.createElement("input");
+  announceCheckbox.type = "checkbox";
+  announceCheckbox.checked = true;
+  announceCheckbox.addEventListener("change", () => {
+    logEl.setAttribute("aria-live", announceCheckbox.checked ? "polite" : "off");
+  });
+  announceLabel.appendChild(announceCheckbox);
+  announceLabel.appendChild(document.createTextNode(" Automatically announce to screen readers"));
+  controlsEl.appendChild(announceLabel);
+  chatEl.appendChild(controlsEl);
+  const formEl = document.createElement("form");
+  formEl.className = "dn-text-chat-form";
+  const inputLabel = document.createElement("label");
+  inputLabel.setAttribute("for", `dn-text-chat-input-${uid}`);
+  inputLabel.className = "dn-text-chat-sr-only";
+  inputLabel.textContent = "Navigation command";
+  const inputEl = document.createElement("input");
+  inputEl.type = "text";
+  inputEl.id = `dn-text-chat-input-${uid}`;
+  inputEl.autocomplete = "off";
+  inputEl.setAttribute("placeholder", "Type a command...");
+  const submitBtn = document.createElement("button");
+  submitBtn.type = "submit";
+  submitBtn.textContent = "Send";
+  formEl.appendChild(inputLabel);
+  formEl.appendChild(inputEl);
+  formEl.appendChild(submitBtn);
+  chatEl.appendChild(formEl);
+  rootEl.appendChild(chatEl);
+  let savedInput = "";
+  inputEl.addEventListener("keydown", (e) => {
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      if (history.length === 0)
+        return;
+      if (historyIndex === -1) {
+        savedInput = inputEl.value;
+        historyIndex = history.length - 1;
+      } else if (historyIndex > 0) {
+        historyIndex--;
+      }
+      inputEl.value = history[historyIndex];
+    } else if (e.key === "ArrowDown") {
+      e.preventDefault();
+      if (historyIndex === -1)
+        return;
+      if (historyIndex < history.length - 1) {
+        historyIndex++;
+        inputEl.value = history[historyIndex];
+      } else {
+        historyIndex = -1;
+        inputEl.value = savedInput;
+      }
+    }
+  });
+  const addMessage = (text, className) => {
+    const msg = document.createElement("div");
+    msg.className = `dn-text-chat-message ${className}`;
+    msg.textContent = text;
+    logEl.appendChild(msg);
+    logEl.scrollTop = logEl.scrollHeight;
+  };
+  const addSystemMessage = (text) => addMessage(text, "dn-text-chat-system");
+  const addEcho = (text) => addMessage(`> ${text}`, "dn-text-chat-input-echo");
+  const addResponse = (text) => addMessage(text, "dn-text-chat-response");
+  const addResponseWithList = (intro, items) => {
+    const wrapper = document.createElement("div");
+    wrapper.className = "dn-text-chat-message dn-text-chat-response";
+    const p = document.createElement("span");
+    p.textContent = intro;
+    wrapper.appendChild(p);
+    const ol = document.createElement("ol");
+    ol.className = "dn-text-chat-choices";
+    items.forEach((item) => {
+      const li = document.createElement("li");
+      li.textContent = item;
+      ol.appendChild(li);
+    });
+    wrapper.appendChild(ol);
+    logEl.appendChild(wrapper);
+    logEl.scrollTop = logEl.scrollHeight;
+  };
+  const askLLM = (question) => __async(void 0, null, function* () {
+    const systemMsg = { role: "system", content: buildSystemPrompt() };
+    llmHistory.push({ role: "user", content: question });
+    const thinkingMsg = document.createElement("div");
+    thinkingMsg.className = "dn-text-chat-message dn-text-chat-llm-thinking";
+    thinkingMsg.textContent = "Thinking...";
+    logEl.appendChild(thinkingMsg);
+    logEl.scrollTop = logEl.scrollHeight;
+    try {
+      const response = yield llm([systemMsg, ...llmHistory]);
+      logEl.removeChild(thinkingMsg);
+      if (response === null) {
+        llmHistory.pop();
+        return null;
+      }
+      llmHistory.push({ role: "assistant", content: response });
+      addResponse(response);
+      return response;
+    } catch (err) {
+      logEl.removeChild(thinkingMsg);
+      llmHistory.pop();
+      addResponse(`Error: ${err.message || "Could not get a response."}`);
+      return "";
+    }
+  });
+  if (llm) {
+    addSystemMessage('Text navigation ready. Type "enter" to begin navigating, "help" for commands, or ask a question about the data.');
+    addSystemMessage('Note: AI-generated answers may be inaccurate. You can ask the model to "verify" any answer \u2014 it will attempt to provide a Python script that checks the claim against the dataset. If a claim cannot be verified with code, it should be verified externally.');
+  } else {
+    addSystemMessage('Text navigation ready. Type "enter" to begin or "help" for available commands.');
+  }
+  const specialCommands = ["enter", "help", "more", "more help", "clear"];
+  const moveToNode = (nodeId) => {
+    const node = inputHandler.moveTo(nodeId);
+    if (node) {
+      currentNodeId = node.id;
+      if (onNavigate)
+        onNavigate(node);
+      addResponse(`Moved to: ${describeNode2(node)}`);
+    } else {
+      addResponse("Could not move to that node.");
+    }
+  };
+  const handleCommand = (raw) => __async(void 0, null, function* () {
+    const trimmed = raw.trim();
+    if (!trimmed)
+      return;
+    addEcho(trimmed);
+    const lower = trimmed.toLowerCase();
+    if (pendingChoices) {
+      const num = parseInt(trimmed, 10);
+      if (!isNaN(num) && num >= 1 && num <= pendingChoices.length) {
+        const choice = pendingChoices[num - 1];
+        pendingChoices = null;
+        moveToNode(choice.nodeId);
+        return;
+      }
+      pendingChoices = null;
+    }
+    if (lower === "clear") {
+      logEl.innerHTML = "";
+      addSystemMessage('Chat cleared. Type "help" for available commands.');
+      return;
+    }
+    if (lower === "enter") {
+      if (currentNodeId) {
+        addResponse('Already in the structure. Type "help" to see available commands.');
+        return;
+      }
+      const entryNode = inputHandler.enter();
+      if (!entryNode) {
+        addResponse("Could not enter the structure. No entry point found.");
+        return;
+      }
+      currentNodeId = entryNode.id;
+      if (onNavigate)
+        onNavigate(entryNode);
+      addResponse(`Entered: ${describeNode2(entryNode)}`);
+      return;
+    }
+    if (lower === "help") {
+      const llmHint = llm ? " You can also type any question about the data." : "";
+      if (!currentNodeId) {
+        addResponse(
+          'Not yet in the structure. Type "enter" to begin navigating, or "move to <search>" to jump to a node.' + llmHint
+        );
+      } else {
+        const node = structure.nodes[currentNodeId];
+        const available = getAvailableRules(currentNodeId, node, structure);
+        const formatted = available.map((r) => formatRule(r, commandLabels));
+        addResponse(`Available: ${formatted.join(", ")}, move to <search>.` + llmHint);
+      }
+      return;
+    }
+    if (lower.startsWith("move to ")) {
+      const query = trimmed.slice("move to ".length).trim();
+      if (!query) {
+        addResponse("Usage: move to <search term>");
+        return;
+      }
+      const results = searchNodes(query, structure, describeNode2);
+      if (results.length === 0) {
+        addResponse(`No nodes found matching "${query}".`);
+      } else if (results.length === 1) {
+        moveToNode(results[0].nodeId);
+      } else {
+        pendingChoices = results;
+        addResponseWithList(
+          `Found ${results.length} matches. Type a number to move there:`,
+          results.map((r) => r.description)
+        );
+      }
+      return;
+    }
+    if (lower === "more" || lower === "more help") {
+      const allRules2 = getAllRuleNames(structure);
+      const formatted = allRules2.map((r) => formatRule(r, commandLabels));
+      addResponse(`All navigation rules: ${formatted.join(", ")}.`);
+      return;
+    }
+    if (!currentNodeId) {
+      if (llm) {
+        const response = yield askLLM(trimmed);
+        if (response !== null)
+          return;
+      }
+      const llmHint = llm ? " Enter an API key above to ask questions about the data." : "";
+      addResponse('Type "enter" to begin navigating the structure, or "move to <search>" to jump to a node.' + llmHint);
+      return;
+    }
+    const allRules = getAllRuleNames(structure);
+    const { match, ambiguous } = fuzzyMatch(lower, [...allRules, ...specialCommands], commandLabels);
+    if (match && specialCommands.includes(match)) {
+      yield handleCommand(match);
+      return;
+    }
+    if (!match && ambiguous.length > 0) {
+      const formatted = ambiguous.map((r) => formatRule(r, commandLabels));
+      addResponse(`Did you mean: ${formatted.join(", ")}?`);
+      return;
+    }
+    if (!match) {
+      if (llm) {
+        const response = yield askLLM(trimmed);
+        if (response !== null)
+          return;
+      }
+      const llmHint = llm ? " Enter an API key above to ask questions about the data." : "";
+      addResponse(`Unknown command "${trimmed}". Type "help" for available commands.` + llmHint);
+      return;
+    }
+    const direction = match;
+    const label = commandLabels[direction] || direction;
+    if (direction === "exit") {
+      currentNodeId = null;
+      if (onExit)
+        onExit();
+      addResponse('Exited the structure. Type "enter" to re-enter.');
+      return;
+    }
+    const nextNode = inputHandler.move(currentNodeId, direction);
+    if (nextNode) {
+      currentNodeId = nextNode.id;
+      if (onNavigate)
+        onNavigate(nextNode);
+      addResponse(`${label}: ${describeNode2(nextNode)}`);
+    } else {
+      addResponse(`Cannot move "${direction}" from here.`);
+    }
+  });
+  formEl.addEventListener("submit", (e) => __async(void 0, null, function* () {
+    e.preventDefault();
+    const value = inputEl.value.trim();
+    if (value) {
+      history.push(value);
+      historyIndex = -1;
+    }
+    yield handleCommand(inputEl.value);
+    inputEl.value = "";
+    inputEl.focus();
+  }));
+  return {
+    destroy() {
+      rootEl.removeChild(chatEl);
+    },
+    getCurrentNode() {
+      return currentNodeId ? structure.nodes[currentNodeId] || null : null;
+    }
+  };
+};
+
 // src/index.ts
-var src_default = { structure: structure_default, input: input_default, rendering: rendering_default };
+var src_default = { structure: structure_default, input: input_default, rendering: rendering_default, textChat: text_chat_default };
 export {
   src_default as default
 };