flow-mindmap 0.4.0 → 0.4.1

package/dist/components/DataPanel.vue.d.ts

@@ -0,0 +1,10 @@
+import type { MindMapNode } from '../types';
+type __VLS_Props = {
+    data: MindMapNode;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    import: (data: MindMapNode) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onImport?: ((data: MindMapNode) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/Drawer.vue.d.ts

@@ -0,0 +1,33 @@
+type __VLS_Props = {
+    /** 'left' slides in from the left edge, 'right' from the right. */
+    side?: 'left' | 'right';
+    /** Pixels wide. */
+    width?: number;
+    /** Show or hide the panel. Animation handles the transition. */
+    open?: boolean;
+    /** Optional title shown in the header. */
+    title?: string;
+};
+declare var __VLS_5: {}, __VLS_7: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_5) => any;
+} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    title: string;
+    width: number;
+    side: "left" | "right";
+    open: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Icon.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    name: string;
+    size?: number | string;
+    stroke?: number | string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/MarkdownPanel.vue.d.ts

@@ -0,0 +1,12 @@
+import type { MindMapNode } from '../types';
+type __VLS_Props = {
+    /** Current data tree.  Used to populate the editor on first mount
+     *  (as markdown) and as the source of the "export .md" action. */
+    data: MindMapNode;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    import: (data: MindMapNode) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onImport?: ((data: MindMapNode) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/MindMap.vue.d.ts

@@ -0,0 +1,87 @@
+import type { MindMapNode, MindMapTheme, MindMapSettings, NodeStyle, MindMapImage } from '../types';
+type __VLS_Props = {
+    data: MindMapNode;
+    theme?: MindMapTheme;
+    /**
+     * When true, hides the MindMap's own toolbar and disables every
+     * edit operation (add/remove/edit/drag/paste/rich-edit/note
+     * edit/context menu).  Expand/collapse stays available so the
+     * user can still navigate a large tree.  The app-level top
+     * toolbar / drawers are controlled by the parent (App.vue).
+     */
+    previewMode?: boolean;
+    /**
+     * Optional raw markdown source.  When set, the component parses
+     * it into the data tree and ignores `data` (use one or the
+     * other).  Editing nodes on the canvas emits `markdownChange`
+     * with the re-serialized form, so the host can keep its
+     * markdown source in sync without polling.  Pass an empty
+     * string to clear.
+     */
+    markdown?: string;
+    /**
+     * Optional per-edge color list.  When set, top-level branches
+     * draw their edges (and their descendant edges under
+     * `rainbowBranch`) using these colors in order, wrapping
+     * around.  Overrides the palette picked by `branchPaletteId`
+     * / `customPalettes`.  Pass an empty array to fall back to
+     * the palette pipeline.
+     */
+    lineColors?: string[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    addChild: (parentId: string) => void;
+    addSibling: (nodeId: string) => void;
+    removeNode: (nodeId: string) => void;
+    duplicateNode: (nodeId: string) => void;
+    setNodeText: (nodeId: string, text: string) => void;
+    moveNode: (srcId: string, targetId: string, position: "before" | "after" | "child") => boolean;
+    getData: () => MindMapNode;
+    setData: (data: MindMapNode) => void;
+    resetView: () => void;
+    exportData: () => string;
+    importData: (json: string) => boolean;
+    getMarkdown: () => string;
+    setMarkdown: (md: string, emitMarkdownChange?: boolean) => void;
+    setBalanced: (value: boolean) => void;
+    isBalanced: () => boolean;
+    balance: () => void;
+    applyNodeStyle: (nodeId: string, style: NodeStyle) => void;
+    getNodeStyle: (nodeId: string) => NodeStyle;
+    applyNodeLink: (nodeId: string, url: string) => void;
+    removeNodeLink: (nodeId: string) => void;
+    applyNodeNote: (nodeId: string, text: string) => void;
+    removeNodeNote: (nodeId: string) => void;
+    applyNodeImageByUrl: (nodeId: string, url: string) => void;
+    applyNodeImage: (nodeId: string, image: MindMapImage) => void;
+    removeNodeImage: (nodeId: string) => void;
+    applyNodeRichContent: (nodeId: string, content: {
+        kind: "code" | "table";
+        raw: string;
+        lang?: string;
+    } | null) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    applySettings: (s: Partial<MindMapSettings>) => void;
+    getSettings: () => MindMapSettings;
+    setBranchPalette: (id: import("../types").BranchPaletteId) => void;
+    getBranchPalette: () => import("../types").BranchPaletteId;
+    getBranchPalettes: () => import("../types").BranchPalette[];
+    lineWidthForDepth: (depth: number) => number;
+    endWidthForDepth: (depth: number) => number;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    select: (node: MindMapNode | null) => any;
+    change: (data: MindMapNode) => any;
+    "edit-note": (nodeId: string) => any;
+    markdownChange: (markdown: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((node: MindMapNode | null) => any) | undefined;
+    onChange?: ((data: MindMapNode) => any) | undefined;
+    "onEdit-note"?: ((nodeId: string) => any) | undefined;
+    onMarkdownChange?: ((markdown: string) => any) | undefined;
+}>, {
+    previewMode: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/NodeContextMenu.vue.d.ts

@@ -0,0 +1,63 @@
+type __VLS_Props = {
+    /** Cursor X in viewport coords (clientX). */
+    x: number;
+    /** Cursor Y in viewport coords (clientY). */
+    y: number;
+    /** Container the menu should not escape — used to clamp the
+     *  position so the menu stays on-screen. */
+    container: HTMLElement | null;
+    /** Whether the node already has an image.  When true, the
+     *  "添加图片" action is renamed "替换图片" and a "移除图片"
+     *  action is appended. */
+    hasImage?: boolean;
+    /** Whether the node already has a link.  Drives the label /
+     *  presence of the "添加链接" / "编辑链接" / "移除链接"
+     *  actions. */
+    hasLink?: boolean;
+    /** Whether the node already has a note.  Same role as
+     *  hasLink for the note action. */
+    hasNote?: boolean;
+    /** Whether the node already has a code block in its
+     *  richContent.  Drives the code-block action's label and
+     *  whether a "移除代码块" sub-action shows. */
+    hasCode?: boolean;
+    /** Whether the node already has a table in its richContent.
+     *  Same role as hasCode for the table action. */
+    hasTable?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    pickImage: () => any;
+    setLink: () => any;
+    removeLink: () => any;
+    editNote: () => any;
+    removeNote: () => any;
+    removeImage: () => any;
+    addCode: () => any;
+    editCode: () => any;
+    removeCode: () => any;
+    addTable: () => any;
+    editTable: () => any;
+    removeTable: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onPickImage?: (() => any) | undefined;
+    onSetLink?: (() => any) | undefined;
+    onRemoveLink?: (() => any) | undefined;
+    onEditNote?: (() => any) | undefined;
+    onRemoveNote?: (() => any) | undefined;
+    onRemoveImage?: (() => any) | undefined;
+    onAddCode?: (() => any) | undefined;
+    onEditCode?: (() => any) | undefined;
+    onRemoveCode?: (() => any) | undefined;
+    onAddTable?: (() => any) | undefined;
+    onEditTable?: (() => any) | undefined;
+    onRemoveTable?: (() => any) | undefined;
+}>, {
+    hasImage: boolean;
+    hasLink: boolean;
+    hasNote: boolean;
+    hasCode: boolean;
+    hasTable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/NotePanel.vue.d.ts

@@ -0,0 +1,34 @@
+import type { MindMapNode } from '../types';
+type __VLS_Props = {
+    /** The currently selected node.  `null` means nothing is
+     *  selected; the panel renders an empty-state in that case. */
+    selectedNode: MindMapNode | null;
+    /** Disable all edit controls (read-only mode). */
+    readonly?: boolean;
+    /** Bumped by the parent (App.vue) on each select change.  The
+     *  panel uses this as a "focus the textarea" signal so the
+     *  user can start typing immediately after picking a node. */
+    focusTick?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "set-link": (url: string) => any;
+    apply: (text: string) => any;
+    remove: () => any;
+    "set-image": (src: string) => any;
+    "set-rich": (payload: {
+        kind: "code" | "table";
+        raw: string;
+        lang?: string;
+    } | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onSet-link"?: ((url: string) => any) | undefined;
+    onApply?: ((text: string) => any) | undefined;
+    onRemove?: (() => any) | undefined;
+    "onSet-image"?: ((src: string) => any) | undefined;
+    "onSet-rich"?: ((payload: {
+        kind: "code" | "table";
+        raw: string;
+        lang?: string;
+    } | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/Outline.vue.d.ts

@@ -0,0 +1,45 @@
+import type { MindMapNode } from '../types';
+type __VLS_Props = {
+    /** Root of the mind map. */
+    data: MindMapNode;
+    /** Highlight the node with this id (the one selected on the main canvas). */
+    selectedId?: string | null;
+    /** When true, hide a node's children in the outline. */
+    collapsedIds?: Set<string>;
+    /** Read-only — disables editing / add / drag.  Default false. */
+    readonly?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    select: (node: MindMapNode) => any;
+    edit: (payload: {
+        id: string;
+        text: string;
+    }) => any;
+    toggleCollapse: (id: string) => any;
+    addChild: (id: string) => any;
+    addSibling: (id: string) => any;
+    move: (payload: {
+        srcId: string;
+        targetId: string;
+        position: "before" | "after" | "child";
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((node: MindMapNode) => any) | undefined;
+    onEdit?: ((payload: {
+        id: string;
+        text: string;
+    }) => any) | undefined;
+    onToggleCollapse?: ((id: string) => any) | undefined;
+    onAddChild?: ((id: string) => any) | undefined;
+    onAddSibling?: ((id: string) => any) | undefined;
+    onMove?: ((payload: {
+        srcId: string;
+        targetId: string;
+        position: "before" | "after" | "child";
+    }) => any) | undefined;
+}>, {
+    selectedId: string | null;
+    readonly: boolean;
+    collapsedIds: Set<string>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/SettingsPanel.vue.d.ts

@@ -0,0 +1,30 @@
+import type { MindMapSettings } from '../types';
+type __VLS_Props = {
+    settings: MindMapSettings;
+    /** true when a node is selected — the per-node panel is shown too. */
+    hasSelection: boolean;
+    selectedNodeText?: string;
+};
+/** Style overrides for a single node.  Stored externally (App.vue
+ *  holds the map) so the per-node state is preserved across
+ *  selection changes. */
+export interface NodeStyle {
+    /** Background colour.  undefined = fall back to theme/branch. */
+    bg?: string;
+    /** Text colour. */
+    textColor?: string;
+    /** Border colour. */
+    borderColor?: string;
+    /** Font weight: 400 / 600.  undefined = inherit. */
+    fontWeight?: 400 | 600;
+}
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    reset: () => any;
+    "update:settings": (s: Partial<MindMapSettings>) => any;
+    "update:nodeStyle": (s: Partial<NodeStyle>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReset?: (() => any) | undefined;
+    "onUpdate:settings"?: ((s: Partial<MindMapSettings>) => any) | undefined;
+    "onUpdate:nodeStyle"?: ((s: Partial<NodeStyle>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/composables/useAutosize.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tiny autosize helper for textareas.  Usage:
+ *
+ *   const taRef = ref<HTMLTextAreaElement | null>(null)
+ *   useAutosize(taRef, { minRows: 4, maxRows: 12 })
+ *
+ * The composable listens to the textarea's `input` event, sets
+ * its height to its scrollHeight (clamped to the row range), and
+ * also re-runs when the bound value changes from outside so a
+ * parent that resets `.value` (e.g. on node switch) still sizes
+ * correctly.
+ */
+import { type Ref } from 'vue';
+export interface AutosizeOptions {
+    /** Minimum visible rows when the textarea is empty.  Default 3. */
+    minRows?: number;
+    /** Maximum visible rows before the textarea starts scrolling.
+     *  Default 12.  Set to 0 for "no cap". */
+    maxRows?: number;
+}
+export declare function useAutosize(refEl: Ref<HTMLTextAreaElement | null>, options?: AutosizeOptions): void;

package/dist/composables/useHistory.d.ts

@@ -0,0 +1,19 @@
+import type { MindMapNode } from '../types';
+/**
+ * Linear undo/redo history for the mind map.
+ *
+ * Each entry stores the data tree (full JSON snapshot).
+ * Snapshots are deep-cloned JSON strings (one string per state).  The
+ * timeline is bounded so a long session doesn't grow without limit.
+ */
+export interface HistoryState {
+    data: MindMapNode;
+}
+export declare function useHistory(maxSize?: number): {
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    record: (snapshot: HistoryState) => void;
+    undo: () => HistoryState | null;
+    redo: () => HistoryState | null;
+    reset: () => void;
+};

package/dist/composables/useKeyboard.d.ts

@@ -0,0 +1,32 @@
+export interface KeyboardOptions {
+    isEditing: () => boolean;
+    isReadonly: () => boolean;
+    getSelectedId: () => string | null;
+    getRootId: () => string;
+    /**
+     * Called when Tab/Enter fires and no node is selected — defaults the
+     * action to the root node so the user can build a tree from scratch
+     * without first clicking something.
+     */
+    defaultTargetId?: () => string;
+    onAddChild: (id: string) => void;
+    onAddSibling: (id: string) => void;
+    onAddSiblingBefore: (id: string) => void;
+    onRemove: (id: string) => void;
+    onStartEdit: (id: string) => void;
+    onClearSelection: () => void;
+    onDuplicate: (id: string) => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    /**
+     * Move selection to a neighbour.  Returns the new selected id (or null
+     * if no neighbour exists in that direction).
+     *   dx = -1  → select first child
+     *   dx = +1  → select parent
+     *   dy = -1  → select previous sibling
+     *   dy = +1  → select next sibling
+     */
+    onNavigate: (dx: number, dy: number) => void;
+    onSelectRoot: () => void;
+}
+export declare function useKeyboard(opts: KeyboardOptions): void;

package/dist/composables/useMarkdown.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Render a markdown string to sanitized HTML.  Returns `''` for
+ * empty input so the caller can use the result in a `v-html` v-if
+ * without a separate guard.
+ */
+export declare function renderMarkdown(src: string): string;

package/dist/composables/usePanZoom.d.ts

@@ -0,0 +1,35 @@
+import { type Ref } from 'vue';
+export interface PanZoomOptions {
+    minScale?: number;
+    maxScale?: number;
+    step?: number;
+    getContainer: () => HTMLElement | null;
+}
+export interface MarqueeRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function usePanZoom(opts: PanZoomOptions): {
+    scale: Ref<number, number>;
+    offsetX: Ref<number, number>;
+    offsetY: Ref<number, number>;
+    isPanning: Ref<boolean, boolean>;
+    onWheel: (e: WheelEvent) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    startPan: (e: PointerEvent | MouseEvent) => void;
+    startMarquee: (worldX: number, worldY: number) => void;
+    updateMarquee: (worldX: number, worldY: number) => void;
+    isMarquee: Ref<boolean, boolean>;
+    marquee: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    marqueeVersion: Ref<number, number>;
+    setOnMarqueeEnd: (cb: (() => void) | null) => void;
+    resetView: (layoutWidth: number, layoutHeight: number, rootY: number, padding?: number) => void;
+};

package/dist/composables/useRichContent.d.ts

@@ -0,0 +1,29 @@
+/** Strip the opening and closing ``` fences from a code block,
+ *  returning just the body.  Handles both ``` and ~~~ markers. */
+export declare function stripCodeFence(raw: string): string;
+/** Detect the info-string from the opening fence.  Returns an
+ *  empty string when the block has no fence or the language
+ *  isn't one of our registered ones (so callers can fall back
+ *  to a plain `<pre>`). */
+export declare function codeLang(raw: string): string;
+/** Run highlight.js on a code body and return sanitized HTML.
+ *  Falls back to an escaped plain-text version when the language
+ *  isn't registered — never throws.  `body` should already be
+ *  fence-stripped (see `stripCodeFence`). */
+export declare function highlightCode(body: string, lang: string): string;
+/** Split a pipe-delimited table into rows of cells, dropping the
+ *  alignment separator row.  Each inner array is the cells of one
+ *  row.  The first row is conventionally the header. */
+export declare function tableRows(raw: string): string[][];
+/** Re-join a 2-D cell array into pipe-delimited markdown.  Used
+ *  when the user edits a table in CSV/textarea form and we need
+ *  to push it back into `richContent.raw`. */
+export declare function rowsToTable(rows: string[][]): string;
+/** Sort a 2-D cell array in place around a chosen column.  The
+ *  first row is the header and stays pinned at the top.
+ *  Direction is `'asc'` | `'desc'`.  When every value in the
+ *  column parses as a finite number the sort is numeric,
+ *  otherwise lexical (locale-aware).  Stable across equal keys.
+ *  Doesn't mutate the input. */
+export type SortDir = 'asc' | 'desc';
+export declare function sortTable(rows: string[][], col: number, dir: SortDir): string[][];

package/dist/core/layout.d.ts

@@ -0,0 +1,144 @@
+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 {};