ooxml-ui 0.27.2 → 0.28.0

package/dist/controls.js

@@ -1,4 +1,4 @@
-export { CONTROL_DEFINERS, DEFAULT_OFFICE_PROFILE, EMPTY_MENU_STATE, OFFICE_AVATAR_SWATCHES, OFFICE_PROFILE_STORAGE_KEY, OFFICE_TITLE_BAR_SEARCH_LIMIT, OFFICE_TOAST_VISIBLE_LIMIT, assignKeyTips, attachKeyTips, clampFlyoutPosition, clampOptionNumber, clearOfficeProfile, createRibbonOverflow, defineAccount, defineBackstage, defineButton, defineCheckbox, defineCommandSearch, defineContextMenu, defineDialog, defineDialogFooter, defineFindBar, defineGallery, defineIcon, defineMenuButton, defineMenuItem, defineMenuSeparator, defineOptionsDialog, definePasteOptions, definePrintPreview, defineRadio, defineReadOnlyBanner, defineRibbon, defineRibbonGroup, defineRibbonSection, defineRibbonStack, defineRibbonToggle, defineRuler, defineSearchField, defineSelect, defineStatusBar, defineStatusItem, defineSwitch, defineTabStrip, defineTitleBar, defineToasts, defineToolbar, defineZoomSlider, nextEnabledIndex, parseSvgPreview, profileInitials, readOfficeProfile, registerControls, rulerDivisions, runKeyTips, sanitizeOfficeProfile, typeAheadIndex, writeOfficeProfile } from './chunk-4PBFBPOH.js';
+export { CONTROL_DEFINERS, DEFAULT_OFFICE_PROFILE, EMPTY_MENU_STATE, OFFICE_AVATAR_SWATCHES, OFFICE_PROFILE_STORAGE_KEY, OFFICE_TITLE_BAR_SEARCH_LIMIT, OFFICE_TOAST_VISIBLE_LIMIT, assignKeyTips, attachKeyTips, clampFlyoutPosition, clampOptionNumber, clearOfficeProfile, createRibbonOverflow, defineAccount, defineBackstage, defineButton, defineCheckbox, defineCommandSearch, defineContextMenu, defineDialog, defineDialogFooter, defineFindBar, defineGallery, defineIcon, defineMenuButton, defineMenuItem, defineMenuSeparator, defineOptionsDialog, definePasteOptions, definePrintPreview, defineRadio, defineReadOnlyBanner, defineRibbon, defineRibbonGroup, defineRibbonSection, defineRibbonStack, defineRibbonToggle, defineRuler, defineSearchField, defineSelect, defineStatusBar, defineStatusItem, defineSwitch, defineTabStrip, defineTitleBar, defineToasts, defineToolbar, defineZoomSlider, nextEnabledIndex, parseSvgPreview, profileInitials, readOfficeProfile, registerControls, rulerDivisions, runKeyTips, sanitizeOfficeProfile, typeAheadIndex, writeOfficeProfile } from './chunk-G4ZGQYBH.js';
 import './chunk-HZ422LTR.js';
 import './chunk-V6W5DKJ6.js';
 import './chunk-ZWBP2WTC.js';

package/dist/docx/backstage-home.d.ts

@@ -0,0 +1,3 @@
+import type { PageContext } from './backstage-pages';
+/** A local-file start page, following the Office viewers' File navigation. */
+export declare function renderHome({ handlers, t, content }: PageContext): void;

package/dist/docx/backstage-options.d.ts

@@ -0,0 +1,13 @@
+import type { PageContext } from './backstage-pages';
+export interface BackstageOptions {
+    locale: string;
+    theme: string;
+    author: string;
+    spellCheck?: boolean;
+    showRuler?: boolean;
+    showMarks?: boolean;
+    showThumbnails?: boolean;
+}
+export type BackstageOptionKey = keyof BackstageOptions;
+/** Editor preferences share the same live controls as the ribbon. */
+export declare function renderOptions({ handlers, t, content }: PageContext): void;

package/dist/docx/backstage-pages.d.ts

@@ -0,0 +1,41 @@
+import { PROPERTY_FIELDS, type DocumentModel } from 'ooxml-core/docx';
+import type { DocumentStats } from 'ooxml-core/docx';
+import type { FileCommand } from './file-commands';
+import type { BackstageOptions, BackstageOptionKey } from './backstage-options';
+export { renderOptions } from './backstage-options';
+/** What the File view needs from the editor; every value is read when a page opens. */
+export interface BackstageHandlers {
+    fileCommand(command: FileCommand, fileName?: string): void;
+    close(): void;
+    summary(): {
+        fileName: string;
+        model: DocumentModel;
+        words: number;
+        stats: DocumentStats;
+        saveState: string;
+    };
+    options(): BackstageOptions;
+    setOption(key: BackstageOptionKey, value: string): void;
+    /** Sets a document property (title, author, tags...); an empty value clears it. */
+    setProperty(key: (typeof PROPERTY_FIELDS)[number], value: string): void;
+    /** The ribbon element, for listing its commands on Customize Ribbon. */
+    ribbon(): HTMLElement | undefined;
+    hiddenActions(): readonly string[];
+    setHiddenActions(ids: string[]): void;
+}
+export interface PageContext {
+    handlers: BackstageHandlers;
+    t(text: string): string;
+    content: HTMLElement;
+}
+export declare function renderInfo({ handlers, t, content }: PageContext): void;
+export declare function renderNew({ handlers, t, content }: PageContext): void;
+export declare function renderOpen({ handlers, t, content }: PageContext): void;
+export declare function renderSaveAs({ handlers, t, content }: PageContext): void;
+export declare function renderPrint({ handlers, t, content }: PageContext): void;
+export declare function renderExport({ handlers, t, content }: PageContext): void;
+/**
+ * Word's Customize Ribbon, reduced to showing and hiding: every tab, group and command with a
+ * checkbox. Unchecked commands go into `hiddenActions`; groups and tabs left empty disappear.
+ */
+export declare function renderCustomize({ handlers, t, content }: PageContext): void;

package/dist/docx/backstage.d.ts

@@ -0,0 +1,18 @@
+import { type BackstageHandlers } from './backstage-pages';
+export type { BackstageHandlers } from './backstage-pages';
+export type BackstagePage = 'home' | 'info' | 'new' | 'open' | 'saveAs' | 'print' | 'export' | 'options' | 'customize';
+export interface Backstage {
+    element: HTMLElement;
+    open(page?: BackstagePage): void;
+    close(): void;
+    readonly isOpen: boolean;
+    /** Retranslates the navigation after the editor locale changed, and redraws the open page. */
+    relocalize(): void;
+}
+/**
+ * Word's File view. Left: Back, Info, New, Open, Save and its siblings (Save As, Print, Export)
+ * and Options; right: the selected page. Info shows properties and compatibility notes, Save As
+ * takes a file name, Export offers PDF (through printing), DOCX and plain text, and Options sets
+ * the editor's language, theme and review author.
+ */
+export declare function createBackstage(handlers: BackstageHandlers): Backstage;

package/dist/docx/binding-labels.d.ts

@@ -0,0 +1,9 @@
+import type { LocalizationKey } from './localization';
+/**
+ * Labels for the editor's ProseMirror key bindings. The help dialog lists exactly the bindings that
+ * have a label here, and ribbon tooltips append the same keys ("Bold (Ctrl+B)"), so a shortcut is
+ * documented in one place. A label that is also a ribbon control's English name links the two.
+ */
+export declare const EDITOR_BINDING_LABELS: Record<string, LocalizationKey>;
+/** The shortcut for a ribbon control's English label, formatted for the platform, if it has one. */
+export declare function shortcutHint(label: string, mac?: boolean): string | undefined;

package/dist/docx/bookmark-commands.d.ts

@@ -0,0 +1,20 @@
+import type { EditorView } from 'prosemirror-view';
+export declare const MAX_BOOKMARK_LENGTH = 40;
+export type BookmarkNameProblem = 'empty' | 'start' | 'characters' | 'length';
+/**
+ * Word's bookmark naming rule: a letter first, then letters, digits and underscores, at most 40
+ * characters, no spaces. Returns the first rule the name breaks, or null when it is valid.
+ */
+export declare function bookmarkNameProblem(name: string): BookmarkNameProblem | null;
+/** Bookmark names in document order. */
+export declare function listBookmarks(view: EditorView): string[];
+/**
+ * Word's Bookmark > Add: puts `name` on the paragraph holding the selection. A bookmark of the
+ * same name (compared without regard to case) elsewhere moves here, as in Word. Returns
+ * `added`, `moved`, or the naming problem.
+ */
+export declare function addBookmark(view: EditorView, name: string): 'added' | 'moved' | BookmarkNameProblem | 'unavailable';
+/** Bookmark > Delete: removes the named bookmark. Returns whether it existed. */
+export declare function deleteBookmark(view: EditorView, name: string): boolean;
+/** Bookmark > Go To: puts the caret at the bookmark's paragraph and scrolls to it. */
+export declare function goToBookmark(view: EditorView, name: string): boolean;

package/dist/docx/bookmark-dialog.d.ts

@@ -0,0 +1,4 @@
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Word's Bookmark dialog: name a bookmark for the current paragraph, or go to or delete one. */
+export declare function createBookmarkDialog(getView: () => EditorView | undefined): FormatDialog;

package/dist/docx/borders-dialog.d.ts

@@ -0,0 +1,4 @@
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Word's Borders and Shading dialog for paragraphs: sides, one pen (style, width, colour) and a fill. */
+export declare function createBordersDialog(getView: () => EditorView | undefined): FormatDialog;

package/dist/docx/canvas-measurer.d.ts

@@ -0,0 +1,7 @@
+import { type TextMeasurer } from 'ooxml-core/docx/layout';
+/**
+ * Browser measurer backed by an offscreen `<canvas>` 2D context. Falls back to
+ * the fake measurer's formula if no canvas is available (SSR, jsdom without
+ * canvas support), so callers never need to branch on environment.
+ */
+export declare function createCanvasMeasurer(): TextMeasurer;

package/dist/docx/caption-commands.d.ts

@@ -0,0 +1,31 @@
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+/** Word's built-in caption labels; the SEQ identifier is the English label. */
+export declare const CAPTION_LABELS: readonly ['Figure', 'Table', 'Equation'];
+export type CaptionLabel = (typeof CAPTION_LABELS)[number];
+export declare const seqInstruction: (label: string) => string;
+/** The label a text node's field numbers (`Figure` for `SEQ Figure ...`), or undefined. */
+export declare function seqLabelOf(node: ProseMirrorNode): string | undefined;
+/**
+ * Renumbers every `SEQ label` field in document order from 1, as Word's Update Field does, so a
+ * caption inserted in the middle shifts the ones after it. Returns the transaction for chaining.
+ */
+export declare function renumberCaptions(tr: Transaction, label: string): Transaction;
+export interface CaptionOptions {
+    /** Label identifier, e.g. `Figure`. */
+    label: string;
+    /** The label as shown in the document language, e.g. `Abbildung`. */
+    labelText: string;
+    /** Text after the number (`Figure 1: text`). */
+    text: string;
+    position: 'above' | 'below';
+    /** The document's Caption style id, if it has one. */
+    style?: string;
+}
+/**
+ * Insert > Caption: a paragraph "Label N" (N is a `SEQ` field) with optional text, placed above
+ * or below the block holding the selection, then every caption of that label is renumbered.
+ * Without a Caption style the text is italic. Returns false for a read-only view.
+ */
+export declare function insertCaption(view: EditorView, options: CaptionOptions): boolean;

package/dist/docx/caption-dialog.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Word's Caption dialog: a label, its numbered `SEQ` field and optional text, above or below. */
+export declare function createCaptionDialog(getView: () => EditorView | undefined, getModel: () => DocumentModel): FormatDialog;

package/dist/docx/change-case.d.ts

@@ -0,0 +1,5 @@
+import type { EditorView } from 'prosemirror-view';
+import { type CaseMode } from 'ooxml-core/docx';
+export type { CaseMode } from 'ooxml-core/docx';
+/** Rewrites the case of the selected text, keeping each run's marks. Returns false when nothing changed. */
+export declare function changeCase(view: EditorView, mode: CaseMode): boolean;

package/dist/docx/character-style-picker.d.ts

@@ -0,0 +1,12 @@
+import type { EditorView } from 'prosemirror-view';
+import type { DocumentModel } from 'ooxml-core/docx';
+import { type EditorLocale } from './localization';
+/** The character style (`w:rStyle`) at the start of the selection, or '' when none applies. */
+export declare function characterStyleAtSelection(view: EditorView): string;
+/** Applies (or with '' removes) a character style on the selection, or for the next typed text. */
+export declare function applyCharacterStyle(view: EditorView, styleId: string): boolean;
+/**
+ * Keeps a "Character style" select beside the paragraph style picker. Changes are raised as a
+ * `characterStyle` ribbon action so the editor applies them to its current view.
+ */
+export declare function syncCharacterStylePicker(toolbar: HTMLElement, view: EditorView, model: DocumentModel, locale: EditorLocale): void;

package/dist/docx/chrome-icons.d.ts

@@ -0,0 +1,25 @@
+/** Small inline SVG icons for the window chrome, drawn with `currentColor` so they follow the theme. */
+declare const paths: {
+    readonly save: 'M4 3h9l3 3v11H4z M7 3v4h6V3 M7 17v-5h6v5';
+    readonly undo: 'M8 5 4 9l4 4 M4 9h8a4 4 0 0 1 0 8H9';
+    readonly redo: 'M12 5l4 4-4 4 M16 9H8a4 4 0 0 0 0 8h3';
+    readonly search: 'M9 4a5 5 0 1 0 0 10A5 5 0 0 0 9 4z M13 13l4 4';
+    readonly comment: 'M4 4h12v9H9l-4 3v-3H4z';
+    readonly back: 'M12 4 6 10l6 6';
+    readonly file: 'M6 3h6l4 4v10H6z M12 3v4h4';
+    readonly folder: 'M3 6h5l2 2h7v8H3z';
+    readonly copy: 'M7 7h9v10H7z M4 4h9v2 M4 4v10h2';
+    readonly print: 'M6 8V3h8v5 M4 8h12v6h-2 M6 12h8v5H6z';
+    readonly info: 'M10 3a7 7 0 1 0 0 14 7 7 0 0 0 0-14z M10 9v4 M10 6.5v.5';
+    readonly warning: 'M10 3 2 17h16z M10 8v4 M10 14.5v.5';
+    readonly pageView: 'M5 3h10v14H5z M8 7h4 M8 10h4';
+    readonly webView: 'M3 5h14v10H3z M3 8h14';
+    readonly settings: 'M10 7a3 3 0 1 0 0 6 3 3 0 0 0 0-6z M10 2v2 M10 16v2 M2 10h2 M16 10h2 M4.3 4.3l1.4 1.4 M14.3 14.3l1.4 1.4 M15.7 4.3l-1.4 1.4 M5.7 14.3l-1.4 1.4';
+    readonly minus: 'M5 10h10';
+    readonly plus: 'M5 10h10 M10 5v10';
+};
+export type ChromeIcon = keyof typeof paths;
+export declare function icon(name: ChromeIcon): SVGSVGElement;
+/** An icon button whose accessible name is `label` (localized later by `localizeElement`). */
+export declare function iconButton(name: ChromeIcon, label: string, className?: string): HTMLButtonElement;
+export {};

package/dist/docx/collaboration-model.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import { CollaborationAuthority, type CollaborationAuthorityConfig } from 'ooxml-core/docx/ui';
+/** Build a reference authority using exactly the shared editor's document schema. */
+export declare function createCollaborationAuthority(model: DocumentModel, options: Omit<CollaborationAuthorityConfig, 'doc'>): CollaborationAuthority;

package/dist/docx/collaboration-session.d.ts

@@ -0,0 +1,18 @@
+import type { EditorView } from 'prosemirror-view';
+import { CollaborationClient, type CollaborationConfig, type StepBatch } from 'ooxml-core/docx/ui';
+import { EditorPresence } from './editor-presence';
+/** One editor's collaboration state: step client, presence and collaborative id generator. */
+export declare class CollaborationSession {
+    private readonly element;
+    private readonly getView;
+    client?: CollaborationClient | undefined;
+    presence?: EditorPresence | undefined;
+    ids?: ((kind: string) => string) | undefined;
+    private sendScheduled;
+    constructor(element: HTMLElement, getView: () => EditorView | undefined);
+    get active(): boolean;
+    start(config: CollaborationConfig): void;
+    stop(): void;
+    /** Coalesces pending steps into one `collaboration-send` event per microtask. */
+    scheduleSend(pending: () => StepBatch | null): void;
+}

package/dist/docx/columns-dialog.d.ts

@@ -0,0 +1,10 @@
+import { type SectionColumns, type SectionProperties } from 'ooxml-core/docx';
+import type { FormatDialog } from './font-dialog';
+export interface ColumnsHost {
+    section(): SectionProperties | undefined;
+    canEdit(): boolean;
+    apply(columns: SectionColumns): void;
+    restoreFocus(): void;
+}
+/** Current-section column settings; width edits adjust the adjacent column as Word does. */
+export declare function createColumnsDialog(host: ColumnsHost): FormatDialog;

package/dist/docx/comment-commands.d.ts

@@ -0,0 +1,21 @@
+import type { Comment } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+/** Wraps the current selection with a `comment` mark carrying a new comment id; returns the new entry. */
+export declare function addComment(view: EditorView, author: string, text: string, idGenerator?: (kind: string) => string): Comment | null;
+/** Removes one comment id from every anchor range that carries it. */
+export declare function removeCommentAnchor(view: EditorView, id: string): void;
+export declare function deleteComment(comments: Comment[], id: string): Comment[];
+export declare function resolveComment(comments: Comment[], id: string, resolved: boolean): Comment[];
+export declare function replyToComment(comments: Comment[], parentId: string, author: string, text: string, idGenerator?: (kind: string) => string): Comment[];
+/** Comment ids anchored at the selection, outermost first (replies are not anchored). */
+export declare function commentIdsAtSelection(view: EditorView): string[];
+/** Where each comment's anchored text starts, in document order. */
+export declare function commentAnchors(view: EditorView): Array<{
+    id: string;
+    from: number;
+}>;
+/**
+ * Review > Previous / Next Comment: moves the caret to the start of the neighbouring commented
+ * text, wrapping around. Returns the comment id it landed on, or null when there are none.
+ */
+export declare function goToComment(view: EditorView, direction: 'previous' | 'next'): string | null;

package/dist/docx/comments-panel.d.ts

@@ -0,0 +1,19 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+export interface CommentsPanelOptions {
+    getModel: () => DocumentModel;
+    canAdd: () => boolean;
+    onAdd: (text: string) => void;
+    onReply: (parentId: string, text: string) => void;
+    onResolve: (id: string, resolved: boolean) => void;
+    onDelete: (id: string) => void;
+    onClose?: () => void;
+}
+export interface CommentsPanelHandle {
+    element: HTMLElement;
+    open(): void;
+    close(): void;
+    refresh(): void;
+    setLocale(locale: string): void;
+    readonly isOpen: boolean;
+}
+export declare function createCommentsPanel(options: CommentsPanelOptions): CommentsPanelHandle;

package/dist/docx/component.d.ts

@@ -0,0 +1,70 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { CollaborationConfig, ClientReceiveResult, StepBatch } from 'ooxml-core/docx/ui';
+import { type EditorTheme, type EditorThemeMode } from 'ooxml-core/docx/ui';
+import { EditorCore, type LoadedDocument } from './editor-core';
+import { DocxEditorApi } from './element-api';
+import { type DocxEditorEventMap } from './events';
+/**
+ * Typed event overloads. Redeclaring the methods hides the inherited ones, so the standard DOM
+ * event map and the string fallback are repeated here.
+ */
+export interface DocxEditorElement {
+    addEventListener<K extends keyof DocxEditorEventMap>(type: K, listener: (this: DocxEditorElement, event: DocxEditorEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: DocxEditorElement, event: HTMLElementEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DocxEditorEventMap>(type: K, listener: (this: DocxEditorElement, event: DocxEditorEventMap[K]) => unknown, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: DocxEditorElement, event: HTMLElementEventMap[K]) => unknown, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export declare class DocxEditorElement extends DocxEditorApi {
+    /** Attributes mirrored to the `locale`, `readOnly`, `fileName`, `reviewAuthor` and `theme` properties. */
+    static get observedAttributes(): string[];
+    protected readonly core: EditorCore;
+    private readonly shellApi;
+    /** Internal seams that in-repo tests reach for; not public API. */
+    private get view();
+    private get inserts();
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    get reviewAuthor(): string;
+    set reviewAuthor(value: string);
+    /** File name shown in the title bar and used for downloads from the built-in File commands. */
+    get fileName(): string;
+    set fileName(value: string);
+    /** `light`, `dark`, or `auto` (default, follows the OS). Reflected to the `theme` attribute. */
+    get theme(): EditorThemeMode;
+    set theme(value: EditorThemeMode);
+    /** Token overrides applied as inline `--dve-*` custom properties on the host. */
+    get themeColors(): Partial<EditorTheme> | undefined;
+    set themeColors(value: Partial<EditorTheme> | undefined);
+    get locale(): string;
+    set locale(value: string);
+    publishPresence(profile: {
+        name: string;
+        color: string;
+    }): import("./presence").PresenceMessage | null;
+    receivePresence(message: unknown): "applied" | "duplicate" | "invalid" | "out-of-order" | "stale" | "wrong-session";
+    leavePresence(): import("./presence").PresenceMessage | null;
+    get documentModel(): DocumentModel | null;
+    set documentModel(value: DocumentModel | null);
+    get readOnly(): boolean;
+    set readOnly(value: boolean);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    load(input: Uint8Array | ArrayBuffer): Promise<void>;
+    setLoadedDocument(session: LoadedDocument): void;
+    /** Join only after loading the authority's matching document snapshot and version. */
+    startCollaboration(config: CollaborationConfig): void;
+    getPendingCollaboration(): StepBatch | null;
+    receiveCollaboration(batch: unknown): ClientReceiveResult['status'];
+    /** Stopping with pending edits requires an explicit discard of the transport queue. */
+    stopCollaboration(discardPending?: boolean): void;
+    private assertDocumentReplaceable;
+    /** Swaps in a new model (and the session that produced it) and invalidates in-flight loads. */
+    private replaceDocument;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'docx-editor': DocxEditorElement;
+    }
+}
+export declare function registerDocxEditor(): void;

package/dist/docx/context-menu-actions.d.ts

@@ -0,0 +1,10 @@
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Cut or copy through the browser's own command so ProseMirror's clipboard serializer keeps rich
+ * content; the async fallback keeps its HTML slice when that API is available.
+ */
+export declare function copyOrCut(view: EditorView, op: 'cut' | 'copy'): Promise<boolean>;
+/** Whether the browser will let us read the clipboard; `true` when it cannot say. */
+export declare function clipboardReadAllowed(): Promise<boolean>;
+/** Uses ProseMirror's HTML parser for formatted content, with a plain-text API fallback. */
+export declare function pasteClipboard(view: EditorView): Promise<boolean>;

package/dist/docx/context-menu-items.d.ts

@@ -0,0 +1,36 @@
+/** Pure context-menu model: which items appear, and which are disabled, for a given editor state. */
+import type { EditorView } from 'prosemirror-view';
+import type { LocalizationKey } from './localization';
+import type { RibbonAction } from './ribbon-action';
+import { type TableCommand } from './table-commands';
+export type MenuCommand = {
+    kind: 'clipboard';
+    op: 'cut' | 'copy' | 'paste';
+} | {
+    kind: 'removeLink';
+} | {
+    kind: 'ribbon';
+    action: RibbonAction;
+};
+export interface MenuItem {
+    id: string;
+    label: LocalizationKey;
+    command: MenuCommand;
+    disabled: boolean;
+    /** Set when disabled because of the platform, so the UI can say why. */
+    reason?: LocalizationKey;
+    /** Starts a new group; rendered as a separator. */
+    separatorBefore: boolean;
+}
+export interface MenuState {
+    readOnly: boolean;
+    hasSelection: boolean;
+    onLink: boolean;
+    inTable: boolean;
+    /** The browser exposes an async clipboard read API. */
+    canReadClipboard: boolean;
+    canTable(command: TableCommand): boolean;
+}
+/** Items for the current state; table items only exist while the selection is in a table. */
+export declare function computeMenuItems(state: MenuState): MenuItem[];
+export declare function menuStateFromView(view: EditorView, readOnly: boolean): MenuState;

package/dist/docx/context-menu.d.ts

@@ -0,0 +1,25 @@
+import type { EditorView } from 'prosemirror-view';
+import { type EditorLocale } from './localization';
+import type { RibbonAction } from './ribbon-action';
+export interface ContextMenuHost {
+    /** Element the menu is appended to (inside the shadow root, so theme tokens apply). */
+    container: HTMLElement;
+    /** Element whose `contextmenu` events open the menu. */
+    target: HTMLElement;
+    view(): EditorView | undefined;
+    /** Returns focus to the document surface (which may be non-editable). */
+    focusDocument(): void;
+    readOnly(): boolean;
+    locale(): EditorLocale;
+    run(action: RibbonAction): void;
+    warn(message: string): void;
+}
+export interface ContextMenu {
+    readonly isOpen: boolean;
+    readonly element: HTMLElement | undefined;
+    open(x: number, y: number): void;
+    /** Opens at the caret, for Shift+F10 and the ContextMenu key. */
+    openAtCaret(): void;
+    close(restoreFocus?: boolean): void;
+}
+export declare function createContextMenu(host: ContextMenuHost): ContextMenu;

package/dist/docx/contextual-tabs.d.ts

@@ -0,0 +1,8 @@
+import type { EditorState } from 'prosemirror-state';
+/** Whether the selection sits inside a table cell. */
+export declare function selectionInTable(state: EditorState): boolean;
+/**
+ * Word shows its table tools only while a table is selected. The tab is added to the tab strip
+ * when the selection enters a table and removed (falling back to Home) when it leaves.
+ */
+export declare function syncContextualTabs(toolbar: HTMLElement, state: EditorState): void;

package/dist/docx/cover-page.d.ts

@@ -0,0 +1,14 @@
+import type { EditorView } from 'prosemirror-view';
+export interface CoverPageText {
+    title: string;
+    subtitle: string;
+    author: string;
+    date: string;
+}
+/**
+ * Insert > Cover Page: a plain centred title page at the top of the document (title, subtitle,
+ * author, date) that pushes the existing content onto the next page. It is one simple design,
+ * not Word's gallery of building blocks. `titleStyle` is the document's Title style id, if it has
+ * one. Returns false for a read-only view.
+ */
+export declare function insertCoverPage(view: EditorView, text: CoverPageText, titleStyle?: string): boolean;

package/dist/docx/cross-reference-commands.d.ts

@@ -0,0 +1,30 @@
+import { type DocumentModel } from 'ooxml-core/docx';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+export type ReferenceKind = 'heading' | 'bookmark' | 'figure' | 'table' | 'equation';
+export type ReferenceContent = 'text' | 'page' | 'label';
+export interface ReferenceTarget {
+    /** What the list shows. */
+    label: string;
+    /** Position of the target paragraph. */
+    pos: number;
+    /** The paragraph's id, for page lookup. */
+    id: string;
+    /** The whole paragraph text. */
+    text: string;
+    /** For a caption: "Figure 3". */
+    numbered?: string;
+    /** An existing bookmark on the paragraph that the field can point at. */
+    bookmark?: string;
+}
+/** Every paragraph of `kind`, in document order: headings, bookmarked paragraphs or captions. */
+export declare function referenceTargets(doc: ProseMirrorNode, model: DocumentModel, kind: ReferenceKind): ReferenceTarget[];
+/** A new hidden `_Ref` bookmark name, the kind Word makes for cross-references. */
+export declare function newReferenceBookmark(existing: readonly string[]): string;
+/**
+ * Insert > Cross-reference: puts a `REF` (text or caption label and number) or `PAGEREF` field
+ * at the selection, pointing at `target`. A paragraph without a bookmark gets a hidden `_Ref`
+ * one in the same undoable step. `pageOf` supplies a page number for `page`. The result text is
+ * computed now; it does not update when the target changes until the field is edited.
+ */
+export declare function insertCrossReference(view: EditorView, target: ReferenceTarget, content: ReferenceContent, pageOf: (id: string) => string | undefined): boolean;

package/dist/docx/cross-reference-dialog.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Word's Cross-reference dialog for headings, bookmarks and numbered captions. */
+export declare function createCrossReferenceDialog(getView: () => EditorView | undefined, getModel: () => DocumentModel, pageOf: (id: string) => string | undefined): FormatDialog;

package/dist/docx/dialog-fields.d.ts

@@ -0,0 +1,22 @@
+/** Small builders for the ribbon's format dialogs (Font, Paragraph). Text stays English until localized. */
+export declare function labelled<T extends HTMLElement>(label: string, control: T): HTMLLabelElement;
+export declare function textInput(options?: {
+    inputMode?: string;
+}): HTMLInputElement;
+/** A text input offering `values` through a native list (Word's editable drop-down). */
+export declare function listInput(values: readonly string[]): {
+    input: HTMLInputElement;
+    list: HTMLDataListElement;
+};
+export declare function numberInput(min: number, max: number, step: number): HTMLInputElement;
+export declare function selectOf(options: ReadonlyArray<readonly [value: string, label: string]>): HTMLSelectElement;
+/** A checkbox row whose text is its accessible name. */
+export declare function checkbox(label: string): {
+    wrapper: HTMLLabelElement;
+    input: HTMLInputElement;
+};
+export declare function fieldset(legend: string, ...children: HTMLElement[]): HTMLFieldSetElement;
+export declare function row(...children: HTMLElement[]): HTMLDivElement;
+export declare function dialogButton(label: string, primary?: boolean): HTMLButtonElement;
+/** A tri-state checkbox: `null` shows the indeterminate mark (the selection mixes values). */
+export declare function setTriState(input: HTMLInputElement, value: boolean | null): void;

package/dist/docx/dialog-shell.d.ts

@@ -0,0 +1,19 @@
+import { type EditorLocale } from './localization';
+/**
+ * The frame every format dialog shares: the shared modal `office-ui-dialog` (focus trap, Escape,
+ * backdrop, heading, return of focus). The dialog's fields are its light-DOM children, styled by
+ * the editor, and its buttons go in `dialogActions`. `title` is the English heading; it is
+ * translated by `localizeDialog`.
+ */
+export declare function createDialogShell(title: string, className: string): HTMLElement;
+/** The action row, placed in the dialog's footer slot. */
+export declare function dialogActions(...buttons: HTMLElement[]): HTMLDivElement;
+export declare const isDialogOpen: (element: HTMLElement) => boolean;
+export declare function setDialogOpen(element: HTMLElement, open: boolean): void;
+/**
+ * Runs `onDismiss` when the user closes the dialog with Escape, the close button or the backdrop,
+ * so the dialog can clean up the way its own Cancel button does.
+ */
+export declare function onDialogDismiss(element: HTMLElement, onDismiss: () => void): void;
+/** Translates the dialog's fields (light DOM) and its heading. */
+export declare function localizeDialog(element: HTMLElement, locale: EditorLocale): void;

package/dist/docx/drop-cap-command.d.ts

@@ -0,0 +1,20 @@
+import type { EditorView } from 'prosemirror-view';
+export type DropCapStyle = 'none' | 'drop' | 'margin';
+export interface DropCapOptions {
+    lines: number;
+    distanceTwips?: number;
+    fontFamily?: string;
+}
+/** Current frame settings, or the body font for a new initial. */
+export declare function readDropCap(view: EditorView): {
+    style: DropCapStyle;
+    lines: number;
+    distanceTwips: number;
+    fontFamily: string;
+} | undefined;
+/**
+ * Insert > Drop Cap. Like Word, the first letter of the paragraph moves into its own frame
+ * paragraph (`w:framePr`) placed before it; None folds the letter back. Choosing a style on a
+ * paragraph that already has a frame only restyles the frame.
+ */
+export declare function setDropCap(view: EditorView, style: DropCapStyle, options?: DropCapOptions): boolean;

package/dist/docx/drop-cap-dialog.d.ts

@@ -0,0 +1,4 @@
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Word's position, font, height and text-distance controls for the selected initial. */
+export declare function createDropCapDialog(getView: () => EditorView | undefined): FormatDialog;

package/dist/docx/editor-attributes.d.ts

@@ -0,0 +1,26 @@
+import { type EditorThemeMode } from 'ooxml-core/docx/ui';
+/**
+ * Attribute <-> property mapping for `<docx-editor>`. Properties stay the source of truth: an
+ * attribute change is applied through the property setter only when it would change the value, and
+ * a property change is written back to its attribute only when the attribute would differ. That
+ * makes each direction idempotent, so the two cannot ping-pong.
+ */
+export declare const DOCX_EDITOR_ATTRIBUTES: readonly ['locale', 'read-only', 'file-name', 'review-author', 'theme', 'show-thumbnails', 'show-toolbar'];
+export type DocxEditorAttribute = (typeof DOCX_EDITOR_ATTRIBUTES)[number];
+export declare const DEFAULT_FILE_NAME = "Document1.docx";
+export declare const DEFAULT_REVIEW_AUTHOR = "Author";
+/** The element properties the attributes drive. */
+export interface AttributeProperties {
+    locale: string;
+    readOnly: boolean;
+    fileName: string;
+    reviewAuthor: string;
+    theme: EditorThemeMode;
+    showThumbnails: boolean;
+    showToolbar: boolean;
+}
+export declare function isDocxEditorAttribute(name: string): name is DocxEditorAttribute;
+/** attributeChangedCallback body: attribute -> property. */
+export declare function applyAttribute(target: AttributeProperties, name: DocxEditorAttribute, value: string | null): void;
+/** Property setter tail: property -> attribute. No-op where the element has no DOM (SSR). */
+export declare function reflectAttribute(element: Element, name: DocxEditorAttribute, value: string | boolean): void;