@henryx/pagely 0.1.0

package/dist/composables/useEditorEvents.d.ts

@@ -0,0 +1,22 @@
+export interface UseEditorEventsOptions {
+    onBlockMouseMove: (event: MouseEvent) => void;
+    onBlockMouseLeave: () => void;
+    updateInsertButton: () => void;
+    clearInsertButton: () => void;
+    onTableMouseMove: (event: MouseEvent) => void;
+    scheduleTableHide: () => void;
+    closeBlockMenu: () => void;
+    closeInsertMenu: () => void;
+    isBlockMenuVisible: () => boolean;
+    isInsertMenuVisible: () => boolean;
+}
+export declare function useEditorEvents(options: UseEditorEventsOptions): {
+    onMove: (e: MouseEvent) => void;
+    onLeave: (e: MouseEvent) => void;
+    onEditorMouseDown: () => void;
+    onDocMouseUp: () => void;
+    onOverlayEnter: () => void;
+    onOverlayLeave: () => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+    setHasSelection: (value: boolean) => void;
+};

package/dist/composables/useEmbedView.d.ts

@@ -0,0 +1,28 @@
+import { ComputedRef, Ref } from 'vue';
+import { EmbedViewAttrs, EmbedViewMode, EmbedFileType } from '../extensions/EmbedView';
+import { UrlMetadata } from '../utils/embedView/metadata';
+export interface UseEmbedViewOptions {
+    getAttrs: () => EmbedViewAttrs;
+    updateAttrs: (attrs: Partial<EmbedViewAttrs>) => void;
+    replaceWithText?: () => void;
+}
+export interface UseEmbedViewResult {
+    fileType: ComputedRef<EmbedFileType>;
+    currentView: ComputedRef<EmbedViewMode>;
+    metadata: Ref<UrlMetadata | null>;
+    metadataLoading: Ref<boolean>;
+    loadMetadataIfNeeded: () => void;
+    mdHtml: Ref<string | null>;
+    mdLoading: Ref<boolean>;
+    mdError: Ref<string | null>;
+    loadMdIfNeeded: () => void;
+    setView: (view: EmbedViewMode) => void;
+    copyLink: () => Promise<void>;
+    download: () => void;
+    openInNewTab: () => void;
+    removeLink: () => void;
+    toggleFullscreen: (open: boolean) => void;
+    fullscreen: Ref<boolean>;
+    copyTip: Ref<boolean>;
+}
+export declare function useEmbedView(options: UseEmbedViewOptions): UseEmbedViewResult;

package/dist/composables/useFileUpload.d.ts

@@ -0,0 +1,28 @@
+import { DEFAULT_ATTACHMENT_ACCEPT, defaultAttachmentUpload, FileUploadHandler, FileUploadResult } from '../utils/attachmentUpload';
+export declare const IMAGE_FILE_ACCEPT = "image/*,.png,.jpg,.jpeg,.gif,.webp,.bmp,.svg,.avif";
+export { DEFAULT_ATTACHMENT_ACCEPT, defaultAttachmentUpload, type FileUploadHandler, type FileUploadResult, };
+export interface ImageFilePayload {
+    src: string;
+    alt: string;
+}
+export interface UseImageFileUploadOptions {
+    onBeforeSelect?: () => void;
+    onInsert: (payload: ImageFilePayload) => void;
+}
+export interface UseDocFileUploadOptions {
+    onBeforeSelect?: () => void;
+    onInsert: (payload: FileUploadResult) => void;
+    uploadHandler?: FileUploadHandler;
+}
+export declare function isImageFile(file: File): boolean;
+export declare function readFileAsDataUrl(file: File): Promise<string | null>;
+export declare function useImageFileUpload(options: UseImageFileUploadOptions): {
+    imageAccept: string;
+    onImageFileClick: (event: MouseEvent) => void;
+    onImageFileChange: (event: Event) => Promise<void>;
+};
+export declare function useDocFileUpload(options: UseDocFileUploadOptions): {
+    fileAccept: string;
+    onDocFileClick: (event: MouseEvent) => void;
+    onDocFileChange: (event: Event) => Promise<void>;
+};

package/dist/composables/useHeadingCollapse.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+import { Extension } from '@tiptap/core';
+import { DecorationSet } from 'prosemirror-view';
+import { PluginKey } from 'prosemirror-state';
+interface CollapseState {
+    collapsed: Set<number>;
+    decorations: DecorationSet;
+}
+export declare const COLLAPSE_KEY: PluginKey<CollapseState>;
+export declare function useHeadingCollapse(): {
+    extension: Extension<any, any>;
+    bind: (editor: Ref<Editor | undefined>, getCurrentBlockTag: () => string, getCurrentBlockPMPos: () => number | null) => {
+        isHeadingBlock: import('vue').ComputedRef<boolean>;
+        isCurrentCollapsed: import('vue').ComputedRef<boolean>;
+        onCollapseClick: () => void;
+    };
+};
+export {};

package/dist/composables/useHoverMenu.d.ts

@@ -0,0 +1,7 @@
+export declare function useHoverMenu(delay?: number): {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    open: () => void;
+    close: () => void;
+    scheduleClose: () => void;
+    clearCloseTimer: () => void;
+};

package/dist/composables/useInsertButton.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+export declare function useInsertButton(_editorRef: Ref<HTMLElement | null>, _editor: Ref<Editor | undefined>, getCurrentBlockEl: () => Element | null): {
+    isEmptyParagraph: Ref<boolean, boolean>;
+    updateFromCurrentBlock: () => void;
+    clear: () => void;
+};

package/dist/composables/useInsertMenu.d.ts

@@ -0,0 +1,17 @@
+import { MenuPlacement } from './useMenuPosition';
+export declare function useInsertMenu(getCurrentBlockPMPos: () => number | null, getAnchorRect: () => DOMRect | null, beforeOpen: () => void): {
+    visible: import('vue').Ref<boolean, boolean>;
+    top: import('vue').Ref<number, number>;
+    left: import('vue').Ref<number, number>;
+    placement: import('vue').Ref<MenuPlacement, MenuPlacement>;
+    targetPos: import('vue').Ref<number | null, number | null>;
+    openFromButton: () => void;
+    openFromSlash: (blockPos: number, rect: DOMRect) => void;
+    onButtonEnter: () => void;
+    onButtonLeave: (e: MouseEvent) => void;
+    onMenuEnter: () => void;
+    onMenuLeave: () => void;
+    close: () => void;
+    scheduleClose: () => void;
+    clearHideTimer: () => void;
+};

package/dist/composables/useLinkHover.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+export declare function useLinkHover(editorRef: Ref<Editor | undefined>, onShow: (href: string, text: string, rect: DOMRect) => void, onHide: () => void): void;

package/dist/composables/useLinkOps.d.ts

@@ -0,0 +1,32 @@
+import { Editor } from '@tiptap/vue-3';
+import { EditorState } from 'prosemirror-state';
+interface LinkRange {
+    from: number;
+    to: number;
+}
+export interface ExclusiveLinkBlock extends LinkRange {
+    text: string;
+}
+/**
+ * 在文档中找到 href 匹配的第一个"连续" text node 组的范围。
+ * 连续：相邻节点紧挨着（positions[i].from === positions[i-1].to）。
+ * 返回 null 表示未找到。
+ */
+export declare function findLinkRange(state: EditorState, href: string): LinkRange | null;
+export declare function findExclusiveLinkBlock(state: EditorState, href: string): ExclusiveLinkBlock | null;
+/**
+ * 将 href 对应链接的第一个连续组文字替换为 newText，保留 link mark。
+ * 返回是否成功找到并替换。
+ */
+export declare function replaceLinkText(editor: Editor, href: string, newText: string): boolean;
+/**
+ * 取消链接：移除 link mark，保留 displayText 作为纯文本。
+ * displayText 应传入当前显示的链接文字（而非 href），以保留用户看到的内容。
+ */
+export declare function unlinkText(editor: Editor, href: string, displayText: string): boolean;
+/**
+ * 更新链接 href：在文档中找到该链接范围，用新 href 替换 link mark 属性。
+ * 比 chain().setLink() 更精确——不依赖当前编辑器选区。
+ */
+export declare function updateLinkHref(editor: Editor, oldHref: string, newHref: string): boolean;
+export {};

package/dist/composables/useMarkdownSync.d.ts

@@ -0,0 +1,12 @@
+import { Editor } from '@tiptap/vue-3';
+export type MarkdownEmit = {
+    (event: 'update:markdown', md: string): void;
+};
+export declare function useMarkdownSync(getEditor: () => Editor | undefined, emit: MarkdownEmit, delay?: number): {
+    isSettingContent: import('vue').Ref<boolean, boolean>;
+    scheduleMarkdownEmit: (html: string) => void;
+    getHtml: () => string;
+    getMarkdown: () => string;
+    setMarkdown: (md: string) => void;
+    setHtml: (html: string) => void;
+};

package/dist/composables/useMath.d.ts

@@ -0,0 +1,38 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+export type MathNodeKind = 'inline' | 'block';
+export interface MathNode {
+    attrs: {
+        latex: string;
+    };
+}
+export declare function useMath(editor: Ref<Editor | undefined>): {
+    visible: Ref<boolean, boolean>;
+    anchorRect: Ref<{
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null, DOMRect | {
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null>;
+    initialLatex: Ref<string, string>;
+    openForEdit: (node: MathNode, pos: number, nodeKind?: MathNodeKind) => void;
+    openForInsert: (insertPos: number, rect?: DOMRect | null, nodeKind?: MathNodeKind) => void;
+    confirm: (latex: string) => void;
+    close: () => void;
+    rectAtPos: (pos: number) => DOMRect | null;
+};

package/dist/composables/useMention.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+import { MentionAttrs } from '../extensions/Mention';
+export interface MentionAnchor extends MentionAttrs {
+    from: number;
+    to: number;
+}
+export interface MentionTriggerPayload {
+    query: string;
+    rect: DOMRect;
+}
+export interface UseMentionOptions {
+    onTrigger?: (payload: MentionTriggerPayload) => void;
+    onCancel?: () => void;
+}
+export declare function useMention(editorRef: Ref<Editor | undefined>, options?: UseMentionOptions): {
+    insertMention: (attrs: MentionAttrs) => boolean;
+    getMentions: () => MentionAnchor[];
+    applyMentions: (mentions: MentionAnchor[]) => boolean;
+};

package/dist/composables/useMenuPosition.d.ts

@@ -0,0 +1,13 @@
+export type MenuPlacement = 'left' | 'right' | 'below' | 'above';
+export interface MenuAnchor {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface MenuPosition {
+    top: number;
+    left: number;
+    placement: MenuPlacement;
+}
+export declare function calcMenuPosition(anchor: MenuAnchor, menuWidth: number, preferredPlacement: MenuPlacement, gap?: number, menuHeight?: number): MenuPosition;

package/dist/composables/useMenuSidePanel.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties, Ref, WatchSource } from 'vue';
+import { MenuPlacement } from './useMenuPosition';
+export declare const MENU_PANEL_WIDTH = 224;
+export declare const MENU_PANEL_GAP = 4;
+export declare const MENU_PANEL_EDGE = 8;
+export declare const MENU_ITEM_HEIGHT = 32;
+export declare const MENU_CLOSE_DELAY = 120;
+export declare function getMenuEnterTranslate(placement: MenuPlacement): string;
+export interface MenuSidePanelOptions {
+    visible: WatchSource<boolean>;
+    rootSelector: string;
+    estimatedHeight: () => number;
+    fallbackTop: () => number;
+    fallbackLeft: () => number;
+    closeDelay?: number;
+}
+export declare function useMenuSidePanel<Id extends string>(options: MenuSidePanelOptions): {
+    rootId: Ref<Id | null, Id | null>;
+    hovered: Ref<boolean, boolean>;
+    style: import('vue').ComputedRef<CSSProperties>;
+    open: (id: Id, event: MouseEvent) => void;
+    close: () => void;
+    scheduleClose: () => void;
+    clearCloseTimer: () => void;
+    onPanelMouseEnter: () => void;
+    onPanelMouseLeave: () => void;
+};

package/dist/composables/useNodeViewCommentAttrs.d.ts

@@ -0,0 +1,12 @@
+export declare function useNodeViewCommentAttrs(getAttrs: () => Record<string, unknown>): {
+    commentAttrs: import('vue').ComputedRef<{
+        'data-comment-ids'?: undefined;
+        'data-comment-count'?: undefined;
+    } | {
+        'data-comment-ids': string;
+        'data-comment-count': string | undefined;
+    }>;
+    commentClass: import('vue').ComputedRef<{
+        'pagely-comment-block': boolean;
+    }>;
+};

package/dist/composables/usePagelyEditor.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { Content, Extension } from '@tiptap/core';
+import { ExtensionProfile } from '../config/extensionProfiles';
+import { FileUploadHandler } from '../utils/attachmentUpload';
+export interface UsePagelyEditorOptions {
+    profile: ExtensionProfile;
+    initialContent: Content;
+    headingCollapseExtension?: Extension;
+    isSettingContent: Ref<boolean>;
+    editable?: boolean;
+    onHtmlUpdate?: (html: string) => void;
+    onSelectionUpdate?: () => void;
+    onOpenMathPopover?: (node: unknown, pos: number, kind: 'inline' | 'block') => void;
+    onOpenSlashInsert?: (blockPos: number, rect: DOMRect) => void;
+    fileUploadHandler?: FileUploadHandler;
+}
+export declare function usePagelyEditor(options: UsePagelyEditorOptions): import('vue').ShallowRef<import('@tiptap/vue-3').Editor | undefined, import('@tiptap/vue-3').Editor | undefined>;

package/dist/composables/useSelectionToolbar.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+export declare function useSelectionToolbar(editorRef: Ref<Editor | undefined>, onShow: (rect: DOMRect) => void, onHide: () => void): void;

package/dist/composables/useTableCellOps.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+import { CellOpKind } from '../config/insertMenu';
+export interface CellBounds {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export declare function useTableCellOps(editor: Ref<Editor | undefined>, currentTable: Ref<HTMLElement | null>, currentCell: Ref<HTMLElement | null>, hoveredCellBounds: Ref<CellBounds | null>, refreshDots: (table: HTMLElement) => void, hide: () => void): {
+    cellOps: Record<CellOpKind, () => void>;
+    focusCell: (cell: HTMLElement) => void;
+    focusFirstCell: () => void;
+    focusLastRowCell: () => void;
+    focusLastColCell: () => void;
+    focusHoveredCell: () => void;
+    insertRowAt: (index: number) => void;
+    insertColAt: (index: number) => void;
+    refreshCurrentCellFromSelection: () => void;
+    getCurrentCellRootPMPos: () => number | null;
+};

package/dist/composables/useTableDots.d.ts

@@ -0,0 +1,60 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+import { Node as ProseMirrorNode } from 'prosemirror-model';
+import { TableAlign } from '../utils/tableAlign';
+export interface InsertDot {
+    pos: number;
+    index: number;
+}
+export interface ColAlignDot {
+    pos: number;
+    y: number;
+    colIndex: number;
+    align: TableAlign;
+}
+export declare function getDirectRows(table: HTMLElement): HTMLElement[];
+export declare function getDirectCells(row: Element | null | undefined): HTMLElement[];
+export declare function getFirstDirectCell(row: Element | null | undefined): HTMLElement | null;
+export declare function useTableDots(editor: Ref<Editor | undefined>): {
+    tableBounds: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    rowDots: Ref<{
+        pos: number;
+        index: number;
+    }[], InsertDot[] | {
+        pos: number;
+        index: number;
+    }[]>;
+    colDots: Ref<{
+        pos: number;
+        index: number;
+    }[], InsertDot[] | {
+        pos: number;
+        index: number;
+    }[]>;
+    colAlignDots: Ref<{
+        pos: number;
+        y: number;
+        colIndex: number;
+        align: TableAlign;
+    }[], ColAlignDot[] | {
+        pos: number;
+        y: number;
+        colIndex: number;
+        align: TableAlign;
+    }[]>;
+    hasHeaderRow: Ref<boolean, boolean>;
+    hasHeaderCol: Ref<boolean, boolean>;
+    findPmTableState: (table: HTMLElement) => {
+        node: ProseMirrorNode;
+        pos: number;
+    } | null;
+    refreshDots: (table: HTMLElement) => void;
+    refreshHeaderState: (table: HTMLElement) => void;
+    refreshColumnAlignDots: (table: HTMLElement) => void;
+    clearDots: () => void;
+};

package/dist/composables/useTableTools.d.ts

@@ -0,0 +1,72 @@
+import { Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+import { TableAlign } from '../utils/tableAlign';
+import { CellBounds } from './useTableCellOps';
+import { ColAlignDot, InsertDot } from './useTableDots';
+export type { CellBounds, ColAlignDot, InsertDot };
+export declare function useTableTools(_editorRef: Ref<HTMLElement | null>, editor: Ref<Editor | undefined>): {
+    tableVisible: Ref<boolean, boolean>;
+    tableBounds: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    rowDots: Ref<{
+        pos: number;
+        index: number;
+    }[], InsertDot[] | {
+        pos: number;
+        index: number;
+    }[]>;
+    colDots: Ref<{
+        pos: number;
+        index: number;
+    }[], InsertDot[] | {
+        pos: number;
+        index: number;
+    }[]>;
+    colAlignDots: Ref<{
+        pos: number;
+        y: number;
+        colIndex: number;
+        align: TableAlign;
+    }[], ColAlignDot[] | {
+        pos: number;
+        y: number;
+        colIndex: number;
+        align: TableAlign;
+    }[]>;
+    hoveredCellBounds: Ref<{
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | null, CellBounds | {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | null>;
+    hasHeaderRow: Ref<boolean, boolean>;
+    hasHeaderCol: Ref<boolean, boolean>;
+    onTableMouseMove: (e: MouseEvent) => void;
+    onTableSelectionUpdate: () => void;
+    keepAlive: () => void;
+    scheduleHide: () => void;
+    insertRowAt: (index: number) => void;
+    insertColAt: (index: number) => void;
+    cellOps: Record<import('..').CellOpKind, () => void>;
+    tableAddRowAfter: () => void;
+    tableAddColumnAfter: () => void;
+    tableToggleHeaderRow: () => void;
+    tableToggleHeaderColumn: () => void;
+    setColumnAlign: (align: TableAlign, colIndex?: number) => void;
+    tableDeleteTable: () => void;
+    tableCopyTable: () => void;
+    tableCutTable: () => void;
+    getCurrentTableRootPMPos: () => number | null;
+    tableFocusFirstCell: () => void;
+    focusHoveredCell: () => void;
+    getCurrentCellRootPMPos: () => number | null;
+};

package/dist/config/blockMenu/index.d.ts

@@ -0,0 +1,39 @@
+import { MenuChain } from '../../types/menuCommands';
+import { MenuItemDef } from './items';
+export type { ItemId, MenuItemDef, BlockOpId } from './items';
+export type { SectionId, SectionDef } from './sections';
+export type { ProfileId, ProfileDef } from './profiles';
+export type { BlockDisplay } from './tagMapping';
+export { MENU_ITEMS } from './items';
+export { MENU_SECTIONS } from './sections';
+export { MENU_PROFILES } from './profiles';
+export { BLOCK_DISPLAY, BLOCK_TAG_TO_PROFILE } from './tagMapping';
+export interface MenuSectionDef {
+    label?: string;
+    style?: 'tiles' | 'list';
+    items: MenuItemDef[];
+}
+export interface BlockConfig {
+    label: string;
+    icon: import('vue').Component;
+    pillVariant: 'text' | 'table' | 'minimal';
+    sections: MenuSectionDef[];
+    /** Which element's rect to use for overlay positioning (default: blockEl) */
+    getRectEl?: (blockEl: Element) => Element;
+    /** Which element to pass to posAtDOM (default: blockEl) */
+    getPMDomTarget?: (blockEl: Element) => Element;
+    /** How to apply a type-conversion command (default: no-op) */
+    applyConvert?: (chain: MenuChain, id: string) => void;
+    /** tile 高亮 ID（静态，默认用 tag 本身） */
+    currentTypeId?: string;
+    /** tile 高亮 ID（动态，优先级低于 currentTypeId，用于依赖 DOM 的情况） */
+    getCurrentTypeId?: (blockEl: Element) => string;
+    /**
+     * 包裹型节点：内部仍有独立的文本类型（P / H1-H6 等）。
+     * 为 true 时，tile 菜单同时高亮本节点类型 + 内部文本类型。
+     * 未标记的块类型之间互斥（同一时刻只高亮一个 tile）。
+     */
+    isWrapper?: true;
+}
+export declare function getBlockConfig(tag: string): BlockConfig;
+export declare const BLOCK_CONFIGS: Record<string, BlockConfig>;

package/dist/config/blockMenu/items.d.ts

@@ -0,0 +1,26 @@
+import { Component } from 'vue';
+export type ItemId = 'P' | 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6' | 'UL' | 'OL' | 'LI_TASK' | 'PRE' | 'BLOCKQUOTE' | 'COPY_BLOCK' | 'DELETE_BLOCK' | 'CUT_BLOCK' | 'COPY_CODE' | 'DELETE_CODE_BLOCK' | 'COPY_CANVAS_CODE' | 'COPY_CANVAS_IMAGE' | 'CUT_TABLE' | 'COPY_TABLE' | 'TOGGLE_TABLE_HEADER_ROW' | 'TOGGLE_TABLE_HEADER_COL' | 'DELETE_TABLE' | 'CANVAS' | 'MERMAID' | 'INDENT_INC' | 'INDENT_DEC' | 'SUBMENU_INDENT_LIST' | 'COLOR';
+/** Block-level operations dispatched via useBlockOps.applyBlockOp. */
+export type BlockOpId = 'copyBlock' | 'copyCode' | 'copyCanvasCode' | 'copyCanvasImage' | 'copyTable' | 'cutTable' | 'cutBlock' | 'deleteBlock' | 'deleteCodeBlock' | 'deleteTable' | 'toggleTableHeaderRow' | 'toggleTableHeaderColumn';
+export interface MenuItemDef {
+    id: string;
+    label: string;
+    icon: Component;
+    shortcut?: string;
+    danger?: boolean;
+    /** 悬停预览描述文字（hover 时右侧弹出面板中显示） */
+    description?: string;
+    /** 行为类别：缺省为类型转换 */
+    action?: 'indent' | 'op';
+    /** 缩进方向（action === 'indent'） */
+    indentDir?: 'inc' | 'dec';
+    /** 块级操作（action === 'op'） */
+    op?: BlockOpId;
+    /** Render a switch indicator for active/inactive operation rows. */
+    toggle?: boolean;
+    /** 二级菜单项 ID（与 panel 互斥） */
+    children?: ItemId[];
+    /** 二级面板类型：渲染自定义面板而非扁平的 children 列表（与 children 互斥） */
+    panel?: 'color';
+}
+export declare const MENU_ITEMS: Record<ItemId, MenuItemDef>;

package/dist/config/blockMenu/profiles.d.ts

@@ -0,0 +1,13 @@
+import { BlockConvertId } from '../../composables/useBlockConvert';
+import { SectionId } from './sections';
+export type ProfileId = 'TEXT_LIKE' | 'HEADING' | 'BLOCKQUOTE' | 'TASK_ITEM' | 'LI' | 'PRE' | 'TABLE' | 'TABLE_CELL' | 'MINIMAL' | 'MERMAID' | 'CANVAS' | 'IMAGE' | 'EMBED_VIEW';
+export interface ProfileDef {
+    sections: SectionId[];
+    getRectEl?: (blockEl: Element) => Element;
+    getPMDomTarget?: (blockEl: Element) => Element;
+    convert?: BlockConvertId;
+    currentTypeId?: string;
+    getCurrentTypeId?: (blockEl: Element) => string;
+    isWrapper?: true;
+}
+export declare const MENU_PROFILES: Record<ProfileId, ProfileDef>;

package/dist/config/blockMenu/sections.d.ts

@@ -0,0 +1,8 @@
+import { ItemId } from './items';
+export type SectionId = 'CONVERT_TILES' | 'DRAW' | 'OPS' | 'CODE_OPS' | 'TABLE_OPS' | 'INDENT_LIST' | 'COLOR_SECTION' | 'CANVAS_OPS' | 'IMAGE_OPS' | 'EMBED_VIEW_OPS';
+export interface SectionDef {
+    label?: string;
+    style?: 'tiles' | 'list';
+    items: ItemId[];
+}
+export declare const MENU_SECTIONS: Record<SectionId, SectionDef>;

package/dist/config/blockMenu/tagMapping.d.ts

@@ -0,0 +1,9 @@
+import { Component } from 'vue';
+import { ProfileId } from './profiles';
+export interface BlockDisplay {
+    label: string;
+    icon: Component;
+    pillVariant: 'text' | 'table' | 'minimal';
+}
+export declare const BLOCK_TAG_TO_PROFILE: Record<string, ProfileId>;
+export declare const BLOCK_DISPLAY: Record<string, BlockDisplay>;

package/dist/config/blockTypeConfig.d.ts

@@ -0,0 +1 @@
+export * from './blockMenu';

package/dist/config/extensionProfiles.d.ts

@@ -0,0 +1,3 @@
+export type ExtensionProfile = 'edit' | 'view' | 'comment';
+export declare const EXTENSION_PROFILES: Record<string, ExtensionProfile[]>;
+export declare function shouldLoad(extName: string, profile: ExtensionProfile): boolean;

package/dist/config/insertMenu/blockCommands.d.ts

@@ -0,0 +1,2 @@
+import { MenuChain } from '../../types/menuCommands';
+export declare const INSERT_BLOCK_CMDS: Record<string, (chain: MenuChain) => void>;

package/dist/config/insertMenu/cellOps.d.ts

@@ -0,0 +1,22 @@
+import { Component } from 'vue';
+import { InsertItemDef } from './items';
+import { ResolvedInsertSectionDef } from './sections';
+export type CellOpKind = 'rowBefore' | 'rowAfter' | 'colBefore' | 'colAfter' | 'delRow' | 'delCol';
+export interface CellOpItemDef {
+    id: CellOpKind;
+    label: string;
+    icon: Component;
+    danger?: boolean;
+    kind: 'cell-op';
+}
+export type InsertMenuItemDef = InsertItemDef | CellOpItemDef;
+export interface ResolvedInsertMenuSectionDef {
+    label: string;
+    style: 'tiles' | 'list';
+    items: InsertMenuItemDef[];
+}
+export declare const CELL_OP_ITEMS: Record<CellOpKind, CellOpItemDef>;
+export declare const CELL_OP_SECTIONS: ResolvedInsertMenuSectionDef[];
+export declare const RESOLVED_INSERT_SECTIONS_CELL_WITH_OPS: ResolvedInsertMenuSectionDef[];
+export declare function isCellOpItem(item: InsertMenuItemDef): item is CellOpItemDef;
+export declare function asInsertMenuSections(sections: ResolvedInsertSectionDef[]): ResolvedInsertMenuSectionDef[];

package/dist/config/insertMenu/commands.d.ts

@@ -0,0 +1,16 @@
+import { InsertItemId } from './items';
+import { MenuChain } from '../../types/menuCommands';
+import { EmbedViewMode } from '../../extensions/EmbedView';
+export interface InsertCtx {
+    pos?: number;
+    rows?: number;
+    cols?: number;
+    src?: string;
+    alt?: string | null;
+    title?: string | null;
+    label?: string;
+    text?: string;
+    href?: string;
+    view?: EmbedViewMode;
+}
+export declare const INSERT_CMDS: Record<InsertItemId, (chain: MenuChain, ctx?: InsertCtx) => void>;

package/dist/config/insertMenu/index.d.ts

@@ -0,0 +1,10 @@
+export type { InsertItemDef, InsertItemId, InsertPickerKind } from './items';
+export type { InsertSectionDef, ResolvedInsertSectionDef } from './sections';
+export type { InsertCtx } from './commands';
+export type { MenuChain } from '../../types/menuCommands';
+export type { CellOpItemDef, CellOpKind, InsertMenuItemDef, ResolvedInsertMenuSectionDef } from './cellOps';
+export { INSERT_ITEMS } from './items';
+export { INSERT_SECTIONS, INSERT_SECTIONS_CELL, RESOLVED_INSERT_SECTIONS, RESOLVED_INSERT_SECTIONS_CELL } from './sections';
+export { INSERT_CMDS } from './commands';
+export { INSERT_BLOCK_CMDS } from './blockCommands';
+export { CELL_OP_ITEMS, CELL_OP_SECTIONS, RESOLVED_INSERT_SECTIONS_CELL_WITH_OPS, asInsertMenuSections, isCellOpItem, } from './cellOps';