flow-mindmap 0.2.0 → 0.2.2

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

@@ -1,4 +1,4 @@
-import type { MindMapNode, MindMapTheme, MindMapSettings, NodeStyle } from '../types';
+import type { MindMapNode, MindMapTheme, MindMapSettings, NodeStyle, MindMapImage } from '../types';
 type __VLS_Props = {
     data: MindMapNode;
     readonly?: boolean;
@@ -54,6 +54,14 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {
     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;

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

@@ -17,6 +17,13 @@ type __VLS_Props = {
     /** 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;
     /** True if the component is in readonly mode — all actions
      *  render but are disabled. */
     readonly?: boolean;
@@ -29,6 +36,12 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     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;
@@ -37,10 +50,18 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     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;
     readonly: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -11,10 +11,24 @@ type __VLS_Props = {
     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/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/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/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

@@ -50,6 +50,15 @@ export interface LayoutNode {
      *  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;
 }
@@ -91,6 +100,20 @@ export interface LayoutOptions {
      * 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;