@eigenpal/docx-editor-vue 0.0.0

package/dist/_plugin-vue_export-helper-B52Kst-M.js

@@ -0,0 +1,8 @@
+//#region \0plugin-vue:export-helper
+var e = (e, t) => {
+	let n = e.__vccOpts || e;
+	for (let [e, r] of t) n[e] = r;
+	return n;
+};
+//#endregion
+export { e as t };

package/dist/_plugin-vue_export-helper-CX7YVcP6.cjs

@@ -0,0 +1 @@
+var e=(e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n};Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});

package/dist/components/DocxEditor/types.d.ts

@@ -0,0 +1,100 @@
+import { Plugin } from 'prosemirror-state';
+import { Document, Theme } from '@eigenpal/docx-editor-core/types/document';
+import { DocxInput } from '@eigenpal/docx-editor-core/utils';
+import { FontOption } from '@eigenpal/docx-editor-core/utils/fontOptions';
+import { StyleValue, VNodeChild } from 'vue';
+import { EditorRefLike } from '@eigenpal/docx-editor-agents/bridge';
+import { Translations } from '@eigenpal/docx-editor-i18n';
+export type EditorMode = 'editing' | 'suggesting' | 'viewing';
+/**
+ * Public props for the Vue editor component.
+ */
+export interface DocxEditorProps {
+    /** Document data — ArrayBuffer, Uint8Array, Blob, or File. */
+    documentBuffer?: DocxInput | null;
+    /** Pre-parsed document model, alternative to documentBuffer. */
+    document?: Document | null;
+    /** Whether to show the main formatting toolbar. */
+    showToolbar?: boolean;
+    /** Whether to show the title/menu bar. Vue-only chrome toggle. */
+    showMenuBar?: boolean;
+    /** Whether to show page rulers. */
+    showRuler?: boolean;
+    /** Document name shown in the title bar. */
+    documentName?: string;
+    /** Whether the editor is read-only. */
+    readOnly?: boolean;
+    /** Editor mode: direct editing, suggesting, or viewing. */
+    mode?: EditorMode;
+    /** Callback when the editing mode changes. */
+    onModeChange?: (mode: EditorMode) => void;
+    /** Translation overrides merged with English fallback. */
+    i18n?: Translations;
+    /** Theme override used for toolbar color palettes when the document has no theme. */
+    theme?: Theme | null;
+    /** External ProseMirror plugins supplied by the host app. */
+    externalPlugins?: Plugin[];
+    /** Whether to show the zoom controls in the toolbar. */
+    showZoomControl?: boolean;
+    /** Initial zoom level. */
+    initialZoom?: number;
+    /** Custom toolbar content appended after the built-in controls. */
+    toolbarExtra?: () => VNodeChild;
+    /** Additional CSS class name on the editor root. */
+    className?: string;
+    /** Additional inline styles on the editor root. */
+    style?: StyleValue;
+    /** Whether to show the document outline panel initially. */
+    showOutline?: boolean;
+    /** Whether to show the floating outline toggle button. */
+    showOutlineButton?: boolean;
+    /** Custom list of fonts shown in the font-family dropdown. */
+    fontFamilies?: ReadonlyArray<string | FontOption>;
+    /**
+     * Callback fired when the print action is triggered. Pass it to enable the
+     * `File > Print` menu entry; omit to hide. The `editor.print()` ref method
+     * also invokes this callback.
+     */
+    onPrint?: () => void;
+    /** Disable Cmd/Ctrl+F and Cmd/Ctrl+H interception. */
+    disableFindReplaceShortcuts?: boolean;
+    /** Custom logo/icon renderer for the title bar. Slots remain preferred in templates. */
+    renderLogo?: () => VNodeChild;
+    /** Callback when the document name changes. */
+    onDocumentNameChange?: (name: string) => void;
+    /** Whether the document name is editable. */
+    documentNameEditable?: boolean;
+    /** Custom right-side actions renderer for the title bar. Slots remain preferred in templates. */
+    renderTitleBarRight?: () => VNodeChild;
+}
+/**
+ * Public ref shape for `<DocxEditor>`. Exposes the full editor-scope
+ * `EditorRefLike` contract so the agent bridge can attach to either
+ * React or Vue without an adapter shim.
+ */
+export type DocxEditorRef = EditorRefLike & {
+    /** Agent instance access is React-only today; Vue returns null for API parity. */
+    getAgent(): null;
+    /** Save the document and return DOCX bytes, matching React's component ref. */
+    save(): Promise<ArrayBuffer | null>;
+    /** Set zoom level (1.0 = 100%). */
+    setZoom(zoom: number): void;
+    /** Get current zoom level. */
+    getZoom(): number;
+    /** Focus the editor's hidden ProseMirror view. Vue-only — not in EditorRefLike. */
+    focus(): void;
+    /** Scroll the visible pages to a 1-indexed page number. */
+    scrollToPage(pageNumber: number): void;
+    /** Scroll to a raw ProseMirror document position. */
+    scrollToPosition(pmPos: number): void;
+    /** Open print preview / browser print. */
+    openPrintPreview(): void;
+    /** Print the document. */
+    print(): void;
+    /** Load a pre-parsed document programmatically. */
+    loadDocument(doc: Document): void;
+    /** Load a DOCX buffer programmatically. */
+    loadDocumentBuffer(buffer: DocxInput): Promise<void>;
+    /** Tear down the editor (destroys the PM view + frees listeners). */
+    destroy(): void;
+};

package/dist/components/EditorToolbarContext.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared toolbar prop bag — mirrors React's ToolbarProps. Loosely
+ * typed because the consumer surface here is just the slot-down
+ * channel; tightening would require dragging the entire
+ * ToolbarProps interface across the framework boundary.
+ */
+export type EditorToolbarProps = Record<string, unknown>;
+export declare function provideEditorToolbar(props: EditorToolbarProps): void;
+export declare function useEditorToolbar(): EditorToolbarProps;

package/dist/components/Toolbar/presets.d.ts

@@ -0,0 +1,42 @@
+import { FontOption } from '@eigenpal/docx-editor-core/utils/fontOptions';
+export declare const defaultFonts: FontOption[];
+export declare const fontSizePresets: number[];
+export declare const paragraphStyles: ({
+    id: string;
+    label: string;
+    previewStyle: {
+        fontSize: string;
+        fontWeight?: undefined;
+        color?: undefined;
+    };
+} | {
+    id: string;
+    label: string;
+    previewStyle: {
+        fontSize: string;
+        fontWeight: string;
+        color?: undefined;
+    };
+} | {
+    id: string;
+    label: string;
+    previewStyle: {
+        fontSize: string;
+        color: string;
+        fontWeight?: undefined;
+    };
+} | {
+    id: string;
+    label: string;
+    previewStyle: {
+        fontSize: string;
+        fontWeight: string;
+        color: string;
+    };
+})[];
+export declare const lineSpacingOptions: {
+    label: string;
+    value: number;
+}[];
+export declare const ZOOM_PRESETS: number[];
+export declare const DEFAULT_ZOOM_PERCENT = 100;

package/dist/components/dialogs/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @eigenpal/docx-editor-vue/dialogs
+ *
+ * Modal dialog components — hyperlinks, find/replace, page setup, image
+ * properties, and keyboard shortcuts. Mirrors the React dialogs subpath.
+ *
+ * @example
+ * ```ts
+ * import { HyperlinkDialog, FindReplaceDialog } from '@eigenpal/docx-editor-vue/dialogs';
+ * ```
+ *
+ * @packageDocumentation
+ * @public
+ */
+export { default as FindReplaceDialog } from './FindReplaceDialog.vue';
+export { default as FootnotePropertiesDialog } from './FootnotePropertiesDialog.vue';
+export { default as HyperlinkDialog } from './HyperlinkDialog.vue';
+export { default as ImagePositionDialog } from './ImagePositionDialog.vue';
+export { default as ImagePropertiesDialog } from './ImagePropertiesDialog.vue';
+export { default as InsertImageDialog } from './InsertImageDialog.vue';
+export { default as InsertSymbolDialog } from './InsertSymbolDialog.vue';
+export { default as InsertTableDialog } from './InsertTableDialog.vue';
+export { default as KeyboardShortcutsDialog } from './KeyboardShortcutsDialog.vue';
+export { default as PageSetupDialog } from './PageSetupDialog.vue';
+export { default as PasteSpecialDialog } from './PasteSpecialDialog.vue';
+export { default as SplitCellDialog } from './SplitCellDialog.vue';
+export { default as TablePropertiesDialog } from './TablePropertiesDialog.vue';

package/dist/components/imageContextMenuTypes.d.ts

@@ -0,0 +1,30 @@
+import { WrapType } from '@eigenpal/docx-editor-core/docx/wrapTypes';
+type ImageAttrsCssFloat = 'left' | 'right' | 'none' | null;
+export interface ImageContextMenuState {
+    open: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    pmPos: number;
+    currentWrapType: WrapType;
+    currentCssFloat?: ImageAttrsCssFloat;
+    inlinePositionEmu?: {
+        horizontalEmu: number;
+        verticalEmu: number;
+    };
+}
+/**
+ * Item appended below a divider — mirrors the React side
+ * (`ImageContextMenuTextAction`). `dividerAfter` lets the host group
+ * the items the same way Word does (Cut/Copy/Paste then divider then
+ * Delete).
+ */
+export interface ImageContextMenuTextAction {
+    action: string;
+    label: string;
+    shortcut?: string;
+    disabled?: boolean;
+    dividerAfter?: boolean;
+}
+export {};

package/dist/components/imageSelectionTypes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared `ImageSelectionInfo` type — imported by
+ * `ImageSelectionOverlay.vue` (for `defineProps`) and
+ * `useImageActions.ts` (for the composable's `selectedImage` ref).
+ * Pulled out of the .vue SFC so a plain .ts module can reference it
+ * without going through the `*.vue` wildcard shim, which doesn't
+ * carry named type exports.
+ */
+export interface ImageSelectionInfo {
+    element: HTMLElement;
+    pmPos: number;
+    width: number;
+    height: number;
+}

package/dist/components/insertTableState.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Last-used Insert-Table dimensions. Module-level so the dialog reopens with
+ * whatever the user picked last time (mirrors React lifting this to component
+ * state that survives reopen).
+ */
+export declare const rememberedTableSize: {
+    rows: number;
+    cols: number;
+};

package/dist/components/sidebar/cardStyles.d.ts

@@ -0,0 +1,3 @@
+import { CSSProperties } from 'vue';
+export declare const CARD_STYLE_COLLAPSED: CSSProperties;
+export declare const CARD_STYLE_EXPANDED: CSSProperties;

package/dist/components/sidebar/cardUtils.d.ts

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

package/dist/components/sidebar/resolveItemPositions.d.ts

@@ -0,0 +1,4 @@
+import { CommentSidebarItem } from '../../composables/useCommentSidebarItems';
+import { ResolvedPosition as CoreResolvedPosition } from '@eigenpal/docx-editor-core/plugin-api/resolveItemPositions';
+export type ResolvedPosition = CoreResolvedPosition<CommentSidebarItem>;
+export declare const resolveItemPositions: (items: CommentSidebarItem[], anchorPositions: Map<string, number>, renderedDomContext: import('@eigenpal/docx-editor-core').RenderedDomContext | null, zoom: number, cardHeights: Map<string, number>, lastKnown: Map<string, number>) => CoreResolvedPosition<CommentSidebarItem>[];

package/dist/components/sidebar/sidebarUtils.d.ts

@@ -0,0 +1,4 @@
+import { CSSProperties } from 'vue';
+export { getCommentText, formatDate, getInitials, getAvatarColor, truncateText, type TrackedChangeEntry, } from '@eigenpal/docx-editor-core/utils/comments';
+/** Inline style for an avatar bubble — mirrors React's avatarStyle(). */
+export declare function avatarStyle(name: string, size?: 32 | 28): CSSProperties;

package/dist/components/tableStylePresets.d.ts

@@ -0,0 +1,53 @@
+import { CSSProperties } from 'vue';
+export interface TableStyleBorder {
+    style: string;
+    size?: number;
+    color?: {
+        rgb: string;
+    };
+}
+export interface TableStylePreset {
+    id: string;
+    name: string;
+    /** Table-level borders */
+    tableBorders?: {
+        top?: TableStyleBorder;
+        bottom?: TableStyleBorder;
+        left?: TableStyleBorder;
+        right?: TableStyleBorder;
+        insideH?: TableStyleBorder;
+        insideV?: TableStyleBorder;
+    };
+    /** Conditional formatting per cell position */
+    conditionals?: Record<string, {
+        backgroundColor?: string;
+        borders?: {
+            top?: TableStyleBorder | null;
+            bottom?: TableStyleBorder | null;
+            left?: TableStyleBorder | null;
+            right?: TableStyleBorder | null;
+        };
+        bold?: boolean;
+        color?: string;
+    }>;
+    /** Which conditional formatting is active by default */
+    look?: {
+        firstRow?: boolean;
+        lastRow?: boolean;
+        firstCol?: boolean;
+        lastCol?: boolean;
+        noHBand?: boolean;
+        noVBand?: boolean;
+    };
+}
+export declare const BUILTIN_TABLE_STYLES: TableStylePreset[];
+/** Get a built-in table style preset by ID. */
+export declare function getBuiltinTableStyle(styleId: string): TableStylePreset | undefined;
+/** Map from built-in style ID to en.json translation key under `table.styles.*`. */
+export declare const TABLE_STYLE_NAME_KEYS: Record<string, string>;
+/**
+ * Build the per-cell inline styles for a small preview grid of the given
+ * preset. Shared by TableStyleGallery and InsertTableDialog so the preview
+ * rendering stays in one place.
+ */
+export declare function getPreviewCells(preset: TableStylePreset, rows?: number, cols?: number): CSSProperties[];

package/dist/components/toolbarUtils.d.ts

@@ -0,0 +1 @@
+export { HIGHLIGHT_HEX_TO_NAME, mapHexToHighlightName, } from '@eigenpal/docx-editor-core/utils/highlightColors';

package/dist/components/ui/Icons.d.ts

@@ -0,0 +1 @@
+export { default as MaterialSymbol } from './MaterialSymbol.vue';

package/dist/components/ui/hyperlinkPopupTypes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared `HyperlinkPopupData` type — imported by `HyperlinkPopup.vue`
+ * (for `defineProps`) and `useHyperlinkManagement.ts` (for the
+ * composable's `hyperlinkPopupData` ref). Pulled out of the .vue SFC so
+ * a plain .ts module can reference it without going through the `*.vue`
+ * wildcard shim, which doesn't carry named type exports.
+ */
+export interface HyperlinkPopupData {
+    href: string;
+    displayText: string;
+    tooltip?: string;
+    /** Popup position in the editor's pages-viewport coordinate space (CSS
+     *  pixels from its top-left). Computed once at click time. The popup
+     *  renders inside that viewport with `position: absolute`, so the
+     *  browser handles repositioning during scroll for free. */
+    position: {
+        top: number;
+        left: number;
+    };
+}

package/dist/composables/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @eigenpal/docx-editor-vue/composables
+ *
+ * Vue composables mirroring the React `hooks` subpath — history, table
+ * selection, find/replace, autosave, clipboard, zoom, and the high-level
+ * `useDocxEditor` host composable.
+ *
+ * @example
+ * ```ts
+ * import { useAutoSave, useFindReplace } from '@eigenpal/docx-editor-vue/composables';
+ * ```
+ *
+ * @packageDocumentation
+ * @public
+ */
+export * from './useAutoSave';
+export * from './useClipboard';
+export * from './useCommentSidebarItems';
+export * from './useDocxEditor';
+export * from './useDragAutoScroll';
+export * from './useFindReplace';
+export * from './useFixedDropdown';
+export * from './useHistory';
+export * from './useSelectionHighlight';
+export * from './useTableResize';
+export * from './useTableSelection';
+export * from './useTrackedChanges';
+export * from './useVisualLineNavigation';
+export * from './useWheelZoom';
+export * from './useZoom';

package/dist/composables/useAutoSave.d.ts

@@ -0,0 +1,40 @@
+import { MaybeRef, Ref } from 'vue';
+import { formatLastSaveTime, getAutoSaveStatusLabel, getAutoSaveStorageSize, formatStorageSize, isAutoSaveSupported } from '@eigenpal/docx-editor-core';
+import { AutoSaveStatus, SavedDocumentData } from '@eigenpal/docx-editor-core/managers/types';
+import { Document } from '@eigenpal/docx-editor-core/types/document';
+export type { AutoSaveStatus, SavedDocumentData };
+export { formatLastSaveTime, getAutoSaveStatusLabel, getAutoSaveStorageSize, formatStorageSize, isAutoSaveSupported, };
+export interface UseAutoSaveOptions {
+    /** localStorage key (default: 'docx-editor-autosave') */
+    storageKey?: string;
+    /** Auto-save interval in ms (default: 30000) */
+    interval?: number;
+    /** Whether auto-save starts enabled (default: true). */
+    enabled?: boolean;
+    /** Maximum age of auto-save before it is considered stale. */
+    maxAge?: number;
+    /** Callback when save succeeds. */
+    onSave?: (timestamp: Date) => void;
+    /** Callback when save fails. */
+    onError?: (error: Error) => void;
+    /** Callback when recovery data is found. */
+    onRecoveryAvailable?: (savedDocument: SavedDocumentData) => void;
+    /** Whether document changes trigger a debounced save. */
+    saveOnChange?: boolean;
+    /** Debounce delay for saveOnChange in milliseconds. */
+    debounceDelay?: number;
+}
+export interface UseAutoSaveReturn {
+    status: Ref<AutoSaveStatus>;
+    lastSaveTime: Ref<Date | null>;
+    save: () => Promise<boolean>;
+    clearAutoSave: () => void;
+    hasRecoveryData: Ref<boolean>;
+    getRecoveryData: () => SavedDocumentData | null;
+    acceptRecovery: () => Document | null;
+    dismissRecovery: () => void;
+    isEnabled: Ref<boolean>;
+    enable: () => void;
+    disable: () => void;
+}
+export declare function useAutoSave(document: MaybeRef<Document | null | undefined>, options?: UseAutoSaveOptions): UseAutoSaveReturn;

package/dist/composables/useClipboard.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+import { runsToClipboardContent, ParsedClipboardContent } from '@eigenpal/docx-editor-core/utils';
+import { getSelectionRuns, createSelectionFromDOM, ClipboardSelection, Theme } from '@eigenpal/docx-editor-core';
+export { getSelectionRuns, createSelectionFromDOM, runsToClipboardContent };
+export type { ClipboardSelection };
+export interface UseClipboardOptions {
+    onCopy?: (selection: ClipboardSelection) => void;
+    onCut?: (selection: ClipboardSelection) => void;
+    onPaste?: (content: ParsedClipboardContent, asPlainText: boolean) => void;
+    cleanWordFormatting?: boolean;
+    editable?: boolean;
+    onError?: (error: Error) => void;
+    theme?: Theme | null;
+}
+export interface UseClipboardReturn {
+    copy: (selection: ClipboardSelection) => Promise<boolean>;
+    cut: (selection: ClipboardSelection) => Promise<boolean>;
+    paste: (asPlainText?: boolean) => Promise<ParsedClipboardContent | null>;
+    isProcessing: Ref<boolean>;
+    lastPastedContent: Ref<ParsedClipboardContent | null>;
+}
+export declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturn;

package/dist/composables/useCommentLifecycle.d.ts

@@ -0,0 +1,52 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Document } from '@eigenpal/docx-editor-core/types/document';
+import { Comment } from '@eigenpal/docx-editor-core/types/content';
+import { TrackedChangeEntry } from '../components/sidebar/sidebarUtils';
+export interface UseCommentLifecycleOptions {
+    editorView: Ref<EditorView | null>;
+    getDocument: () => Document | null;
+    comments: Ref<Comment[]>;
+    trackedChanges: Ref<TrackedChangeEntry[]>;
+    resolvedCommentIds: Ref<Set<number>>;
+    activeSidebarItem: Ref<string | null>;
+    showSidebar: Ref<boolean>;
+    isAddingComment: Ref<boolean>;
+    readOnly: Ref<boolean>;
+    zoom: Ref<number>;
+    stateTick: Ref<number>;
+    pagesRef: Ref<HTMLElement | null>;
+    pagesViewportRef: Ref<HTMLElement | null>;
+    emit: (event: string, ...args: unknown[]) => void;
+}
+export declare function useCommentLifecycle(opts: UseCommentLifecycleOptions): {
+    floatingCommentBtn: Ref<{
+        top: number;
+        left: number;
+    } | null, {
+        top: number;
+        left: number;
+    } | {
+        top: number;
+        left: number;
+    } | null>;
+    pendingCommentRange: Ref<{
+        from: number;
+        to: number;
+    } | null, {
+        from: number;
+        to: number;
+    } | {
+        from: number;
+        to: number;
+    } | null>;
+    addCommentYPosition: Ref<number | null, number | null>;
+    sidebarAutoOpenedRef: Ref<boolean, boolean>;
+    extractCommentsAndChanges: () => void;
+    handleAddComment: (text: string) => void;
+    handleCancelAddComment: () => void;
+    handleStartAddComment: () => void;
+    handleMarkerClick: (_commentId: number) => void;
+    recomputeFloatingCommentBtn: () => void;
+    recomputeActiveSidebarItem: () => void;
+};

package/dist/composables/useCommentManagement.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Comment, Document } from '@eigenpal/docx-editor-core/types/document';
+import { TrackedChangeEntry } from '../components/sidebar/sidebarUtils';
+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;
+}
+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;
+    handleCommentUnresolve: (commentId: number) => void;
+    handleCommentDelete: (commentId: number) => void;
+    handleAcceptChange: (from: number, to: number) => void;
+    handleRejectChange: (from: number, to: 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 '@eigenpal/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/useContextMenus.d.ts

@@ -0,0 +1,39 @@
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { ImageLayoutTarget } from '@eigenpal/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/useDocumentLifecycle.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { Document } from '@eigenpal/docx-editor-core/types/document';
+import { DocxInput } from '@eigenpal/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;