flow-mindmap 0.3.8 → 0.4.0

package/dist/core/layout.d.ts

@@ -1,144 +0,0 @@
-export interface LayoutNode {
-    id: string;
-    text: string;
-    depth: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Font size to render this node's text at, in px. */
-    fontSize: number;
-    isRoot: boolean;
-    collapsed?: boolean;
-    side: 1 | -1;
-    /**
-     * Direction this node's children fan out in: 'right' (default for
-     * mindmap right side / tree), 'left' (mindmap left side), or 'down'
-     * (org mode).
-     */
-    _dir: 'right' | 'left' | 'down';
-    /** Direction this node's children fan out in, as a signed scalar
-     *  (1 = right, -1 = left).  Mirrors `_dir` for callers that need
-     *  a number.  Kept in sync by applyDoLayout and forceRight — when
-     *  the height-based balancer moves a child to the opposite side,
-     *  the whole subtree gets its `side` / `_dir` / `_dirRight`
-     *  re-stamped so descendants fan the right way. */
-    _dirRight: 1 | -1;
-    /** Layout-only: vertical extent of this node's subtree (post-order
-     *  walk result, read by layoutHorizontal).  Not for public use. */
-    _subtreeH: number;
-    /** Layout-only: horizontal extent of this node's subtree (read by
-     *  layoutVertical / org mode).  Not for public use. */
-    _subtreeW: number;
-    /** Optional embedded image (mirrored from MindMapNode.image).
-     *  The renderer uses src/width/height; naturalW/H lock the
-     *  resize aspect ratio. */
-    image?: MindMapImage;
-    /** Mirrored from MindMapNode.link.  Read by the renderer to
-     *  show a link icon next to the text. */
-    link?: {
-        url: string;
-    };
-    /** Mirrored from MindMapNode.note.  Read by the renderer to
-     *  show a note icon next to the text. */
-    note?: {
-        text: string;
-    };
-    /** Mirrored from MindMapNode.richContent.  Read by the renderer
-     *  to show a small framed body under the node title (code / list /
-     *  table / paragraph).  Undefined means the node is plain text
-     *  only — the default behaviour, unchanged from before this
-     *  field was introduced. */
-    richContent?: RichContent;
-    /** Inset (px) the SVG edge anchor should retreat from the
-     *  geometric box edge on the in-side, to land at the visible
-     *  content edge instead.  Set to `.zm-node` padding +
-     *  `.zm-rich` padding + 2 for code/table nodes (their visible
-     *  content sits well inside the box); 0 for plain nodes (the
-     *  geometric edge IS the visible edge).  Used by lineAnchor
-     *  in MindMap.vue — non-zero for nodes whose first child of
-     *  the line would otherwise appear to pierce the rich body. */
-    _richInsetX?: number;
-    children: LayoutNode[];
-    parent: LayoutNode | null;
-}
-import type { MindMapNode, MindMapImage, RichContent } from '../types';
-/** Return the rendered font size for a node at the given depth, scaled
- *  by the host's `theme.fontSize` (default 14).  The base table is
- *  tuned at 14px; values scale linearly so a 30px theme produces
- *  roughly 2.14× larger nodes. */
-declare function fontAt(depth: number, baseFontSize?: number): number;
-declare function heightAt(depth: number, baseFontSize?: number): number;
-/** Max text-label width in px.  MUST match `max-width` on `.zm-text`
- *  in MindMap.vue.  The layout reserves this much room for the label
- *  regardless of how long the actual text is — the DOM then truncates
- *  with `text-overflow: ellipsis`.  Without this cap, a long string
- *  pushes the rendered node box past the layout's reserved width and
- *  the line anchor (computed from layout width) ends up inside the
- *  box.  The 200px default is the same value `flow-mindmap` shipped
- *  with before; keeping it keeps edge anchors stable. */
-export declare const TEXT_MAX_W = 200;
-export type LayoutMode = 'mindmap' | 'tree' | 'org';
-export interface LayoutOptions {
-    mode?: LayoutMode;
-    /** @deprecated kept for API compat; ignored in 1.html-style layout. */
-    balanced?: boolean;
-    /** Base font size (px) used to scale node metrics (font/height/
-     *  min-width).  The internal tier table is tuned for 14px; values
-     *  scale linearly.  Default 14. */
-    baseFontSize?: number;
-    /**
-     * When true, layout() leaves each LayoutNode's existing x/y in
-     * place — it still does the doLayout split / redirect / stack
-     * walk, but skips writing to child.x / child.y.  Used after a
-     * drag: we commit the offset into the data tree, clear the
-     * per-node offset map, then re-run layout with this flag so
-     * the dragged node (and its subtree) stay where the user put
-     * them.  The root is still forced to (0, 0) — to put the
-     * dragged node at a new position, the surrounding tree moves
-     * relative to it.  New nodes added later get the algorithmic
-     * position since their LayoutNode has x = 0, y = 0.
-     */
-    preservePositions?: boolean;
-    /**
-     * Per-node measured size of the rendered rich body (the
-     * `<div class="zm-rich">` element above the title), in px.  The
-     * caller (MindMap.vue) populates this after each render with
-     * `el.offsetWidth` / `el.offsetHeight`; layout reads it for
-     * nodes that carry code / table rich content.  When a node has
-     * a measured size we use it directly so the box grows /
-     * shrinks to fit the content.  When the caller hasn't
-     * measured a node yet we fall back to the fixed floor / cap.
-     * IDs not present in the map are simply ignored — useful for
-     * the very first render before measurement has happened.
-     */
-    richHeights?: Record<string, number>;
-    richWidths?: Record<string, number>;
-}
-export declare function layout(root: MindMapNode, options?: LayoutOptions): {
-    root: LayoutNode;
-    width: number;
-    height: number;
-    vbX: number;
-    vbY: number;
-    vbW: number;
-    vbH: number;
-};
-export declare const LAYOUT: {
-    /** Legacy single-size values for callers that still expect them. */
-    NODE_W: number;
-    NODE_H: number;
-    NODE_FONTS: number[];
-    NODE_HEIGHTS: number[];
-    NODE_MIN_W: number[];
-    NODE_PAD_H: number[];
-    NODE_FONT_WEIGHTS: number[];
-    H_GAP: number;
-    V_GAP: number;
-    SIDE_PADDING: number;
-    heightAt: typeof heightAt;
-    fontAt: typeof fontAt;
-    /** Clear the text-measurement cache (call after font load). */
-    clearMeasureCache: () => void;
-};
-export {};

package/dist/core/palettes.d.ts

@@ -1,43 +0,0 @@
-export interface BranchPalette {
-    id: string;
-    name: string;
-    /** Hex colors cycled across top-level branches, in display order. */
-    colors: string[];
-}
-export declare const BUILTIN_PALETTES: readonly BranchPalette[];
-/**
- * Resolve a palette by id from a combined list of built-ins and
- * user-defined custom palettes.  Falls back to the default palette
- * if `id` is missing or points at a deleted custom palette.  Pure
- * — no DOM, no reactive deps — so it can be called from a computed
- * or a watch.
- */
-export declare function resolvePalette(id: string, customPalettes?: readonly BranchPalette[]): BranchPalette;
-/**
- * Parse a free-form text blob into a cleaned color array.  Accepts:
- *
- *   1. **Hex codes** — `#rgb` / `#rgba` / `#rrggbb` / `#rrggbbaa`,
- *      with or without the leading `#`.  The alpha channel on
- *      4- or 8-digit hex is silently dropped.
- *   2. **`rgb()` / `rgba()` functions** — `rgb(255, 99, 71)`,
- *      `rgba(255,99,71,0.5)`.  Whitespace and percentage values
- *      are both accepted (matches CSS rules).  Alpha dropped.
- *   3. **CSS named colors** — the 30 most common (`red`, `tomato`,
- *      `coral`, `teal`, …).  A small curated set keeps the parser
- *      from silently accepting typos that look color-ish
- *      (`tan`, `peru` are in; `chartreuse1` is not).
- *   4. **JSON / JS array** — `['#f87171', 'red']`,
- *      `["#f87171","rgb(0,0,255)"]`, even a single-line
- *      `["red","blue"]`.  Bracket and quote chars are tolerated
- *      so a copy-pasted `[…]` round-trips cleanly.
- *   5. **Any-delimiter blob** — the parser scans the raw text for
- *      color-shaped substrings rather than splitting on commas,
- *      so a user can paste `rgb(255, 0, 0), #0f0, blue` and every
- *      piece lands.
- *
- * Malformed tokens are dropped silently (consistent with the
- * rest of the canvas's "paste messy text" UX).  Returns at most
- * `maxColors` entries; output is lowercased `#rrggbb` for stable
- * dedup and direct comparison with `BUILTIN_PALETTES`.
- */
-export declare function parsePaletteInput(text: string, maxColors?: number): string[];

package/dist/entry.d.ts

@@ -1,11 +0,0 @@
-import MindMap from './components/MindMap.vue';
-import type { App } from 'vue';
-import type { MindMapNode, MindMapOptions, MindMapTheme, MindMapExpose, MindMapSettings, NodeStyle, LineStyle, LayoutMode, BranchPalette, BranchPaletteId, RichContent } from './types';
-import { uid, clone, findNode, findParent, removeNode, addChild, addSibling, markdownToMindMap, mindMapToMarkdown, markdownToRichMindMap, richBlockToMarkdown } from './tree';
-export type { MindMapNode, MindMapOptions, MindMapTheme, MindMapExpose, MindMapSettings, NodeStyle, LineStyle, LayoutMode, BranchPalette, BranchPaletteId, RichContent };
-export { MindMap };
-export { uid, clone, findNode, findParent, removeNode, addChild, addSibling, markdownToMindMap, mindMapToMarkdown, markdownToRichMindMap, richBlockToMarkdown };
-declare const plugin: {
-    install(app: App): void;
-};
-export default plugin;

package/dist/tree.d.ts

@@ -1,96 +0,0 @@
-import type { MindMapNode } from './types';
-export declare function uid(): string;
-export declare function clone<T>(o: T): T;
-export declare function findNode(root: MindMapNode, id: string): MindMapNode | null;
-export declare function findParent(root: MindMapNode, id: string, parent?: MindMapNode | null): MindMapNode | null;
-export declare function removeNode(root: MindMapNode, id: string): boolean;
-/** Replace the text of a node by id.  Returns true on success, false
- *  if the node was not found.  No-op on an empty / same string. */
-export declare function setNodeText(root: MindMapNode, id: string, text: string): boolean;
-/** Position relative to a target node when moving a sibling. */
-export type MovePosition = 'before' | 'after' | 'child';
-/** Move a node to a new location in the tree.
- *  - 'before' / 'after': insert as a sibling of the target at that slot
- *    (target's parent's children array).
- *  - 'child': insert as the last child of the target.
- *  No-op (returns false) if src === root, or if the move would
- *  create a cycle (i.e. the target lives inside the src subtree, or
- *  src is already in the target's desired position). */
-export declare function moveNode(root: MindMapNode, srcId: string, targetId: string, position: MovePosition): boolean;
-export declare function addChild(root: MindMapNode, parentId: string, text?: string): MindMapNode | null;
-export declare function addSibling(root: MindMapNode, nodeId: string, text?: string): MindMapNode | null;
-/**
- * Insert a new sibling node BEFORE the given node (Shift+Enter in xmind).
- * Returns the new node, or null if the target is the root.
- */
-export declare function addSiblingBefore(root: MindMapNode, nodeId: string, text?: string): MindMapNode | null;
-/**
- * Deep-clone a node (with all its descendants) and insert the copy as a
- * sibling immediately after the original. New ids are generated so the
- * result is a real duplicate. Returns the new node, or null if the
- * target is the root.
- */
-export declare function duplicateNode(root: MindMapNode, nodeId: string): MindMapNode | null;
-export declare function countDescendants(n: MindMapNode): number;
-export declare const DEFAULT_NEW_NODE_TEXT = "\u65B0\u8282\u70B9";
-/**
- * Parse a Markdown string into a MindMapNode tree.  Each heading
- * becomes a node; its level sets the depth.
- *   - `# Title`     → root text (overrides `rootText`)
- *   - `## Sub`      → child of the previous #/##/... heading
- *   - bullet / paragraph text between headings → first child
- *     of the preceding heading (so a `# Topic\n- detail` tree
- *     gives one root node with one child).
- *
- * Inline fields parsed from a heading's body (in order, attached
- * to the heading that precedes them):
- *   - `![alt](url)`            → image
- *   - `[label](url)`           → link (label becomes the node's text)
- *   - ` ```note ... ``` `      → note (the fence body becomes note.text)
- *
- * Empty input, or input with no `#` heading, returns a single
- * root with the fallback text.
- */
-export declare function markdownToMindMap(md: string, rootText?: string): MindMapNode;
-/**
- * Round-trip-safe Markdown export of a MindMapNode tree.  Each
- * heading is emitted as `#…`, then any inline fields (link /
- * image / note) in a fixed order so the same source produces
- * byte-stable output across re-exports.
- *
- * The `note` field round-trips through a ` ```note ` fence so a
- * user opening the export in any markdown editor sees a clearly
- * labeled block.  The link is emitted as a standard `[label](url)`
- * with the node's text as the label — this keeps the export
- * human-readable and lets `markdownToMindMap` re-attach the
- * link to the right heading.
- */
-export declare function mindMapToMarkdown(n: MindMapNode, depth?: number): string;
-/**
- * Parse a whole markdown document into a MindMapNode tree where
- * every block (heading, paragraph, list, code fence, table)
- * becomes a node.  Body blocks carry their original markdown
- * payload in `node.richContent` so the renderer can show code,
- * tables, lists, etc. inside the node box.  Headings form the
- * hierarchy; everything else is attached to the most recent
- * heading as a child (or to the synthetic root if no heading
- * has been seen yet).
- *
- * Unlike `markdownToMindMap`, this does NOT collapse body into
- * a single child of the heading, and the depth is unbounded —
- * a paragraph under `## Foo` becomes a child of `Foo`, and a
- * paragraph that follows a list under the same heading becomes
- * a sibling of that list, etc.  This is the mode the user
- * asked for: "every paragraph becomes a child, no depth limit".
- *
- * A document with no `#` heading still produces a valid tree —
- * every block lands under the synthetic root.
- */
-export declare function markdownToRichMindMap(md: string, rootText?: string): MindMapNode;
-/**
- * Serialize a single node's rich body (if any) back to the
- * original markdown it came from.  Used by `mindMapToMarkdown`
- * to round-trip a tree built by `markdownToRichMindMap`.
- * Returns '' when the node has no rich body.
- */
-export declare function richBlockToMarkdown(n: MindMapNode): string;

package/dist/types.d.ts

@@ -1,270 +0,0 @@
-export interface MindMapNode {
-    id: string;
-    text: string;
-    children: MindMapNode[];
-    collapsed?: boolean;
-    /**
-     * Reserved for the layout algorithm — do not set or read from
-     * your own code.  After a drag, MindMap writes the dragged
-     * node's offset into the data tree so a subsequent layout with
-     * `preservePositions: true` can keep the node where the user
-     * put it.  Cleared on the next data-mutating action (add,
-     * remove, edit, import) so unrelated re-layouts don't keep
-     * stale overrides around.
-     */
-    _x?: number;
-    _y?: number;
-    /**
-     * Optional embedded image shown above the node text.  The
-     * image is stored as either a remote URL (preferred) or a
-     * data: URL (fallback for local-file uploads); width/height
-     * reflect the rendered size, which the user can resize via
-     * a drag handle.  naturalW/naturalH preserve the source
-     * aspect ratio so a resize keeps the original proportions.
-     */
-    image?: MindMapImage;
-    /**
-     * Optional external link.  When set, the node renders a
-     * small link icon next to its text; clicking the icon
-     * navigates to `url` in a new tab.  No validation is
-     * performed at write time — the rendering layer is
-     * responsible for rejecting dangerous schemes (javascript:,
-     * data:, …) before following the link.
-     */
-    link?: {
-        url: string;
-    };
-    /**
-     * Optional free-form note.  When set, the node renders a
-     * small note icon next to its text; clicking the icon
-     * expands an inline textarea below the node for editing,
-     * hovering the icon shows a tooltip preview.  An empty
-     * `text` field is treated as "no note" by the UI.
-     */
-    note?: {
-        text: string;
-    };
-    /**
-     * Optional rich body.  When set, the node renders the raw
-     * markdown payload in a small framed block under the title
-     * (code fences get monospace styling, lists get bullet
-     * markers, tables get a mini grid, paragraphs get plain
-     * text).  Produced by `markdownToRichMindMap` so a whole
-     * markdown document can be previewed as a mindmap without
-     * losing its body content.  The first line of `raw` is
-     * still available as `text` so the node always has a
-     * meaningful label.
-     */
-    richContent?: RichContent;
-}
-/**
- * A node body that came from a markdown block.  `raw` is the
- * original markdown source for the block (preserved verbatim so
- * `mindMapToMarkdown` can re-emit it byte-for-byte).  `kind`
- * tells the renderer which layout to use.
- */
-export interface RichContent {
-    kind: 'code' | 'list' | 'table' | 'paragraph';
-    /** Original markdown source.  Always non-empty. */
-    raw: string;
-    /**
-     * Optional language tag for code blocks (the info string after
-     * the opening fence).  `undefined` for non-code kinds.
-     */
-    lang?: string;
-}
-export interface MindMapImage {
-    /** Remote URL or data URL.  Always a string — never undefined. */
-    src: string;
-    /** Source image intrinsic size, in px.  Used to lock aspect
-     *  ratio during a user-driven resize. */
-    naturalW: number;
-    naturalH: number;
-    /** Current rendered size, in px.  Drag handle writes to these
-     *  fields.  Clamped to a sane range by the layout (≥24, ≤400). */
-    width: number;
-    height: number;
-}
-export interface MindMapOptions {
-    data: MindMapNode;
-    theme?: MindMapTheme;
-}
-export interface MindMapTheme {
-    rootBg?: string;
-    rootText?: string;
-    branchBg?: string;
-    branchText?: string;
-    lineColor?: string;
-    bgColor?: string;
-    fontSize?: number;
-    /** Stroke width of SVG connecting paths at the *parent-end* of the
-       *  edge, in px.  Default 2.2. */
-    lineWidthStart?: number;
-    /** Stroke width at the *child-end* of the edge, in px.  Default 0.8. */
-    lineWidthEnd?: number;
-    /**
-     * When true, each top-level branch gets its own color (root stays
-     * neutral, every child[0] of root takes a different hue, and that
-     * hue propagates down the subtree).  Default false.
-     */
-    rainbowBranch?: boolean;
-}
-export type LineStyle = 'curve' | 'straight';
-export type LayoutMode = 'mindmap' | 'tree' | 'org';
-/** Identifier for a branch palette — the id of a built-in (e.g.
- *  'default', 'classic', 'vivid', 'dev', 'mint') or a user-defined
- *  custom palette.  Strings rather than a string union so users
- *  can add their own ids without recompiling the type. */
-export type BranchPaletteId = string;
-/**
- * A named 8-color palette cycled across top-level branches when
- * `rainbowBranch` is on.  Exposed in the public API so the library
- * consumer can register their own scheme (e.g. a corporate brand
- * palette) via `setBranchPalette` / `customPalettes`.
- */
-export interface BranchPalette {
-    id: BranchPaletteId;
-    name: string;
-    /** Hex colors cycled across top-level branches, in display order.
-     *  When a palette has fewer than the number of branches, colors
-     *  wrap around with modulo. */
-    colors: string[];
-}
-export interface MindMapSettings {
-    /** When the user adds a new node or finishes a drag, automatically
-     *  snap the layout back to balanced mode.  Default false. */
-    autoBalanceOnChange: boolean;
-    /** Stroke width of SVG edges at the parent end. */
-    lineWidthStart: number;
-    /** Stroke width of SVG edges at the child end. */
-    lineWidthEnd: number;
-    /** Color-cycle the top-level branches. */
-    rainbowBranch: boolean;
-    /** Which named palette to use when rainbowBranch is on.  Built-in
-     *  ids: 'default' | 'classic' | 'vivid' | 'dev' | 'mint'.  Any
-     *  custom palette id in `customPalettes` is also valid.  Default
-     *  'default'. */
-    branchPaletteId: BranchPaletteId;
-    /** User-defined palettes.  The settings panel lets the user add,
-     *  edit (via a textarea of hex codes), and delete entries.  The
-     *  canvas treats these as first-class palettes alongside the
-     *  built-ins.  Persisted by the host app. */
-    customPalettes: BranchPalette[];
-    /** Edge shape between parent and child. 'curve' = fish-gill bezier
-     *  (xmind default), 'straight' = direct line segment. */
-    lineStyle: LineStyle;
-    /** Layout mode (1.html parity).  'mindmap' = center + left/right
-     *  fans; 'tree' = single column expanding to the right; 'org' =
-     *  downward hierarchy.  Default 'mindmap'. */
-    layoutMode: LayoutMode;
-    /** When true (default), each edge tapers independently — its
-     *  parent-end width comes from the parent node's tier and its
-     *  child-end width comes from `lineWidthEnd`.  Visually you get
-     *  discrete ribbons where the parent side of a level-2 edge can
-     *  be thicker than the child side of a level-1 edge.
-     *  When false, the whole tree forms a single tapered band:
-     *  every edge's parent end = the previous edge's child end, so
-     *  widths interpolate continuously from root to leaves. */
-    taperedEdge: boolean;
-    /** When true, every node shows a small badge with its zero-based
-     *  position in its parent's children array ("1.", "2.", "3.").
-     *  Default false — useful when verifying the data-tree order
-     *  against the visual layout. */
-    showOrderBadge: boolean;
-}
-export interface NodeStyle {
-    bg?: string;
-    textColor?: string;
-    borderColor?: string;
-    fontWeight?: 400 | 600;
-}
-export interface MindMapExpose {
-    addChild: (parentId: string) => void;
-    addSibling: (nodeId: string) => void;
-    removeNode: (nodeId: string) => void;
-    duplicateNode: (nodeId: string) => void;
-    /** Set a node's text (no-op if unchanged).  Used by the outline
-     *  panel's inline edit; the canvas has its own dblclick → input
-     *  flow. */
-    setNodeText: (nodeId: string, text: string) => void;
-    /** Move a node to a new location.  `position` is relative to
-     *  `targetId`: 'before' / 'after' insert as siblings, 'child'
-     *  makes it the last child of target.  Used by the outline panel's
-     *  drag-and-drop.  Returns true on success, false (no-op) if the
-     *  move would create a cycle or hit another invalid case. */
-    moveNode: (srcId: string, targetId: string, position: 'before' | 'after' | 'child') => boolean;
-    getData: () => MindMapNode;
-    setData: (data: MindMapNode) => void;
-    resetView: () => void;
-    exportData: () => string;
-    importData: (json: string) => boolean;
-    /** Serialize the current data tree as markdown. */
-    getMarkdown: () => string;
-    /** Replace the data tree with the result of parsing `md`.  The
-     *  `emitMarkdownChange` flag (default true) controls whether the
-     *  change is also echoed via `markdownChange` — set false to
-     *  avoid feedback loops when the host just wrote back the
-     *  value the component emitted. */
-    setMarkdown: (md: string, emitMarkdownChange?: boolean) => void;
-    setBalanced: (value: boolean) => void;
-    isBalanced: () => boolean;
-    balance: () => void;
-    /** Apply or update the per-node style override (empty object clears it). */
-    applyNodeStyle: (nodeId: string, style: NodeStyle) => void;
-    /** Read the current per-node style override. */
-    getNodeStyle: (nodeId: string) => NodeStyle;
-    /** Set a node's external link.  Pass an empty string to clear. */
-    applyNodeLink: (nodeId: string, url: string) => void;
-    /** Remove a node's link (no-op if absent). */
-    removeNodeLink: (nodeId: string) => void;
-    /** Set a node's note text.  Pass an empty string to clear. */
-    applyNodeNote: (nodeId: string, text: string) => void;
-    /** Remove a node's note (no-op if absent). */
-    removeNodeNote: (nodeId: string) => void;
-    /** Set a node's image from a URL or data: URI.  Fetches the
-     *  asset to read its natural dimensions; clamps to IMG_MAX_W
-     *  with a preserved aspect ratio.  Empty string removes the
-     *  image. */
-    applyNodeImageByUrl: (nodeId: string, url: string) => void;
-    /** Set a node's image from a fully-resolved MindMapImage.
-     *  Used by the file-picker flow (readImageFile) and the drag
-     *  resize handle.  Prefer `applyNodeImageByUrl` from the
-     *  panel — it fetches the natural dimensions for you. */
-    applyNodeImage: (nodeId: string, image: MindMapImage) => void;
-    /** Remove a node's image (no-op if absent). */
-    removeNodeImage: (nodeId: string) => void;
-    /** Set a node's rich body (code block or table).  Pass `null`
-     *  to remove the body.  The renderer reads `kind` to decide
-     *  which preview layout to use. */
-    applyNodeRichContent: (nodeId: string, content: {
-        kind: 'code' | 'table';
-        raw: string;
-        lang?: string;
-    } | null) => void;
-    undo: () => void;
-    redo: () => void;
-    canUndo: () => boolean;
-    canRedo: () => boolean;
-    /** Apply a partial settings object — keys you omit are left as-is. */
-    applySettings: (s: Partial<MindMapSettings>) => void;
-    /** Read the current effective settings. */
-    getSettings: () => MindMapSettings;
-    /** Set the active branch palette by id.  The id may be a built-in
-     *  ('default' / 'classic' / 'vivid' / 'dev' / 'mint') or a custom
-     *  palette id from `customPalettes`.  No-op if the id is unknown. */
-    setBranchPalette: (id: BranchPaletteId) => void;
-    /** Read the active palette id. */
-    getBranchPalette: () => BranchPaletteId;
-    /** Read every palette the canvas knows about — built-ins first,
-     *  then the user's custom palettes.  Useful for the host app to
-     *  render a picker. */
-    getBranchPalettes: () => BranchPalette[];
-    /** Stroke width used for the parent end of an edge that starts at
-     *  a node of the given depth. Lets the canvas taper sharply
-     *  (root → 1st → 2nd → 3rd+) instead of using a single global
-     *  width. */
-    lineWidthForDepth: (depth: number) => number;
-    /** Stroke width used for the child end of an edge that ends at
-     *  a node of the given depth. */
-    endWidthForDepth: (depth: number) => number;
-}