flow-mindmap 0.1.0-beta.1

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

@@ -0,0 +1,20 @@
+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, {} & {
+    apply: (text: string) => any;
+    remove: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onApply?: ((text: string) => any) | undefined;
+    onRemove?: (() => 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;
+}>, {
+    readonly: boolean;
+    selectedId: string | null;
+    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/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/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/core/layout.d.ts

@@ -0,0 +1,98 @@
+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;
+    };
+    children: LayoutNode[];
+    parent: LayoutNode | null;
+}
+import type { MindMapNode, MindMapImage } from '../types';
+declare function heightAt(depth: number): number;
+declare function fontAt(depth: number): number;
+export type LayoutMode = 'mindmap' | 'tree' | 'org';
+export interface LayoutOptions {
+    mode?: LayoutMode;
+    /** @deprecated kept for API compat; ignored in 1.html-style layout. */
+    balanced?: boolean;
+    /**
+     * 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;
+}
+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

@@ -0,0 +1,43 @@
+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

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