wendang-react 0.0.0-stage → 0.5.6

package/dist/chunks/katex-WjrodtTU.js

@@ -0,0 +1,71 @@
+"use client";
+function whenNearViewport(target, onVisible, options = {}) {
+  const factory = options.io ?? (typeof IntersectionObserver !== "undefined" ? (cb, opts) => new IntersectionObserver(cb, opts) : void 0);
+  if (!factory) {
+    onVisible();
+    return () => void 0;
+  }
+  let done = false;
+  const observer = factory(
+    (entries) => {
+      const hit = entries.some((e) => e.isIntersecting);
+      if (!hit || done) return;
+      done = true;
+      observer.disconnect();
+      onVisible();
+    },
+    { rootMargin: options.rootMargin ?? "200px" }
+  );
+  observer.observe(target);
+  return () => {
+    if (done) return;
+    done = true;
+    observer.disconnect();
+  };
+}
+let katexPromise = null;
+async function loadKatex() {
+  if (!katexPromise) {
+    katexPromise = import("katex").then((m) => m.default ?? m);
+  }
+  return katexPromise;
+}
+const cache = /* @__PURE__ */ new Map();
+const CACHE_LIMIT = 500;
+async function renderMathAsync(latex, displayMode) {
+  const key = `${displayMode ? "b" : "i"}:${latex}`;
+  const hit = cache.get(key);
+  if (hit) return { html: hit, error: null };
+  try {
+    const katex = await loadKatex();
+    const html = katex.renderToString(latex, {
+      displayMode,
+      // 关键安全选项：不允许 \href / \url / \htmlClass 等产生链接或属性
+      trust: false,
+      // 捕获解析错误并交给两端的统一错误态，避免红色 KaTeX 输出被缓存为成功。
+      throwOnError: true,
+      // 严格模式降级为忽略：不因排版细节让整个公式渲染失败
+      strict: "ignore",
+      output: "html"
+    });
+    if (cache.size >= CACHE_LIMIT) cache.clear();
+    cache.set(key, html);
+    return { html, error: null };
+  } catch (err) {
+    return {
+      html: "",
+      error: err instanceof Error ? err.message : "公式渲染失败"
+    };
+  }
+}
+let cssInjected = false;
+async function ensureKatexCss() {
+  if (cssInjected || typeof document === "undefined") return;
+  cssInjected = true;
+  await import("katex/dist/katex.min.css");
+}
+export {
+  ensureKatexCss as e,
+  renderMathAsync as r,
+  whenNearViewport as w
+};

package/dist/chunks/mind-map-controller-B6SxK3GZ.js

@@ -0,0 +1,479 @@
+"use client";
+import { closeHistory } from "@tiptap/pm/history";
+import { yUndoPluginKey } from "@tiptap/y-tiptap";
+import { p as planMindTopicDeletion } from "./mind-map-delete-CVsxdXfs.js";
+import { textDifference, MIND_MAP_MAX_TOPICS, mindMapId, mindMapTree, mindMapDescendants, mindMapOutline, projectMindSideMove, canMoveMindTopic, mindMapBranchSides, MIND_MAP_MAX_TEXT, readMindMap, MIND_MAP_VERSION } from "wendang/internal/mind-map";
+import { searchMindMap, topicTitle, topicField } from "wendang/internal/mind-map-phase2";
+function createMindMapController(editor, getPos, context = {}) {
+  var _a;
+  const listeners = /* @__PURE__ */ new Set(), sessions = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const initialPosition = getPos();
+  const identity = typeof initialPosition === "number" ? (_a = editor.state.doc.nodeAt(initialPosition)) == null ? void 0 : _a.attrs.id : void 0;
+  let composing = false;
+  function composition(active) {
+    var _a2;
+    if (active === composing) return;
+    composing = active;
+    const storage = (_a2 = editor.storage) == null ? void 0 : _a2.mindMap;
+    if (storage) storage.composing = Math.max(0, storage.composing + (active ? 1 : -1));
+  }
+  function current() {
+    if (disposed || editor.isDestroyed) return null;
+    const pos = getPos();
+    if (typeof pos !== "number") return null;
+    const node = editor.state.doc.nodeAt(pos);
+    if ((node == null ? void 0 : node.type.name) !== "mindMap" || node.attrs.id !== identity) return null;
+    const model = readMindMap(node.toJSON());
+    return model ? { node, pos, model } : null;
+  }
+  function topicAt(id) {
+    const map = current();
+    if (!map) return null;
+    let found = null;
+    map.node.forEach((node, offset) => {
+      if (node.attrs.id === id) found = { node, pos: map.pos + offset + 1 };
+    });
+    return found;
+  }
+  function topicInsertPos(map) {
+    let pos = map.pos + 1;
+    map.node.forEach((n) => {
+      if (n.type.name === "mindMapTopic") pos += n.nodeSize;
+    });
+    return pos;
+  }
+  function fieldAt(id, field) {
+    const t = topicAt(id);
+    if (!t) return null;
+    if (field === "title") return { ...t, text: topicTitle(t.node.toJSON()) };
+    let found = null;
+    t.node.forEach((n, offset) => {
+      if (n.type.name === (field === "description" ? "mindMapDescription" : "mindMapNote")) found = { node: n, pos: t.pos + 1 + offset, text: n.textContent };
+    });
+    return found;
+  }
+  const editable = () => !!current() && editor.isEditable;
+  function structuralChange(tr) {
+    var _a2;
+    const map = current();
+    if (map && map.node.attrs.formatVersion < MIND_MAP_VERSION) {
+      const mapped = tr.doc.nodeAt(tr.mapping.map(map.pos));
+      if ((mapped == null ? void 0 : mapped.type.name) === "mindMap") tr.setNodeMarkup(tr.mapping.map(map.pos), void 0, { ...mapped.attrs, formatVersion: MIND_MAP_VERSION });
+    }
+    const undoManager = (_a2 = yUndoPluginKey.getState(editor.state)) == null ? void 0 : _a2.undoManager;
+    undoManager == null ? void 0 : undoManager.stopCapturing();
+    editor.view.dispatch(closeHistory(tr));
+    undoManager == null ? void 0 : undoManager.stopCapturing();
+  }
+  function notify() {
+    for (const fn of listeners) fn();
+  }
+  function onTransaction({ transaction }) {
+    for (const [id, s] of sessions) {
+      const locate = (doc) => {
+        let result = null;
+        doc.descendants((node, pos) => {
+          if (node.type.name === "mindMapTopic" && node.attrs.id === id.split("::")[0]) {
+            result = { node, pos };
+            return false;
+          }
+          return !result;
+        });
+        return result;
+      };
+      const field = id.split("::")[1] || "title";
+      const before = locate(transaction.before), after = locate(transaction.doc);
+      if (!before || !after) {
+        sessions.delete(id);
+        continue;
+      }
+      const getText = (n) => field === "title" ? topicTitle(n.toJSON()) : topicField(n.toJSON(), field);
+      const diff = textDifference(getText(before.node), getText(after.node));
+      const shift = diff.text.length - (diff.to - diff.from);
+      s.boundaries = s.boundaries.map((p) => {
+        const offset = Math.max(0, Math.min(getText(before.node).length, p));
+        const mapped = offset < diff.from ? offset : offset >= diff.to ? offset + shift : diff.from + diff.text.length;
+        return Math.max(0, Math.min(getText(after.node).length, mapped));
+      });
+    }
+    notify();
+  }
+  editor.on("transaction", onTransaction);
+  editor.on("update", notify);
+  function beginText(id, field = "title") {
+    var _a2, _b, _c;
+    const t = fieldAt(id, field);
+    if (!t) return;
+    const text2 = t.text;
+    sessions.set(`${id}::${field}`, { text: text2, boundaries: Array.from({ length: text2.length + 1 }, (_, i) => i) });
+    const local = (_b = (_a2 = context.awareness) == null ? void 0 : _a2.getLocalState()) == null ? void 0 : _b.mindMap;
+    if ((local == null ? void 0 : local.blockId) === identity) (_c = context.awareness) == null ? void 0 : _c.setLocalStateField("mindMap", { ...local, topicId: id, editing: true });
+  }
+  function text(id, next, field = "title") {
+    if (!editable() || next.length > (field === "title" ? MIND_MAP_MAX_TEXT : 4e3)) return false;
+    let t = fieldAt(id, field);
+    if (!t && field !== "title") {
+      const topic = topicAt(id);
+      if (!topic) return false;
+      let pos = topic.pos + topic.node.nodeSize - 1;
+      if (field === "description") topic.node.forEach((n, offset) => {
+        if (n.type.name === "mindMapNote") pos = topic.pos + 1 + offset;
+      });
+      structuralChange(editor.state.tr.insert(pos, editor.schema.nodes[field === "description" ? "mindMapDescription" : "mindMapNote"].create()));
+      t = fieldAt(id, field);
+    }
+    if (!t) return false;
+    const key = `${id}::${field}`;
+    if (!sessions.has(key)) beginText(id, field);
+    const s = sessions.get(key);
+    const diff = textDifference(s.text, next);
+    if (diff.from === diff.to && !diff.text) return true;
+    const from = t.pos + 1 + s.boundaries[diff.from], to = t.pos + 1 + s.boundaries[diff.to];
+    if (from < t.pos + 1 || to > t.pos + 1 + t.text.length || from > to) return false;
+    const tr = editor.state.tr.insertText(diff.text, from, to);
+    editor.view.dispatch(tr);
+    const mapped = sessions.get(key);
+    if (!mapped) return false;
+    mapped.boundaries = [
+      ...mapped.boundaries.slice(0, diff.from),
+      ...Array.from({ length: diff.text.length + 1 }, (_, i) => from - t.pos - 1 + i),
+      ...mapped.boundaries.slice(diff.to + 1)
+    ];
+    mapped.text = next;
+    return true;
+  }
+  function patch(id, attrs) {
+    const t = topicAt(id);
+    if (!editable() || !t) return false;
+    structuralChange(editor.state.tr.setNodeMarkup(t.pos, void 0, { ...t.node.attrs, ...attrs }));
+    return true;
+  }
+  function orderAt(tr, siblings, index) {
+    var _a2, _b, _c;
+    const previous = ((_a2 = siblings[index - 1]) == null ? void 0 : _a2.order) ?? (((_b = siblings[index]) == null ? void 0 : _b.order) ?? 0) - 2048;
+    const next = ((_c = siblings[index]) == null ? void 0 : _c.order) ?? previous + 2048;
+    const value = (previous + next) / 2;
+    if (value > previous && value < next && Math.abs(value) < 1e12 && next - previous > Number.EPSILON * Math.max(1, Math.abs(previous), Math.abs(next)) * 8) return value;
+    siblings.forEach((t, i) => {
+      const existing = topicAt(t.id);
+      if (existing) tr.setNodeMarkup(existing.pos, void 0, { ...existing.node.attrs, order: i * 1024 });
+    });
+    return index * 1024 - 512;
+  }
+  function freezeBranchSides(tr, map) {
+    const sides = mindMapBranchSides(map.model);
+    for (const [id, side] of sides) {
+      const entry = topicAt(id);
+      tr.setNodeMarkup(entry.pos, void 0, { ...tr.doc.nodeAt(entry.pos).attrs, side });
+    }
+    return sides;
+  }
+  function insertTopic(parentId, referenceId, label = "新主题", placement = "after", requestedSide) {
+    const map = current();
+    if (!editable() || !map || map.model.topics.length >= MIND_MAP_MAX_TOPICS || !topicAt(parentId)) return null;
+    if (requestedSide !== void 0 && (parentId !== map.model.rootId || map.model.layout === "down" || requestedSide !== -1 && requestedSide !== 1)) return null;
+    const siblings = mindMapTree(map.model).filter((t) => t.parentId === parentId);
+    const at = siblings.findIndex((t) => t.id === referenceId);
+    if (referenceId && at < 0) return null;
+    const tr = editor.state.tr;
+    const order = orderAt(tr, siblings, at >= 0 ? at + (placement === "after" ? 1 : 0) : siblings.length);
+    const id = mindMapId();
+    const changeLayout = requestedSide !== void 0 && map.model.layout !== "both" && requestedSide !== (map.model.layout === "left" ? -1 : 1);
+    const sides = map.model.layout === "both" || changeLayout ? freezeBranchSides(tr, map) : mindMapBranchSides(map.model);
+    const side = requestedSide ?? (parentId === map.model.rootId ? referenceId ? sides.get(referenceId) : map.model.layout === "left" ? -1 : 1 : null);
+    const node = editor.schema.nodes.mindMapTopic.create(
+      { id, parentId, order, side },
+      label ? editor.schema.text(label.slice(0, MIND_MAP_MAX_TEXT)) : void 0
+    );
+    if (changeLayout) tr.setNodeMarkup(map.pos, void 0, { ...map.node.attrs, layout: "both" });
+    structuralChange(tr.insert(topicInsertPos(map), node));
+    return id;
+  }
+  function add(parentId, afterId, label = "新主题") {
+    return insertTopic(parentId, afterId, label);
+  }
+  function addRootChild(side, label = "新主题") {
+    const map = current();
+    return map ? insertTopic(map.model.rootId, void 0, label, "after", side) : null;
+  }
+  function addSibling(id, placement, label = "新主题") {
+    const map = current();
+    if (!map || id === map.model.rootId) return null;
+    const topic = mindMapTree(map.model).find((t) => t.id === id);
+    return (topic == null ? void 0 : topic.parentId) ? insertTopic(topic.parentId, id, label, placement) : null;
+  }
+  function move(id, targetId, mode = "child") {
+    const map = current();
+    if (!map || !editable()) return false;
+    const tree = mindMapTree(map.model), target = tree.find((t) => t.id === targetId);
+    if (!target) return false;
+    const parentId = mode === "child" ? targetId : target.parentId;
+    if (!canMoveMindTopic(map.model, id, parentId) || id === targetId) return false;
+    const siblings = tree.filter((t) => t.parentId === parentId && t.id !== id);
+    const tr = editor.state.tr;
+    let index;
+    if (mode === "child") index = siblings.length;
+    else {
+      const at = siblings.findIndex((t) => t.id === targetId);
+      if (at < 0) return false;
+      index = mode === "before" ? at : at + 1;
+    }
+    const order = orderAt(tr, siblings, index), node = topicAt(id);
+    const sides = mindMapBranchSides(map.model);
+    if (parentId === map.model.rootId) {
+      for (const sibling of tree.filter((t) => t.parentId === parentId && t.id !== id)) {
+        const entry = topicAt(sibling.id);
+        tr.setNodeMarkup(entry.pos, void 0, { ...tr.doc.nodeAt(entry.pos).attrs, side: sides.get(sibling.id) });
+      }
+    }
+    const side = parentId === map.model.rootId ? sides.get(mode === "child" ? id : targetId) ?? (map.model.layout === "left" ? -1 : 1) : null;
+    tr.setNodeMarkup(node.pos, void 0, { ...tr.doc.nodeAt(node.pos).attrs, parentId, order, side });
+    structuralChange(tr);
+    return true;
+  }
+  function moveToSide(id, side, beforeId) {
+    const map = current();
+    if (!map || !editable()) return false;
+    const projected = projectMindSideMove(map.model, id, side, beforeId);
+    if (!projected) return false;
+    const tr = editor.state.tr;
+    for (const topic of projected.topics) {
+      const before = map.model.topics.find((t) => t.id === topic.id);
+      if (before.parentId === topic.parentId && before.order === topic.order && before.side === topic.side) continue;
+      const entry = topicAt(topic.id);
+      tr.setNodeMarkup(entry.pos, void 0, { ...entry.node.attrs, parentId: topic.parentId, order: topic.order, side: topic.side ?? null });
+    }
+    if (map.model.layout !== projected.layout) tr.setNodeMarkup(map.pos, void 0, { ...map.node.attrs, layout: projected.layout });
+    if (tr.docChanged) structuralChange(tr);
+    return true;
+  }
+  function remove(id) {
+    return removeMany([id]);
+  }
+  function removeMany(selection) {
+    const map = current();
+    if (!editable() || !map) return false;
+    const plan = planMindTopicDeletion(map.model, selection);
+    if (!plan) return false;
+    const { ids } = plan;
+    const ranges = [];
+    map.node.forEach((t, offset) => {
+      if (ids.has(t.attrs.id) || t.type.name === "mindMapRelation" && (ids.has(t.attrs.source) || ids.has(t.attrs.target))) ranges.push({ from: map.pos + 1 + offset, to: map.pos + 1 + offset + t.nodeSize });
+    });
+    const tr = editor.state.tr;
+    if (map.model.layout === "both") freezeBranchSides(tr, map);
+    for (const range of ranges.reverse()) tr.delete(range.from, range.to);
+    structuralChange(tr);
+    return true;
+  }
+  function settings(attrs) {
+    const map = current();
+    if (!editable() || !map) return false;
+    const tr = editor.state.tr;
+    if (attrs.layout && attrs.layout !== map.model.layout) for (const topic of map.model.topics.filter((t) => t.parentId === map.model.rootId)) {
+      const entry = topicAt(topic.id);
+      if (entry.node.attrs.side !== null) tr.setNodeMarkup(entry.pos, void 0, { ...entry.node.attrs, side: null });
+    }
+    structuralChange(tr.setNodeMarkup(map.pos, void 0, { ...map.node.attrs, ...attrs }));
+    return true;
+  }
+  function addParent(id) {
+    const map = current(), t = topicAt(id);
+    if (!map || !t || !editable() || id === map.model.rootId || map.model.topics.length >= 500) return null;
+    const projected = mindMapTree(map.model).find((n) => n.id === id);
+    const newId = mindMapId(), tr = editor.state.tr;
+    if (map.model.layout === "both") freezeBranchSides(tr, map);
+    tr.setNodeMarkup(t.pos, void 0, { ...t.node.attrs, parentId: newId, order: 0 });
+    tr.insert(topicInsertPos(map), editor.schema.nodes.mindMapTopic.create({ id: newId, parentId: projected.parentId, order: projected.order, side: mindMapBranchSides(map.model).get(id) ?? null }, editor.schema.text("父主题")));
+    structuralChange(tr);
+    return newId;
+  }
+  function indent(id, out = false) {
+    const map = current();
+    if (!map) return false;
+    const tree = mindMapTree(map.model), topic = tree.find((t) => t.id === id);
+    if (!topic || !topic.parentId) return false;
+    if (out) {
+      const parent = tree.find((t) => t.id === topic.parentId);
+      return !!(parent == null ? void 0 : parent.parentId) && move(id, parent.id, "after");
+    }
+    const siblings = tree.filter((t) => t.parentId === topic.parentId), at = siblings.findIndex((t) => t.id === id);
+    return at > 0 && move(id, siblings[at - 1].id);
+  }
+  function format(id, from, to, mark, attrs) {
+    const t = fieldAt(id, "title"), type = editor.schema.marks[mark];
+    if (!editable() || !t || !type || from < 0 || to > t.text.length || to <= from) return false;
+    const start = t.pos + 1 + from, end = t.pos + 1 + to, tr = editor.state.tr;
+    if (!attrs && editor.state.doc.rangeHasMark(start, end, type)) tr.removeMark(start, end, type);
+    else tr.addMark(start, end, type.create(attrs));
+    structuralChange(tr);
+    return true;
+  }
+  function clearFormat(id, from, to, marks) {
+    const t = fieldAt(id, "title");
+    if (!editable() || !t || from < 0 || to > t.text.length || to <= from) return false;
+    const tr = editor.state.tr;
+    if (marks) for (const name of marks) {
+      const mark = editor.schema.marks[name];
+      if (mark) tr.removeMark(t.pos + 1 + from, t.pos + 1 + to, mark);
+    }
+    else tr.removeMark(t.pos + 1 + from, t.pos + 1 + to);
+    structuralChange(tr);
+    return true;
+  }
+  function replace(query, replacement, target) {
+    const map = current();
+    if (!map || !editable() || !query) return 0;
+    const hits = target ? [target] : searchMindMap(map.model, query), tr = editor.state.tr;
+    if (hits.length > 5e3) return -1;
+    const counts = /* @__PURE__ */ new Map();
+    for (const hit of hits) counts.set(`${hit.id}::${hit.field}`, (counts.get(`${hit.id}::${hit.field}`) ?? 0) + 1);
+    for (const [key, count] of counts) {
+      const [id, field] = key.split("::"), t = fieldAt(id, field);
+      if (t && t.text.length + count * (replacement.length - query.length) > (field === "title" ? 2e3 : 4e3)) return -2;
+    }
+    const ranges = hits.flatMap((hit) => {
+      const t = fieldAt(hit.id, hit.field);
+      if (!t || t.text.slice(hit.from, hit.to).toLocaleLowerCase() !== query.toLocaleLowerCase()) return [];
+      if (t.text.length + replacement.length - query.length > (hit.field === "title" ? 2e3 : 4e3)) return [];
+      return [{ from: t.pos + 1 + hit.from, to: t.pos + 1 + hit.to }];
+    }).sort((a, b) => b.from - a.from);
+    for (const r of ranges) tr.insertText(replacement, r.from, r.to);
+    if (ranges.length) structuralChange(tr);
+    return ranges.length;
+  }
+  function relation(value) {
+    const map = current();
+    if (!map || !editable() || value.source === value.target || !topicAt(value.source) || !topicAt(value.target)) return false;
+    let found = null;
+    map.node.forEach((node, offset) => {
+      if (node.type.name === "mindMapRelation" && node.attrs.id === value.id) found = { node, pos: map.pos + 1 + offset };
+    });
+    const prior = found, attrs = { ...value, id: value.id ?? mindMapId(), label: value.label.slice(0, 200) };
+    structuralChange(prior ? editor.state.tr.setNodeMarkup(prior.pos, void 0, attrs) : editor.state.tr.insert(map.pos + map.node.nodeSize - 1, editor.schema.nodes.mindMapRelation.create(attrs)));
+    return true;
+  }
+  function deleteRelation(id) {
+    const map = current();
+    if (!map || !editable()) return false;
+    const tr = editor.state.tr;
+    let found = false;
+    map.node.forEach((node, offset) => {
+      if (node.type.name === "mindMapRelation" && node.attrs.id === id) {
+        tr.delete(map.pos + 1 + offset, map.pos + 1 + offset + node.nodeSize);
+        found = true;
+      }
+    });
+    if (found) structuralChange(tr);
+    return found;
+  }
+  function copyBranch(id) {
+    const map = current();
+    if (!map) return [];
+    const ids = mindMapDescendants(map.model, id);
+    const topics = new Map((map.node.toJSON().content ?? []).map((t) => {
+      var _a2;
+      return [String((_a2 = t.attrs) == null ? void 0 : _a2.id), t];
+    }));
+    return [
+      ...mindMapOutline(map.model).filter((t) => ids.has(t.id)).map((t) => topics.get(t.id)),
+      ...(map.node.toJSON().content ?? []).filter((t) => {
+        var _a2, _b;
+        return t.type === "mindMapRelation" && ids.has(String((_a2 = t.attrs) == null ? void 0 : _a2.source)) && ids.has(String((_b = t.attrs) == null ? void 0 : _b.target));
+      })
+    ];
+  }
+  function pasteBranch(parentId, branch) {
+    var _a2, _b, _c, _d;
+    const map = current();
+    if (!editable() || !map || !topicAt(parentId) || !branch.length || branch.filter((t) => t.type === "mindMapTopic").length + map.model.topics.length > MIND_MAP_MAX_TOPICS) return null;
+    const topics = branch.filter((t) => t.type === "mindMapTopic");
+    if (!topics.length) return null;
+    const ids = new Map(topics.map((t) => {
+      var _a3;
+      return [String((_a3 = t.attrs) == null ? void 0 : _a3.id), mindMapId()];
+    }));
+    const siblings = mindMapTree(map.model).filter((t) => t.parentId === parentId);
+    const nodes = topics.map((t, i) => {
+      var _a3, _b2, _c2, _d2, _e;
+      return editor.schema.nodeFromJSON({ ...t, attrs: {
+        ...t.attrs,
+        id: ids.get(String((_a3 = t.attrs) == null ? void 0 : _a3.id)),
+        parentId: ids.get(String((_b2 = t.attrs) == null ? void 0 : _b2.parentId)) ?? parentId,
+        order: ids.has(String((_c2 = t.attrs) == null ? void 0 : _c2.parentId)) ? Number((_d2 = t.attrs) == null ? void 0 : _d2.order) || 0 : (((_e = siblings.at(-1)) == null ? void 0 : _e.order) ?? -1) + 1 + i
+      } });
+    });
+    const tr = editor.state.tr.insert(topicInsertPos(map), nodes);
+    for (const r of branch.filter((t) => t.type === "mindMapRelation")) {
+      if (ids.has(String((_a2 = r.attrs) == null ? void 0 : _a2.source)) && ids.has(String((_b = r.attrs) == null ? void 0 : _b.target)))
+        tr.insert(tr.mapping.map(map.pos + map.node.nodeSize - 1), editor.schema.nodes.mindMapRelation.create({ ...r.attrs, id: mindMapId(), source: ids.get(String((_c = r.attrs) == null ? void 0 : _c.source)), target: ids.get(String((_d = r.attrs) == null ? void 0 : _d.target)) }));
+    }
+    structuralChange(tr);
+    return nodes[0].attrs.id;
+  }
+  return {
+    context,
+    snapshot: () => {
+      var _a2;
+      return ((_a2 = current()) == null ? void 0 : _a2.model) ?? null;
+    },
+    editable,
+    beginText,
+    text,
+    composition,
+    patch,
+    addParent,
+    indent,
+    format,
+    clearFormat,
+    replace,
+    relation,
+    deleteRelation,
+    hasActiveText: () => sessions.size > 0,
+    endText: (id, field = "title") => {
+      var _a2, _b, _c;
+      sessions.delete(`${id}::${field}`);
+      const local = (_b = (_a2 = context.awareness) == null ? void 0 : _a2.getLocalState()) == null ? void 0 : _b.mindMap;
+      if ((local == null ? void 0 : local.blockId) === identity) (_c = context.awareness) == null ? void 0 : _c.setLocalStateField("mindMap", { ...local, editing: sessions.size > 0 });
+    },
+    add,
+    addRootChild,
+    addSibling,
+    move,
+    moveToSide,
+    remove,
+    removeMany,
+    settings,
+    copyBranch,
+    pasteBranch,
+    undo: () => editable() && editor.commands.undo(),
+    redo: () => editable() && editor.commands.redo(),
+    canUndo: () => editable() && editor.can().undo(),
+    canRedo: () => editable() && editor.can().redo(),
+    canExport: () => {
+      var _a2;
+      return ((_a2 = context.canExport) == null ? void 0 : _a2.call(context)) ?? false;
+    },
+    status: () => {
+      var _a2;
+      return ((_a2 = context.status) == null ? void 0 : _a2.call(context)) ?? "";
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    dispose() {
+      composition(false);
+      disposed = true;
+      editor.off("transaction", onTransaction);
+      editor.off("update", notify);
+      notify();
+      listeners.clear();
+      sessions.clear();
+    }
+  };
+}
+export {
+  createMindMapController as c
+};

package/dist/chunks/mind-map-delete-CVsxdXfs.js

@@ -0,0 +1,31 @@
+"use client";
+import { mindMapTree } from "wendang/internal/mind-map";
+function planMindTopicDeletion(model, selection, activeId) {
+  var _a, _b;
+  const tree = mindMapTree(model), byId = new Map(tree.map((topic) => [topic.id, topic]));
+  const selected = [...new Set(selection)];
+  if (!selected.length || selected.some((id) => !byId.has(id))) return null;
+  const targets = selected.filter((id) => id !== model.rootId);
+  if (!targets.length) return null;
+  const children = /* @__PURE__ */ new Map();
+  for (const topic of tree) {
+    const siblings = children.get(topic.parentId) ?? [];
+    siblings.push(topic.id);
+    children.set(topic.parentId, siblings);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const pending = [...targets];
+  while (pending.length) {
+    const id = pending.pop();
+    if (ids.has(id)) continue;
+    ids.add(id);
+    pending.push(...children.get(id) ?? []);
+  }
+  const roots = targets.filter((id) => !ids.has(byId.get(id).parentId));
+  let nextId = ((_a = byId.get(activeId ?? targets.at(-1))) == null ? void 0 : _a.parentId) || model.rootId;
+  while (ids.has(nextId)) nextId = ((_b = byId.get(nextId)) == null ? void 0 : _b.parentId) || model.rootId;
+  return { ids, roots, nextId, keepsCenter: selected.includes(model.rootId) };
+}
+export {
+  planMindTopicDeletion as p
+};

package/dist/chunks/mind-map-input-CEWRz_t6.js

@@ -0,0 +1,43 @@
+"use client";
+function selectMindTopic(current, id, additive = false) {
+  if (!additive) return /* @__PURE__ */ new Set([id]);
+  const next = new Set(current);
+  if (next.has(id)) next.delete(id);
+  else next.add(id);
+  return next;
+}
+function resetMindZoom(viewport, width, height) {
+  return {
+    x: width / 2 - (width / 2 - viewport.x) / viewport.zoom,
+    y: height / 2 - (height / 2 - viewport.y) / viewport.zoom,
+    zoom: 1
+  };
+}
+function mindCanvasShortcut(event) {
+  if (event.isComposing || event.keyCode === 229 || event.altKey) return null;
+  if (event.metaKey || event.ctrlKey) {
+    if (event.key === "+" || event.key === "=") return "zoom-in";
+    if (event.key === "-") return "zoom-out";
+    if (!event.shiftKey && event.key === "0") return "reset-zoom";
+    return null;
+  }
+  if (event.metaKey || event.ctrlKey || !event.shiftKey) return null;
+  switch (event.key.toLowerCase()) {
+    case "c":
+      return "comments";
+    case "q":
+      return "quick";
+    case "g":
+      return "grid";
+    case "1":
+    case "!":
+      return "fit";
+    default:
+      return null;
+  }
+}
+export {
+  mindCanvasShortcut as m,
+  resetMindZoom as r,
+  selectMindTopic as s
+};