@heyirisai/docx-editor-vue 1.9.0

package/dist/composables/useCommentManagement.d.ts

@@ -0,0 +1,68 @@
+import { MaybeRef, Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Comment, Document } from '@heyirisai/docx-editor-core/types/document';
+import { CommentIdAllocator } from '@heyirisai/docx-editor-core/prosemirror/commentIdAllocator';
+import { TrackedChangeEntry } from '../components/sidebar/sidebarUtils';
+/**
+ * Host-facing comment lifecycle callbacks (the `onComment*` props). Shared with
+ * `useCommentLifecycle`. The granular callbacks fire on the matching UI action;
+ * `onCommentsChange` fires with the full array on every comment mutation.
+ */
+export interface CommentCallbacks {
+    onCommentAdd?: (comment: Comment) => void;
+    onCommentResolve?: (comment: Comment) => void;
+    onCommentDelete?: (comment: Comment) => void;
+    onCommentReply?: (reply: Comment, parent: Comment) => void;
+    onCommentsChange?: (comments: Comment[]) => void;
+}
+export interface UseCommentManagementOptions {
+    editorView: Ref<EditorView | null>;
+    getDocument: () => Document | null;
+    comments: Ref<Comment[]>;
+    trackedChanges: Ref<TrackedChangeEntry[]>;
+    showSidebar: Ref<boolean>;
+    isAddingComment: Ref<boolean>;
+    pendingCommentRange: Ref<{
+        from: number;
+        to: number;
+    } | null>;
+    contentChangeSubscribers: Set<(document: unknown) => void>;
+    extractCommentsAndChanges: () => void;
+    emit: (event: string, ...args: unknown[]) => void;
+    /**
+     * Per-editor-instance monotonic ID allocator, shared with
+     * `useCommentLifecycle` so comment and tracked-change IDs never collide.
+     */
+    commentIdAllocator: CommentIdAllocator;
+    /** Author name for UI-created replies/changes (the `author` prop). */
+    author?: MaybeRef<string>;
+    /** Host-facing comment lifecycle callbacks (the `onComment*` props). */
+    commentCallbacks?: CommentCallbacks;
+    /** Get all active header/footer ProseMirror EditorViews. */
+    getHfPmViews?: () => Map<string, EditorView>;
+}
+export declare function useCommentManagement(opts: UseCommentManagementOptions): {
+    addComment: (options: {
+        paraId: string;
+        text: string;
+        author: string;
+        search?: string;
+    }) => number | null;
+    replyToComment: (commentId: number, text: string, author: string) => number | null;
+    resolveComment: (commentId: number) => void;
+    proposeChange: (options: {
+        paraId: string;
+        search: string;
+        replaceWith: string;
+        author: string;
+    }) => boolean;
+    handleCommentReply: (commentId: number, text: string) => void;
+    handleCommentResolve: (commentId: number) => void;
+    handleCommentUnresolve: (commentId: number) => void;
+    handleCommentDelete: (commentId: number) => void;
+    handleAcceptChange: (from: number, to: number) => void;
+    handleRejectChange: (from: number, to: number) => void;
+    handleAcceptChangeById: (revisionId: number) => void;
+    handleRejectChangeById: (revisionId: number) => void;
+    handleTrackedChangeReply: (revisionId: number, text: string) => void;
+};

package/dist/composables/useCommentSidebarItems.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { Comment } from '@heyirisai/docx-editor-core/types/content';
+import { TrackedChangeEntry } from './useTrackedChanges';
+export interface CommentSidebarItem {
+    id: string;
+    anchorPos: number;
+    anchorKey?: string;
+    priority?: number;
+    isTemporary?: boolean;
+    fixedY?: number;
+    estimatedHeight?: number;
+    kind: 'add-comment' | 'comment' | 'tracked-change';
+    comment?: Comment;
+    replies?: Comment[];
+    change?: TrackedChangeEntry;
+}
+export interface UseCommentSidebarItemsOptions {
+    comments: Ref<Comment[]>;
+    trackedChanges: Ref<TrackedChangeEntry[]>;
+    showResolved?: Ref<boolean>;
+    isAddingComment?: Ref<boolean>;
+    addCommentYPosition?: Ref<number | null>;
+}
+export declare function useCommentSidebarItems({ comments, trackedChanges, showResolved, isAddingComment, addCommentYPosition, }: UseCommentSidebarItemsOptions): import('vue').ComputedRef<CommentSidebarItem[]>;

package/dist/composables/useCommentSidebarItems.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/useContextMenus.cut.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/useContextMenus.d.ts

@@ -0,0 +1,39 @@
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { ImageLayoutTarget } from '@heyirisai/docx-editor-core/prosemirror/commands';
+import { ImageSelectionInfo } from '../components/imageSelectionTypes';
+import { ImageContextMenuState, ImageContextMenuTextAction } from '../components/imageContextMenuTypes';
+type Commands = Record<string, ((...args: unknown[]) => unknown) | undefined>;
+export interface TextContextMenuState {
+    isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    hasSelection: boolean;
+    inTable: boolean;
+    onImage: boolean;
+    canMergeCells: boolean;
+    canSplitCell: boolean;
+}
+export interface UseContextMenusOptions {
+    editorView: Ref<EditorView | null>;
+    selectedImage: ShallowRef<ImageSelectionInfo | null>;
+    zoom: Ref<number>;
+    showImageProperties: Ref<boolean>;
+    getCommands: () => Commands;
+    clearOverlay: () => void;
+    setPmSelection: (anchor: number, head?: number) => void;
+    resolvePos: (clientX: number, clientY: number) => number | null;
+}
+export interface UseContextMenusReturn {
+    contextMenu: Ref<TextContextMenuState>;
+    imageContextMenu: Ref<ImageContextMenuState | null>;
+    imageContextMenuTextActions: ComputedRef<ImageContextMenuTextAction[]>;
+    handleContextMenu: (event: MouseEvent) => void;
+    handleSelectedImageContextMenu: (event: MouseEvent) => void;
+    handleImageWrapSelect: (target: ImageLayoutTarget) => void;
+    handleContextMenuAction: (action: string) => void;
+}
+export declare function useContextMenus(opts: UseContextMenusOptions): UseContextMenusReturn;
+export {};

package/dist/composables/useControllableBoolean.d.ts

@@ -0,0 +1,16 @@
+import { WritableComputedRef } from 'vue';
+/**
+ * A boolean that can run either controlled or uncontrolled, exposed as a
+ * writable ref so existing call sites can keep mutating `.value` directly.
+ *
+ * - Controlled (`controlled()` returns a boolean): the prop is the source of
+ *   truth. Internal state is bypassed; writes only call `onChange` (if provided)
+ *   and the consumer decides whether to honor them.
+ * - Uncontrolled (`controlled()` returns `undefined`): the composable owns the
+ *   value, and writes update internal state and call `onChange` so consumers can
+ *   observe without owning state.
+ *
+ * `onChange` is optional and does not fire when the value would be unchanged.
+ * Mirrors the React adapter's `useControllableBoolean` hook.
+ */
+export declare function useControllableBoolean(controlled: () => boolean | undefined, onChange?: (value: boolean) => void, defaultValue?: boolean): WritableComputedRef<boolean>;

package/dist/composables/useControllableBoolean.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/useDocumentLifecycle.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { Document } from '@heyirisai/docx-editor-core/types/document';
+import { DocxInput } from '@heyirisai/docx-editor-core/utils';
+export interface UseDocumentLifecycleOptions {
+    documentBuffer: () => DocxInput | null;
+    document: () => Document | null;
+    loadDocumentBuffer: (buffer: DocxInput) => Promise<void>;
+    loadDocument: (doc: Document) => void;
+    sidebarAutoOpenedRef: Ref<boolean>;
+}
+export declare function useDocumentLifecycle(opts: UseDocumentLifecycleOptions): void;

package/dist/composables/useDocxEditor.d.ts

@@ -0,0 +1,96 @@
+import { MaybeRef, Ref, ShallowRef } from 'vue';
+import { EditorState, Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { FontOption } from '@heyirisai/docx-editor-core/utils/fontOptions';
+import { CommandMap } from '@heyirisai/docx-editor-core/prosemirror/extensions/types';
+import { Layout } from '@heyirisai/docx-editor-core/layout-engine/types';
+import { Document } from '@heyirisai/docx-editor-core/types/document';
+import { LayoutSelectionGate } from '@heyirisai/docx-editor-core/prosemirror';
+export interface UseDocxEditorOptions {
+    /** Container element for the hidden ProseMirror editor */
+    hiddenContainer: Ref<HTMLElement | null>;
+    /** Container element for the visible pages */
+    pagesContainer: Ref<HTMLElement | null>;
+    /** Whether the editor is read-only */
+    readOnly?: MaybeRef<boolean>;
+    /** Page gap in pixels */
+    pageGap?: number;
+    /** Callback on document change */
+    onChange?: (doc: Document) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Callback on selection change */
+    onSelectionUpdate?: () => void;
+    /** External ProseMirror plugins supplied by the host app. */
+    externalPlugins?: Plugin[];
+    /** Coordinates layout updates with visible selection/decoration overlays. */
+    syncCoordinator?: LayoutSelectionGate;
+    /**
+     * Editor mode. When set to `'suggesting'`, the composable toggles the
+     * mounted suggestion-mode plugin's active state so typed text becomes
+     * tracked changes. Reactive — flip at runtime to switch modes.
+     * Mirrors React's `editingMode` prop wiring.
+     */
+    editorMode?: MaybeRef<'editing' | 'suggesting' | 'viewing'>;
+    /** Author name attached to tracked changes minted in suggesting mode. */
+    author?: MaybeRef<string>;
+}
+export interface UseDocxEditorReturn {
+    /** ProseMirror editor view (hidden). */
+    editorView: ShallowRef<EditorView | null>;
+    /** Latest editor state. Updated on each transaction. */
+    editorState: ShallowRef<EditorState | null>;
+    /** True once the editor view has mounted and a document is loaded. */
+    isReady: Ref<boolean>;
+    /** Last parse error message, or null if the most recent load succeeded. */
+    parseError: Ref<string | null>;
+    /**
+     * Fonts the loaded document references that the browser can render (embedded
+     * faces + system-resolved), for the picker's "Document fonts" group.
+     */
+    documentFonts: Ref<FontOption[]>;
+    /** Computed page layout. */
+    layout: ShallowRef<Layout | null>;
+    /** Load a DOCX from a binary buffer. */
+    loadBuffer: (buffer: ArrayBuffer | Uint8Array | Blob | File) => Promise<void>;
+    /** Load a parsed `Document` directly. */
+    loadDocument: (doc: Document) => void;
+    /** Serialize the current document to a DOCX blob. */
+    save: () => Promise<Blob | null>;
+    /** Focus the hidden ProseMirror view. */
+    focus: () => void;
+    /** Destroy the editor view and clean up listeners. */
+    destroy: () => void;
+    /** Snapshot the current document model. */
+    getDocument: () => Document | null;
+    /** Access the extension command map for invoking marks/nodes/features. */
+    getCommands: () => CommandMap;
+    /** Force a re-layout without a doc change (e.g. after page-setup changes). */
+    reLayout: () => void;
+    /**
+     * Look up the persistent hidden HF EditorView for a HeaderFooter
+     * instance. The inline overlay and the click router use this to
+     * dispatch selection / focus on the same EditorView the painter reads.
+     * Returns null if the document is unloaded or no PM is mounted for
+     * the HF's `rId` (cold boot, or just-removed slot).
+     */
+    getHfPmView: (hf: import('@heyirisai/docx-editor-core/types/document').HeaderFooter) => EditorView | null;
+    /** Get all active header/footer EditorViews mapped by rId. */
+    getHfPmViews: () => Map<string, EditorView>;
+    /**
+     * Re-mount / tear down HF EditorViews to match the current document's
+     * `package.headers/footers`. Call this after the inline overlay saves
+     * back into `Document.package.headers` (the swap produces new HeaderFooter
+     * objects; new EditorViews need to point at the new objects).
+     */
+    syncHfPMs: () => void;
+    /**
+     * Subscribe to every HF transaction. `cb(rId, view)` fires after the
+     * EditorView's state has been updated. Used by the painted-HF caret
+     * overlay and HF UI chrome (toolbar selection sync).
+     */
+    setHfTransactionListener: (cb: ((rId: string, view: EditorView, docChanged: boolean) => void) | null) => void;
+    /** Publish a fresh Document object (used by HF materialisation). */
+    setDocument: (doc: Document) => void;
+}
+export declare function useDocxEditor(options: UseDocxEditorOptions): UseDocxEditorReturn;

package/dist/composables/useDocxEditorRefApi.d.ts

@@ -0,0 +1,53 @@
+import { Ref, ShallowRef } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Document } from '@heyirisai/docx-editor-core/types/document';
+import { Comment } from '@heyirisai/docx-editor-core/types/content';
+import { DocxInput } from '@heyirisai/docx-editor-core/utils';
+import { Layout } from '@heyirisai/docx-editor-core/layout-engine';
+import { DocxEditorRef } from '../components/DocxEditor/types';
+import { ApplyFormattingOptions } from './useFormattingActions';
+export interface UseDocxEditorRefApiOptions {
+    editorView: Ref<EditorView | null>;
+    layout: Ref<Layout | null>;
+    pagesRef: Ref<HTMLElement | null>;
+    pagesViewportRef: Ref<HTMLElement | null>;
+    zoom: Ref<number>;
+    comments: ShallowRef<Comment[]>;
+    focus: () => void;
+    destroy: () => void;
+    getDocument: () => Document | null;
+    setZoom: (zoom: number) => void;
+    save: () => Promise<ArrayBuffer | null>;
+    loadDocument: (doc: Document) => void;
+    loadDocumentBuffer: (buffer: DocxInput) => Promise<void>;
+    addComment: (options: {
+        paraId: string;
+        text: string;
+        author: string;
+        search?: string;
+    }) => number | null;
+    replyToComment: (commentId: number, text: string, author: string) => number | null;
+    resolveComment: (commentId: number) => void;
+    proposeChange: (options: {
+        paraId: string;
+        search: string;
+        replaceWith: string;
+        author: string;
+    }) => boolean;
+    applyFormatting: (options: ApplyFormattingOptions) => boolean;
+    setParagraphStyle: (options: {
+        paraId: string;
+        styleId: string;
+    }) => boolean;
+    insertBreak: (options: {
+        paraId: string;
+        type: 'page' | 'sectionNextPage' | 'sectionContinuous';
+    }) => boolean;
+    scrollVisiblePositionIntoView: (pmPos: number) => void;
+    contentChangeSubscribers: Set<(document: unknown) => void>;
+    selectionChangeSubscribers: Set<(selection: unknown) => void>;
+    onPrint?: () => void;
+}
+export declare function useDocxEditorRefApi(opts: UseDocxEditorRefApiOptions): {
+    exposed: DocxEditorRef;
+};

package/dist/composables/useDragAutoScroll.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+export interface DragAutoScrollOptions {
+    pagesContainer: Ref<HTMLElement | null>;
+    /** Called during auto-scroll to extend the selection at the current mouse position. */
+    onScrollExtendSelection: (clientX: number, clientY: number) => void;
+}
+export interface UseDragAutoScrollReturn {
+    updateMousePosition: (clientX: number, clientY: number) => void;
+    stopAutoScroll: () => void;
+}
+export declare function useDragAutoScroll({ pagesContainer, onScrollExtendSelection, }: DragAutoScrollOptions): UseDragAutoScrollReturn;

package/dist/composables/useFileIO.d.ts

@@ -0,0 +1,41 @@
+import { EditorView } from 'prosemirror-view';
+import { Document } from '@heyirisai/docx-editor-core/types/document';
+export interface UseFileIOOptions {
+    /** From useDocxEditor — loads a .docx buffer into the editor. */
+    loadBuffer: (buffer: ArrayBuffer | Uint8Array | Blob | File) => Promise<void>;
+    /**
+     * Host override for File > Open / Cmd+O. When provided, the picked file is
+     * passed here instead of running the built-in local load — lets consumers
+     * route Open through their own import pipeline (e.g. a CRDT backend).
+     */
+    onOpen?: (file: File) => void | Promise<void>;
+    /** From useDocxEditor — loads an already-parsed Document model. */
+    loadParsedDocument: (doc: Document) => void;
+    /** From useDocxEditor — returns the current Document, or null. */
+    getDocument: () => Document | null;
+    /** From useDocxEditor — serializes the current state to a .docx Blob. */
+    saveBlob: () => Promise<Blob | null>;
+    /** Fired after load+extract so the next tick sees comments/tracked-changes. */
+    extractCommentsAndChanges: () => void;
+    /** SFC's emit function — re-emits ready / rename / update:document / error. */
+    emit: (event: string, ...args: unknown[]) => void;
+    /** Accessor — read freshly inside the handler so prop updates are honored. */
+    documentName: () => string | undefined;
+    onDocumentNameChange?: (name: string) => void;
+    /** Active editor view to insert images into — the header/footer being edited, else the body. */
+    getActiveView: () => EditorView | null;
+    /** Vue's `nextTick` — passed in so the composable doesn't require its own import wiring. */
+    nextTick: () => Promise<void>;
+}
+export declare function useFileIO(opts: UseFileIOOptions): {
+    docxInputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    imageInputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    handleImageFileChange: (event: Event) => void;
+    handleDocxFileChange: (event: Event) => Promise<void>;
+    handleDocumentNameChange: (name: string) => void;
+    downloadCurrentDocument: () => Promise<void>;
+    emitReadyAfterSidebarStateRefresh: () => Promise<void>;
+    loadDocumentBuffer: (buffer: Parameters<typeof opts.loadBuffer>[0]) => Promise<void>;
+    loadDocument: (doc: Document) => void;
+    save: () => Promise<ArrayBuffer | null>;
+};

package/dist/composables/useFindReplace.d.ts

@@ -0,0 +1,34 @@
+import { ComputedRef } from 'vue';
+import { FindMatch, FindOptions } from '@heyirisai/docx-editor-core/utils/findReplace';
+export type { FindMatch, FindOptions };
+export interface FindReplaceOptions {
+    initialReplaceMode?: boolean;
+    onMatchesChange?: (matches: FindMatch[]) => void;
+    onCurrentMatchChange?: (match: FindMatch | null, index: number) => void;
+}
+export interface FindReplaceState {
+    isOpen: boolean;
+    searchText: string;
+    replaceText: string;
+    options: FindOptions;
+    matches: FindMatch[];
+    currentIndex: number;
+    replaceMode: boolean;
+}
+export interface UseFindReplaceReturn {
+    state: FindReplaceState;
+    currentMatch: ComputedRef<FindMatch | null>;
+    hasMatches: ComputedRef<boolean>;
+    openFind: (selectedText?: string) => void;
+    openReplace: (selectedText?: string) => void;
+    close: () => void;
+    toggle: () => void;
+    setSearchText: (text: string) => void;
+    setReplaceText: (text: string) => void;
+    setOptions: (opts: Partial<FindOptions>) => void;
+    setMatches: (matches: FindMatch[], currentIndex?: number) => void;
+    goToNextMatch: () => number;
+    goToPreviousMatch: () => number;
+    goToMatch: (index: number) => void;
+}
+export declare function useFindReplace(hookOptions?: FindReplaceOptions): UseFindReplaceReturn;

package/dist/composables/useFixedDropdown.d.ts

@@ -0,0 +1,14 @@
+import { Ref, CSSProperties } from 'vue';
+export interface UseFixedDropdownOptions {
+    isOpen: Ref<boolean>;
+    onClose: () => void;
+    /** 'left' aligns dropdown left edge to trigger, 'right' aligns right edge. */
+    align?: 'left' | 'right';
+}
+export interface UseFixedDropdownReturn {
+    containerRef: Ref<HTMLElement | null>;
+    dropdownRef: Ref<HTMLElement | null>;
+    dropdownStyle: Ref<CSSProperties>;
+    handleMouseDown: (e: MouseEvent) => void;
+}
+export declare function useFixedDropdown({ isOpen, onClose, align, }: UseFixedDropdownOptions): UseFixedDropdownReturn;

package/dist/composables/useFontLifecycle.d.ts

@@ -0,0 +1,12 @@
+import { FontDefinition } from '@heyirisai/docx-editor-core/utils';
+/**
+ * Vue counterpart to React's `useFontLifecycle`.
+ *
+ * - Re-registers custom faces from the `fonts` prop on identity change.
+ *   The loader dedupes by `family|weight`, so re-runs are cheap.
+ * - Forwards font-load failures to the supplied error handler. `<DocxEditor>`
+ *   passes `(err) => emit('error', err)`; `emit` is stable per `<script setup>`
+ *   instance, so the subscription stays on a single listener for the
+ *   component's lifetime.
+ */
+export declare function useFontLifecycle(fontsGetter: () => ReadonlyArray<FontDefinition> | undefined, onError: (error: Error) => void): void;

package/dist/composables/useFormattingActions.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Document } from '@heyirisai/docx-editor-core/types/document';
+import { ApplyFormattingOptions, InsertBreakOptions } from '@heyirisai/docx-editor-core/prosemirror/applyFormatting';
+export interface UseFormattingActionsOptions {
+    editorView: Ref<EditorView | null>;
+    /**
+     * The view interactive toolbar formatting should target. While a header or
+     * footer is being edited this is its EditorView, so toolbar actions land in
+     * the HF and not the body (#749). Falls back to the body `editorView`. The
+     * agent ref-API (`applyFormatting`/`setParagraphStyle`, which resolve a
+     * paraId in the body) deliberately keeps using `editorView`.
+     */
+    activeView?: Ref<EditorView | null>;
+    getDocument: () => Document | null;
+}
+export type { ApplyFormattingOptions, InsertBreakOptions };
+export declare function useFormattingActions(opts: UseFormattingActionsOptions): {
+    handleClearFormatting: () => void;
+    handleApplyStyle: (styleId: string) => void;
+    handleInsertPageBreak: () => void;
+    handleInsertSectionBreakNextPage: () => void;
+    handleInsertSectionBreakContinuous: () => void;
+    handleInsertSymbol: (symbol: string) => void;
+    applyFormatting: (options: ApplyFormattingOptions) => boolean;
+    setParagraphStyle: (options: {
+        paraId: string;
+        styleId: string;
+    }) => boolean;
+    insertBreak: (options: InsertBreakOptions) => boolean;
+};

package/dist/composables/useHistory.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef, Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+export interface UseHistoryReturn {
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undo: () => boolean;
+    redo: () => boolean;
+}
+export declare function useHistory(view: Ref<EditorView | null>, stateTick: Ref<number>): UseHistoryReturn;

package/dist/composables/useHostCallbacks.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { DocxEditorProps } from '../components/DocxEditor/types';
+import { CommentCallbacks } from './useCommentManagement';
+export declare function useHostCallbacks(props: DocxEditorProps, editorView: Ref<EditorView | null>): {
+    commentCallbacks: CommentCallbacks;
+};

package/dist/composables/useHyperlinkManagement.d.ts

@@ -0,0 +1,38 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { HyperlinkPopupData } from '../components/ui/hyperlinkPopupTypes';
+export type { HyperlinkPopupData };
+type Commands = Record<string, (...args: unknown[]) => unknown>;
+export interface UseHyperlinkManagementOptions {
+    editorView: Ref<EditorView | null>;
+    getCommands: () => Commands;
+}
+export declare function useHyperlinkManagement(opts: UseHyperlinkManagementOptions): {
+    hyperlinkPopupData: Ref<{
+        href: string;
+        displayText: string;
+        tooltip?: string | undefined;
+        position: {
+            top: number;
+            left: number;
+        };
+    } | null, HyperlinkPopupData | {
+        href: string;
+        displayText: string;
+        tooltip?: string | undefined;
+        position: {
+            top: number;
+            left: number;
+        };
+    } | null>;
+    handleHyperlinkSubmit: (data: {
+        url?: string;
+        bookmark?: string;
+        displayText: string;
+        tooltip: string;
+    }) => void;
+    handleHyperlinkRemove: () => void;
+    handleHyperlinkPopupNavigate: (href: string) => void;
+    handleHyperlinkPopupEdit: (displayText: string, href: string) => void;
+    handleHyperlinkPopupRemove: () => void;
+};

package/dist/composables/useImageActions.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { ImageSelectionInfo } from '../components/imageSelectionTypes';
+type Commands = Record<string, ((...args: unknown[]) => unknown) | undefined>;
+export interface UseImageActionsOptions {
+    editorView: Ref<EditorView | null>;
+    zoom: Ref<number>;
+    stateTick: Ref<number>;
+    getCommands: () => Commands;
+}
+export interface ImageToolbarContext {
+    wrapType: string;
+    displayMode: string;
+    cssFloat: string | null;
+}
+export interface UseImageActionsReturn {
+    selectedImage: import('vue').ShallowRef<ImageSelectionInfo | null>;
+    imageInteracting: import('vue').Ref<boolean>;
+    imageToolbarContext: import('vue').ComputedRef<ImageToolbarContext | null>;
+    handleToolbarImageWrap: (value: string) => void;
+    handleImageTransform: (action: 'rotateCW' | 'rotateCCW' | 'flipH' | 'flipV') => void;
+}
+export declare function useImageActions(opts: UseImageActionsOptions): UseImageActionsReturn;
+export {};

package/dist/composables/useKeyboardShortcuts.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+export interface UseKeyboardShortcutsOptions {
+    showKeyboardShortcuts: Ref<boolean>;
+    showFindReplace: Ref<boolean>;
+    showHyperlink: Ref<boolean>;
+    /** From useZoom — handles Ctrl+= / Ctrl+- / Ctrl+0. */
+    handleZoomKeyDown: (e: KeyboardEvent) => void;
+    /**
+     * Host prop accessor — read freshly inside the handler so a host
+     * toggle at runtime is honored. (Capturing the prop value at setup
+     * time would freeze it.)
+     */
+    disableFindReplaceShortcuts?: () => boolean | undefined;
+    /**
+     * Whether `File > Open` / Cmd+O is enabled. Read freshly so a runtime host
+     * toggle is honored. When false (or `onOpenDocument` is absent), Cmd+O is
+     * left unhandled so the browser default stands.
+     */
+    showFileOpen?: () => boolean | undefined;
+    /** Opens the DOCX picker — wired to the same hidden input as File > Open. */
+    onOpenDocument?: () => void;
+}
+export declare function useKeyboardShortcuts(opts: UseKeyboardShortcutsOptions): {
+    handleKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/composables/useMenuActions.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+export interface UseMenuActionsOptions {
+    editorView: Ref<EditorView | null>;
+    getCommands: () => Record<string, (...args: any[]) => any>;
+    docxInputRef: Ref<HTMLInputElement | null>;
+    imageInputRef: Ref<HTMLInputElement | null>;
+    showPageSetup: Ref<boolean>;
+    showWatermark: Ref<boolean>;
+    showHyperlink: Ref<boolean>;
+    showInsertSymbol: Ref<boolean>;
+    showKeyboardShortcuts: Ref<boolean>;
+    handleClearFormatting: () => void;
+    handleInsertPageBreak: () => void;
+    handleInsertSectionBreakNextPage: () => void;
+    handleInsertSectionBreakContinuous: () => void;
+    handleToggleOutline: () => void;
+    handleToggleSidebar: () => void;
+    downloadCurrentDocument: () => Promise<void>;
+    emit: (event: string, ...args: unknown[]) => void;
+}
+export declare function useMenuActions(opts: UseMenuActionsOptions): {
+    handleMenuAction: (action: string) => void;
+    handleMenuTableInsert: (rows: number, cols: number) => void;
+    execSimpleCommand: (name: string) => void;
+};

package/dist/composables/useOutlineSidebar.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { HeadingInfo } from '@heyirisai/docx-editor-core/utils/headingCollector';
+export interface UseOutlineSidebarOptions {
+    editorView: Ref<EditorView | null>;
+    showOutline: Ref<boolean>;
+    showSidebar: Ref<boolean>;
+    outlineHeadings: Ref<HeadingInfo[]>;
+    activeSidebarItem: Ref<string | null>;
+    extractCommentsAndChanges: () => void;
+    /**
+     * Scroll the VISIBLE paged viewport to a PM position. The hidden PM
+     * (`left: -9999px`) is never what the user sees, so `tr.scrollIntoView()`
+     * on it does nothing; the outline must drive the painter viewport instead
+     * (mirrors React's `scrollToPosition`; #930).
+     */
+    scrollToVisiblePosition: (pmPos: number) => void;
+}
+export declare function useOutlineSidebar(opts: UseOutlineSidebarOptions): {
+    handleToggleOutline: () => void;
+    handleOutlineNavigate: (pmPos: number) => void;
+    handleToggleSidebar: () => void;
+    handleEditorScrollMouseDown: (event: MouseEvent) => void;
+};

package/dist/composables/useOutlineSidebar.test.d.ts

@@ -0,0 +1 @@
+export {};