@visualli/core 0.1.4 → 0.1.6

package/dist/parser/index.cjs

@@ -0,0 +1,739 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/parser/index.ts
+var parser_exports = {};
+__export(parser_exports, {
+  VisualliParseError: () => VisualliParseError,
+  calculateDistance: () => calculateDistance,
+  convertLayerToFlatNodes: () => convertLayerToFlatNodes,
+  convertVisualliToFlatNodes: () => convertVisualliToFlatNodes,
+  countLayersBeneath: () => countLayersBeneath,
+  createMindMapConfig: () => createMindMapConfig,
+  fetchAndParseVisualli: () => fetchAndParseVisualli,
+  flattenNodes: () => flattenNodes,
+  generateSampleConfig: () => generateSampleConfig,
+  getChildLayers: () => getChildLayers,
+  getNodeConnections: () => getNodeConnections,
+  getNodesForLayer: () => getNodesForLayer,
+  getTopLevelConnections: () => getTopLevelConnections,
+  getVisibleNodes: () => getVisibleNodes,
+  loadVisualliFileFromFile: () => loadVisualliFileFromFile,
+  parseVisualliFile: () => parseVisualliFile,
+  parseVisualliFromMongoDB: () => parseVisualliFromMongoDB,
+  resolveNodeOverlaps: () => resolveNodeOverlaps
+});
+module.exports = __toCommonJS(parser_exports);
+
+// src/parser/visualliParser.ts
+function toVisualliLayer(schemaLayer) {
+  return {
+    type: "layer",
+    id: schemaLayer.id,
+    level: schemaLayer.level,
+    parentLayerId: schemaLayer.parentLayerId,
+    parentNodeId: schemaLayer.parentNodeId,
+    layout: schemaLayer.layout,
+    nodes: schemaLayer.nodes ?? [],
+    connections: schemaLayer.connections ?? [],
+    containers: schemaLayer.containers ?? []
+  };
+}
+var VisualliParseError = class extends Error {
+  constructor(message, lineNumber) {
+    super(message);
+    this.lineNumber = lineNumber;
+    this.name = "VisualliParseError";
+  }
+};
+function parseVisualliFile(content) {
+  const lines = content.trim().split("\n");
+  const doc = {
+    meta: null,
+    layers: /* @__PURE__ */ new Map(),
+    layersByLevel: /* @__PURE__ */ new Map(),
+    rootLayer: null
+  };
+  let lineNumber = 0;
+  for (const line of lines) {
+    lineNumber++;
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (err) {
+      throw new VisualliParseError(
+        `Failed to parse JSON at line ${lineNumber}: ${err}`,
+        lineNumber
+      );
+    }
+    if (!obj["type"]) {
+      throw new VisualliParseError(
+        `Missing 'type' field at line ${lineNumber}`,
+        lineNumber
+      );
+    }
+    switch (obj["type"]) {
+      case "meta":
+        doc.meta = obj;
+        break;
+      case "layer": {
+        const schemaLayer = obj;
+        const layer = toVisualliLayer(schemaLayer);
+        doc.layers.set(layer.id, layer);
+        if (!doc.layersByLevel.has(layer.level)) {
+          doc.layersByLevel.set(layer.level, []);
+        }
+        doc.layersByLevel.get(layer.level).push(layer);
+        if (layer.level === 0) {
+          doc.rootLayer = layer;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!doc.meta) throw new VisualliParseError("Missing required meta section");
+  if (!doc.rootLayer) throw new VisualliParseError("Missing root layer (level 0)");
+  return doc;
+}
+async function fetchAndParseVisualli(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  return parseVisualliFile(await response.text());
+}
+function parseVisualliFromMongoDB(visualliJsonl) {
+  if (!visualliJsonl || typeof visualliJsonl !== "string") {
+    throw new VisualliParseError("Invalid visualli data: expected a JSONL string");
+  }
+  const trimmed = visualliJsonl.trim();
+  if (!trimmed) throw new VisualliParseError("Empty visualli data from MongoDB");
+  return parseVisualliFile(trimmed);
+}
+function loadVisualliFileFromFile(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        resolve(parseVisualliFile(e.target?.result));
+      } catch (err) {
+        reject(err);
+      }
+    };
+    reader.onerror = () => reject(new Error("Failed to read file"));
+    reader.readAsText(file);
+  });
+}
+function getChildLayers(doc, nodeId) {
+  const result = [];
+  for (const layer of doc.layers.values()) {
+    if (layer.parentNodeId === nodeId) result.push(layer);
+  }
+  return result;
+}
+function countLayersBeneath(doc, nodeId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(nodeId)) return 0;
+  visited.add(nodeId);
+  const children = getChildLayers(doc, nodeId);
+  if (children.length === 0) return 0;
+  let maxDepth = 0;
+  for (const layer of children) {
+    let depth = 1;
+    for (const node of layer.nodes) {
+      depth = Math.max(depth, 1 + countLayersBeneath(doc, node.id, visited));
+    }
+    maxDepth = Math.max(maxDepth, depth);
+  }
+  return maxDepth;
+}
+
+// src/layout/circularLayout.ts
+function applyCircularLayout(nodes, options = {}) {
+  const {
+    radiusPercentage = 0.135,
+    containerWidth = 2e3,
+    containerHeight = 2e3,
+    centerX = 0,
+    centerY = 0
+  } = options;
+  if (nodes.length === 0) return nodes;
+  if (nodes.length === 1) {
+    nodes[0].x = centerX;
+    nodes[0].y = centerY;
+    return nodes;
+  }
+  const radius = Math.min(containerWidth, containerHeight) * radiusPercentage;
+  const startAngle = nodes.length === 2 ? 0 : -Math.PI / 2;
+  const angleStep = 2 * Math.PI / nodes.length;
+  for (let i = 0; i < nodes.length; i++) {
+    const angle = startAngle + i * angleStep;
+    nodes[i].x = centerX + radius * Math.cos(angle);
+    nodes[i].y = centerY + radius * Math.sin(angle);
+  }
+  return nodes;
+}
+function calculateMinimumRadius(nodeCount, nodeWidth = 200, nodePadding = 150) {
+  if (nodeCount <= 1) return 0;
+  const angleStep = 2 * Math.PI / nodeCount;
+  const minChordLength = nodeWidth + nodePadding;
+  return minChordLength / (2 * Math.sin(angleStep / 2));
+}
+function calculateOptimalRadiusPercentage(nodeCount, containerWidth = 2e3, containerHeight = 2e3, nodeWidth = 200, nodePadding = 120) {
+  const minRadius = calculateMinimumRadius(nodeCount, nodeWidth, nodePadding);
+  const minDimension = Math.min(containerWidth, containerHeight);
+  return Math.min(0.45, Math.max(0.135, minRadius / minDimension));
+}
+
+// src/layout/linearLayout.ts
+function applyLinearHorizontalLayout(nodes, options = {}) {
+  const { nodeWidth = 200, hGap = 180, centerX = 0, centerY = 0 } = options;
+  if (nodes.length === 0) return nodes;
+  if (nodes.length === 1) {
+    nodes[0].x = centerX;
+    nodes[0].y = centerY;
+    return nodes;
+  }
+  const spacing = nodeWidth + hGap;
+  const totalWidth = (nodes.length - 1) * spacing;
+  const startX = centerX - totalWidth / 2;
+  for (let i = 0; i < nodes.length; i++) {
+    nodes[i].x = startX + i * spacing;
+    nodes[i].y = centerY;
+  }
+  return nodes;
+}
+function applyLinearVerticalLayout(nodes, options = {}) {
+  const { nodeHeight = 80, vGap = 220, centerX = 0, centerY = 0 } = options;
+  if (nodes.length === 0) return nodes;
+  if (nodes.length === 1) {
+    nodes[0].x = centerX;
+    nodes[0].y = centerY;
+    return nodes;
+  }
+  const spacing = nodeHeight + vGap;
+  const totalHeight = (nodes.length - 1) * spacing;
+  const startY = centerY - totalHeight / 2;
+  for (let i = 0; i < nodes.length; i++) {
+    nodes[i].x = centerX;
+    nodes[i].y = startY + i * spacing;
+  }
+  return nodes;
+}
+
+// src/parser/visualliConverter.ts
+function doNodesOverlap(n1, n2, padding = 20) {
+  return !(n1.x + n1.width / 2 + padding < n2.x - n2.width / 2 - padding || n1.x - n1.width / 2 - padding > n2.x + n2.width / 2 + padding || n1.y + n1.height / 2 + padding < n2.y - n2.height / 2 - padding || n1.y - n1.height / 2 - padding > n2.y + n2.height / 2 + padding);
+}
+function resolveNodeOverlaps(nodes, maxIterations = 10) {
+  const padding = 150;
+  for (let iter = 0; iter < maxIterations; iter++) {
+    let any = false;
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const n1 = nodes[i];
+        const n2 = nodes[j];
+        if (!doNodesOverlap(n1, n2, padding)) continue;
+        any = true;
+        const dx = n2.x - n1.x;
+        const dy = n2.y - n1.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < 1) {
+          n2.x += n2.width / 2 + padding;
+          continue;
+        }
+        const minDist = (n1.width + n2.width) / 2 + padding;
+        if (dist < minDist) {
+          const push = (minDist - dist) / 2;
+          n1.x -= dx / dist * push;
+          n1.y -= dy / dist * push;
+          n2.x += dx / dist * push;
+          n2.y += dy / dist * push;
+        }
+      }
+    }
+    if (!any) break;
+  }
+}
+var COLOR_PALETTE = [
+  "#12C7D3",
+  "#325E8C",
+  "#8A70A6",
+  "#F54A57",
+  "#FF6C4D",
+  "#F28C16",
+  "#FFD347",
+  "#12C7D3",
+  "#7F7F7F",
+  "#8D8D8D",
+  "#12C7D3"
+];
+function getRandomColorForNode(nodeId) {
+  let hash = 0;
+  for (let i = 0; i < nodeId.length; i++) {
+    hash = nodeId.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const index = Math.abs(hash) % COLOR_PALETTE.length;
+  return COLOR_PALETTE[index];
+}
+function applyFormation(nodes, formation) {
+  if (nodes.length === 0) return;
+  if (nodes.length === 1) {
+    nodes[0].x = 0;
+    nodes[0].y = 0;
+    return;
+  }
+  if (formation === "linear-horizontal" || formation === "linear") {
+    applyLinearHorizontalLayout(nodes, { centerX: 0, centerY: 0 });
+  } else if (formation === "linear-vertical") {
+    applyLinearVerticalLayout(nodes, { centerX: 0, centerY: 0 });
+  } else {
+    const r = Math.max(250, nodes.length * 70);
+    const step = 2 * Math.PI / nodes.length;
+    for (let i = 0; i < nodes.length; i++) {
+      nodes[i].x = r * Math.cos(i * step);
+      nodes[i].y = r * Math.sin(i * step);
+    }
+  }
+}
+function containerBBox(nodes, padding) {
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  for (const n of nodes) {
+    minX = Math.min(minX, n.x - n.width / 2);
+    maxX = Math.max(maxX, n.x + n.width / 2);
+    minY = Math.min(minY, n.y - n.height / 2);
+    maxY = Math.max(maxY, n.y + n.height / 2);
+  }
+  return { width: maxX - minX + padding * 2, height: maxY - minY + padding * 2 };
+}
+function proxyLinearH(proxies, gap = 180) {
+  const total = proxies.reduce((s, p) => s + p.width, 0) + gap * (proxies.length - 1);
+  let x = -total / 2;
+  for (const p of proxies) {
+    p.x = x + p.width / 2;
+    p.y = 0;
+    x += p.width + gap;
+  }
+}
+function proxyLinearV(proxies, gap = 180) {
+  const total = proxies.reduce((s, p) => s + p.height, 0) + gap * (proxies.length - 1);
+  let y = -total / 2;
+  for (const p of proxies) {
+    p.x = 0;
+    p.y = y + p.height / 2;
+    y += p.height + gap;
+  }
+}
+function proxyRadial(proxies, radius = 500) {
+  if (proxies.length === 1) {
+    proxies[0].x = 0;
+    proxies[0].y = 0;
+    return;
+  }
+  const startAngle = proxies.length === 2 ? 0 : -Math.PI / 2;
+  const step = 2 * Math.PI / proxies.length;
+  for (let i = 0; i < proxies.length; i++) {
+    const angle = startAngle + i * step;
+    proxies[i].x = radius * Math.cos(angle);
+    proxies[i].y = radius * Math.sin(angle);
+  }
+}
+function calculateNodeWidth(title) {
+  return Math.max(200, title.length * 8 + 40);
+}
+function makeFlatNode(nodeId, label, summary, layer, color, branchCount, x = 0, y = 0) {
+  return {
+    id: nodeId,
+    parentId: layer.parentNodeId ?? null,
+    x,
+    y,
+    level: layer.level,
+    title: label,
+    description: summary,
+    color,
+    width: calculateNodeWidth(label),
+    height: 80,
+    isExpanded: branchCount > 0,
+    branchCount,
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+}
+function convertLayerWithContainers(layer, doc) {
+  const PADDING = 80;
+  const flatNodes = [];
+  for (const node of layer.nodes) {
+    const label = Array.isArray(node.data.label) ? node.data.label.join(" ") : node.data.label || "Untitled";
+    const branchCount = countLayersBeneath(doc, node.id);
+    flatNodes.push(
+      makeFlatNode(
+        node.id,
+        label,
+        node.data.summary || "",
+        layer,
+        node.data.color || getRandomColorForNode(node.id),
+        branchCount
+      )
+    );
+  }
+  const byId = new Map(flatNodes.map((n) => [n.id, n]));
+  const containerNodeIds = /* @__PURE__ */ new Set();
+  const containerGroups = /* @__PURE__ */ new Map();
+  for (const container of layer.containers) {
+    const group = container.nodes.map((id) => byId.get(id)).filter((n) => !!n);
+    if (!group.length) continue;
+    container.nodes.forEach((id) => containerNodeIds.add(id));
+    const formation = container.data?.["formation"] ?? "radial";
+    applyFormation(group, formation);
+    containerGroups.set(container.id, group);
+  }
+  const proxies = [];
+  for (const node of layer.nodes) {
+    if (!containerNodeIds.has(node.id)) {
+      const nodeWidth = calculateNodeWidth(node.data.label);
+      proxies.push({ id: node.id, x: 0, y: 0, width: nodeWidth, height: 80 });
+    }
+  }
+  for (const container of layer.containers) {
+    const group = containerGroups.get(container.id);
+    if (!group?.length) continue;
+    const bbox = containerBBox(group, PADDING);
+    proxies.push({ id: `__c__${container.id}`, x: 0, y: 0, width: bbox.width, height: bbox.height });
+  }
+  const layout = layer.layout || "radial";
+  if (layout === "linear-horizontal") proxyLinearH(proxies, 180);
+  else if (layout === "linear-vertical") proxyLinearV(proxies, 180);
+  else proxyRadial(proxies, 500);
+  for (const proxy of proxies) {
+    if (proxy.id.startsWith("__c__")) {
+      const group = containerGroups.get(proxy.id.slice(5));
+      group?.forEach((n) => {
+        n.x += proxy.x;
+        n.y += proxy.y;
+      });
+    } else {
+      const fn = byId.get(proxy.id);
+      if (fn) {
+        fn.x = proxy.x;
+        fn.y = proxy.y;
+      }
+    }
+  }
+  resolveNodeOverlaps(flatNodes);
+  return flatNodes;
+}
+function convertLayerToFlatNodes(layer, doc) {
+  if ((layer.containers ?? []).length > 0) {
+    return convertLayerWithContainers(layer, doc);
+  }
+  const flatNodes = [];
+  for (const node of layer.nodes) {
+    const label = Array.isArray(node.data.label) ? node.data.label.join(" ") : node.data.label || "Untitled";
+    const branchCount = countLayersBeneath(doc, node.id);
+    flatNodes.push(
+      makeFlatNode(
+        node.id,
+        label,
+        node.data.summary || "",
+        layer,
+        node.data.color || getRandomColorForNode(node.id),
+        branchCount,
+        0,
+        0
+      )
+    );
+  }
+  if (flatNodes.length > 0) {
+    const layout = layer.layout || "radial";
+    if (layout === "linear-horizontal") {
+      applyLinearHorizontalLayout(flatNodes, { centerX: 0, centerY: 0 });
+    } else if (layout === "linear-vertical") {
+      applyLinearVerticalLayout(flatNodes, { centerX: 0, centerY: 0 });
+    } else {
+      const pct = calculateOptimalRadiusPercentage(flatNodes.length, 2e3, 2e3, 200, 30);
+      applyCircularLayout(flatNodes, {
+        radiusPercentage: pct,
+        containerWidth: 2e3,
+        containerHeight: 2e3,
+        centerX: 0,
+        centerY: 0
+      });
+    }
+  }
+  resolveNodeOverlaps(flatNodes);
+  return flatNodes;
+}
+function convertVisualliToFlatNodes(doc) {
+  const map = /* @__PURE__ */ new Map();
+  for (const layer of doc.layers.values()) {
+    for (const node of convertLayerToFlatNodes(layer, doc)) {
+      map.set(node.id, node);
+    }
+  }
+  for (const node of map.values()) {
+    node.childrenIds = [];
+    for (const candidate of map.values()) {
+      if (candidate.parentId === node.id) node.childrenIds.push(candidate.id);
+    }
+  }
+  return map;
+}
+function getNodesForLayer(doc, layerId) {
+  const layer = doc.layers.get(layerId);
+  return layer ? convertLayerToFlatNodes(layer, doc) : [];
+}
+
+// src/parser/mindmapUtils.ts
+function flattenNodes(nodes) {
+  const result = [];
+  const traverse = (list) => {
+    for (const n of list) {
+      result.push(n);
+      if (n.children) traverse(n.children);
+    }
+  };
+  traverse(nodes);
+  return result;
+}
+function getVisibleNodes(nodes, zoom, focusedNode) {
+  const flat = flattenNodes(nodes);
+  if (focusedNode) {
+    const focused = flat.find((n) => n.id === focusedNode);
+    if (focused) {
+      return focused.children ? [focused, ...focused.children] : [focused];
+    }
+  }
+  if (zoom <= 0.7) return flat.filter((n) => n.level === 0);
+  const maxLevel = Math.floor((zoom - 0.7) / 0.05);
+  return flat.filter((n) => n.level <= maxLevel);
+}
+function getNodeConnections(nodes) {
+  const flat = flattenNodes(nodes);
+  const result = [];
+  for (const n of flat) {
+    if (!n.parent) continue;
+    const parent = flat.find((p) => p.id === n.parent);
+    if (parent) result.push({ from: parent, to: n, label: n.relationshipLabel });
+  }
+  return result;
+}
+function getTopLevelConnections(nodes, topLevelConnections) {
+  const flat = flattenNodes(nodes);
+  const result = [];
+  for (const conn of topLevelConnections) {
+    const from = flat.find((n) => n.id === conn.from);
+    const to = flat.find((n) => n.id === conn.to);
+    if (from && to) result.push({ from, to, label: conn.label ?? "" });
+  }
+  return result;
+}
+function calculateDistance(x1, y1, x2, y2) {
+  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+}
+
+// src/constants/design.ts
+var BRAND_COLORS = {
+  primary: {
+    50: "#EFF6FF",
+    100: "#DBEAFE",
+    200: "#BFDBFE",
+    300: "#93C5FD",
+    400: "#60A5FA",
+    500: "#3B82F6",
+    600: "#2563EB",
+    700: "#1D4ED8",
+    800: "#1E40AF",
+    900: "#1E3A8A"
+  },
+  secondary: {
+    50: "#F0FDF4",
+    100: "#DCFCE7",
+    200: "#BBF7D0",
+    300: "#86EFAC",
+    400: "#4ADE80",
+    500: "#10B981",
+    600: "#059669",
+    700: "#047857",
+    800: "#065F46",
+    900: "#064E3B"
+  },
+  accent: {
+    purple: "#8B5CF6",
+    cyan: "#06B6D4",
+    sky: "#0EA5E9",
+    lime: "#84CC16",
+    amber: "#F59E0B",
+    red: "#EF4444"
+  }
+};
+var LEVEL_COLORS = {
+  level0: BRAND_COLORS.primary[500],
+  level1: BRAND_COLORS.primary[400],
+  level2: BRAND_COLORS.primary[300],
+  level3: BRAND_COLORS.primary[200],
+  level4: BRAND_COLORS.primary[300],
+  level5: BRAND_COLORS.primary[400],
+  level6: BRAND_COLORS.primary[500],
+  level7: BRAND_COLORS.primary[600],
+  level8: BRAND_COLORS.primary[700]
+};
+var LEVEL_COLOR_ARRAY = [
+  LEVEL_COLORS.level0,
+  LEVEL_COLORS.level1,
+  LEVEL_COLORS.level2,
+  LEVEL_COLORS.level3,
+  LEVEL_COLORS.level4,
+  LEVEL_COLORS.level5,
+  LEVEL_COLORS.level6,
+  LEVEL_COLORS.level7,
+  LEVEL_COLORS.level8
+];
+var SEMANTIC_COLORS = {
+  success: BRAND_COLORS.secondary[500],
+  error: BRAND_COLORS.accent.red,
+  warning: BRAND_COLORS.accent.amber,
+  info: BRAND_COLORS.primary[500]
+};
+var LAYOUT_SPACING = {
+  nodeSpacing: 200,
+  levelSpacing: 150,
+  containerPadding: 20,
+  gridSize: 50
+};
+function getColorForLevel(level) {
+  return LEVEL_COLOR_ARRAY[level % LEVEL_COLOR_ARRAY.length];
+}
+
+// src/parser/configUtils.ts
+function createMindMapConfig(nodes, topLevelConnections, title = "Untitled Mindmap") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    metadata: {
+      title,
+      description: `Interactive mindmap with ${nodes.length} nodes`,
+      version: "1.0.0",
+      created: now,
+      lastModified: now
+    },
+    nodes,
+    topLevelConnections,
+    settings: {
+      defaultColors: {
+        level0: LEVEL_COLORS.level0,
+        level1: LEVEL_COLORS.level1,
+        level2: LEVEL_COLORS.level2,
+        level3: LEVEL_COLORS.level3
+      },
+      layout: {
+        nodeSpacing: LAYOUT_SPACING.nodeSpacing,
+        levelSpacing: LAYOUT_SPACING.levelSpacing
+      }
+    }
+  };
+}
+function generateId(prefix, level, index) {
+  return `${prefix}-l${level}-${index}`;
+}
+function generateLevelNodes(parentId, level, maxLevels, xOffset = 0, yOffset = 0) {
+  if (level >= maxLevels) return [];
+  const count = 5;
+  const levelSpacing = 200;
+  const nodeSpacing = 300;
+  const nodes = [];
+  for (let i = 0; i < count; i++) {
+    const nodeId = parentId ? generateId(`${parentId}-${i}`, level, i) : generateId("root", level, i);
+    const x = xOffset + (i - (count - 1) / 2) * nodeSpacing;
+    const y = yOffset + level * levelSpacing;
+    const node = {
+      id: nodeId,
+      title: `Level ${level} Node ${i + 1}`,
+      level,
+      x,
+      y,
+      color: getColorForLevel(level),
+      relationshipLabel: level > 0 ? "child" : void 0,
+      parent: parentId ?? void 0
+    };
+    const children = generateLevelNodes(nodeId, level + 1, maxLevels, x, y + levelSpacing);
+    if (children.length > 0) node.children = children;
+    nodes.push(node);
+  }
+  return nodes;
+}
+function generateSampleConfig(maxLevels = 9) {
+  const nodes = generateLevelNodes(null, 0, maxLevels, 0, 0);
+  const topLevelConnections = nodes.slice(0, -1).map((n, i) => ({
+    from: n.id,
+    to: nodes[i + 1].id,
+    label: "related to"
+  }));
+  return {
+    metadata: {
+      id: `mindmap-${Date.now()}`,
+      title: "Sample Mind Map",
+      description: "A sample mind map",
+      version: "1.0.0",
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    nodes,
+    topLevelConnections,
+    settings: {
+      defaultColors: {
+        level0: LEVEL_COLORS.level0,
+        level1: LEVEL_COLORS.level1,
+        level2: LEVEL_COLORS.level2,
+        level3: LEVEL_COLORS.level3,
+        level4: LEVEL_COLORS.level4,
+        level5: LEVEL_COLORS.level5,
+        level6: LEVEL_COLORS.level6,
+        level7: LEVEL_COLORS.level7,
+        level8: LEVEL_COLORS.level8
+      },
+      layout: {
+        nodeSpacing: LAYOUT_SPACING.nodeSpacing,
+        levelSpacing: LAYOUT_SPACING.levelSpacing
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VisualliParseError,
+  calculateDistance,
+  convertLayerToFlatNodes,
+  convertVisualliToFlatNodes,
+  countLayersBeneath,
+  createMindMapConfig,
+  fetchAndParseVisualli,
+  flattenNodes,
+  generateSampleConfig,
+  getChildLayers,
+  getNodeConnections,
+  getNodesForLayer,
+  getTopLevelConnections,
+  getVisibleNodes,
+  loadVisualliFileFromFile,
+  parseVisualliFile,
+  parseVisualliFromMongoDB,
+  resolveNodeOverlaps
+});
+//# sourceMappingURL=index.cjs.map