@docx-editor.dev/react

ContextMenuCellVerticalAlignmentfunctionSource ↗

Compact vertical-alignment picker for selected table cells.

declare function ContextMenuCellVerticalAlignment(input: ContextMenuCommandProps): react.JSX.Element | null;

ContextMenuItemfunctionSource ↗

A host-owned context-menu row, styled and behaved like the packaged ones.

The toolbar's Action for the right-click surface: no slot, no command, no engine wiring — enabled state and the action are the host's, because the engine has no opinion about an action it does not model. Selecting it closes the menu.

declare function ContextMenuItem(input: ContextMenuItemProps): react.JSX.Element;

ContextMenuPastefunctionSource ↗

Paste the clipboard's text at the selection.

THE ROW READS THE CLIPBOARD, not the engine. exec is synchronous and clipboard read is not — it prompts in Chrome and is refused outright by Firefox and Safari — so the read happens here, inside the click that asked for it, where the permission gesture belongs, and the text goes to the engine as an argument.

Nothing can know whether the read will succeed BEFORE it is attempted, so the row starts enabled (when the engine would accept a paste at all) and disables itself, with the browser's own reason, once a read has actually been refused. Guessing the answer up front would either grey out a working Paste on Chrome or advertise a dead one on Safari.

declare function ContextMenuPaste(input: ContextMenuCommandProps): react.JSX.Element | null;

ContextMenuPasteWithoutFormattingfunctionSource ↗

Paste the clipboard's plain text as if typed, whatever richer flavours it holds.

The Cmd+Shift+V twin as a menu row: same clipboard-read contract as [ContextMenuPaste](ContextMenuPaste), routed through the pasteWithoutFormatting command.

declare function ContextMenuPasteWithoutFormatting(input: ContextMenuCommandProps): react.JSX.Element | null;

DocumentNamefunctionSource ↗

Deprecated. Use `<DocxEditor>` document name slot instead.

declare function DocumentName(input: DocumentNameProps): react__default.JSX.Element;

DocxEditorAuthorStylefunctionSource ↗

Declare one author's presentation, while mounted.

Renders nothing. The editor already colours every author from the --doc-review-author-N ramp; this overrides one of them, and leaves the rest where they are. Prop changes re-apply live — pages repaint without a remount, so the caret and undo history stay — and unmounting returns that author to the ramp.

Read who is in the document with useReviewAuthors, and read these declarations back inside a custom review card with useReviewAuthor.

tsx <DocxEditor.Root document={bytes} modules={MODULES}> <DocxEditor.AuthorStyle author="Jess Lin" color="#7c3aed" avatarUrl="/jess.png" /> … </DocxEditor.Root>

declare function DocxEditorAuthorStyle(props: DocxEditorAuthorStyleProps): null;

DocxEditorColorByChangeTypefunctionSource ↗

Colour tracked changes by the TYPE of change instead of by author, while mounted.

The editor colours by author out of the box — Word's own default, so a paragraph three people edited reads as three people. Mount this to opt out: insertions take --doc-revision-insertion and deletions --doc-revision-deletion, whoever proposed them. Renders nothing; unmounting it returns to by-author colouring.

Composed with DocxEditor.AuthorStyle, it also expresses "highlight these reviewers and leave everyone else green and red": the authors you declare keep their own colour, and this puts the rest on the kind colours.

tsx <DocxEditor.Root document={bytes} modules={MODULES}> <DocxEditor.ColorByChangeType /> … </DocxEditor.Root>

declare function DocxEditorColorByChangeType(): null;

DocxEditorContentfunctionSource ↗

The element the engine paints pages into. Must render inside a DocxEditor.Viewport; the facade attaches here and detaches on unmount (stashing the live document bytes, so remounting elsewhere restores the content).

Its centring margin lives in the STYLESHEET, not in an inline style here, and behind :where() so it carries no specificity: a host that places the page itself — inside its own stage, beside its own art — overrides it with a plain class and no !important. An inline style could not be beaten by a class at all, which is exactly the trap that makes a library feel like something to fight.

declare function DocxEditorContent(input: DocxEditorContentProps): react.JSX.Element;

DocxEditorContextMenufunctionSource ↗

The packaged right-click menu over the painted document.

Mounted by default inside DocxEditor.Viewport; contextMenu={false} on DocxEditor removes it. Rendered as a child of the viewport so it finds its own surface, but positioned in client space, so it is never clipped by the scroller.

declare function DocxEditorContextMenu(input: DocxEditorContextMenuProps): react.JSX.Element;

DocxEditorDocumentOutlinefunctionSource ↗

The document outline as a context-fed part (DocxEditor.DocumentOutline): headings from Editor.getOutline(), in document order; clicking one moves the caret to that heading. The panel positions absolutely — give it a position: relative container.

Renders nothing while the editor has no document — a floating panel saying "no headings" about a document that is not there is the same false claim the rulers made.

declare function DocxEditorDocumentOutline(props: DocxEditorDocumentOutlineProps): ReactElement | null;

DocxEditorEquationfunctionSource ↗

Default equation editor mounted by the packaged React host.

declare function DocxEditorEquation(): react.JSX.Element | null;

DocxEditorFontNoticefunctionSource ↗

Word-style font compatibility notice.

Shown when the open document declares font families this platform cannot resolve — not installed, not embedded in the file, not supplied by the app's font configuration — so the text is rendering in a substitute face. Dismissing hides the notice for that set of families; a different document (or a font arriving) changes the set and surfaces it again.

declare function DocxEditorFontNotice(input: DocxEditorFontNoticeProps): react.JSX.Element | null;

DocxEditorHeaderFooterChromefunctionSource ↗

Thin overlay while a header or footer scope is open: region label and contextual options. Mount beside DocxEditor.Content.

declare function DocxEditorHeaderFooterChrome(input: DocxEditorHeaderFooterChromeProps): ReactElement | null;

DocxEditorHorizontalRulerfunctionSource ↗

The horizontal ruler as a context-fed part (DocxEditor.HorizontalRuler): page width, margins and zoom straight from the editor. Left/right margin handles are draggable when the engine supports page-setup writes; the drag previews locally and commits one undoable step on release.

Renders nothing while the editor holds no document — see [selectDocumentAbsent](selectDocumentAbsent).

declare function DocxEditorHorizontalRuler(props: DocxEditorRulerProps): ReactElement | null;

DocxEditorImagePropertiesDialogfunctionSource ↗

Properties dialog for the selected picture.

declare function DocxEditorImagePropertiesDialog(input: DocxEditorImagePropertiesDialogProps): react.JSX.Element | null;

DocxEditorLoadingSpinnerfunctionSource ↗

The packaged spinner, on its own. Exposed because children replaces the default screen wholesale — a host that wants "spinner plus my own label" would otherwise have to hand-copy an internal class name.

Decorative: it carries aria-hidden, so the surrounding live region needs its own text. DocxEditor.Loading supplies a translated one when you pass no children.

declare function DocxEditorLoadingSpinner(input: DocxEditorLoadingSpinnerProps): react.JSX.Element;

DocxEditorNavigationfunctionSource ↗

The document navigation pane — headings and find — over the left gutter.

declare function DocxEditorNavigation(props: DocxEditorNavigationProps): ReactElement;

DocxEditorNotesChromefunctionSource ↗

declare function DocxEditorNotesChrome(input: DocxEditorNotesChromeProps): ReactElement | null;

DocxEditorPageNumberfunctionSource ↗

Floating localized page readout for the active DocxEditor.Viewport.

Render it as a sibling of the viewport inside a positioned wrapper. It appears while a multi-page document scrolls and fades after 600 ms of inactivity.

declare function DocxEditorPageNumber(input: DocxEditorPageNumberProps): react.JSX.Element | null;

DocxEditorPageSetupDialogfunctionSource ↗

Page Setup dialog: size preset, orientation, margins in inches. Reads the section through usePageSetup() and applies the whole form as one undoable command.

declare function DocxEditorPageSetupDialog(input: DocxEditorPageSetupDialogProps): ReactElement | null;

DocxEditorParagraphDialogfunctionSource ↗

The Paragraph dialog. Reads the selection through useParagraphFormat() and applies the whole form as one undoable command.

declare function DocxEditorParagraphDialog(input: DocxEditorParagraphDialogProps): ReactElement | null;

DocxEditorRootfunctionSource ↗

Creates and owns a DocxEditorInstance and provides it to the subtree. Renders no DOM — compose it with DocxEditor.Viewport + DocxEditor.Content for the painted pages, and any hook-built chrome anywhere inside.

declare function DocxEditorRoot(props: DocxEditorRootProps): react.JSX.Element;

DocxEditorShellfunctionSource ↗

Deprecated. Use `<DocxEditor>` from the composition layer instead.

Outer chrome of the editor: i18n + error provider wrappers, the scroll container with its background-click handler, horizontal and vertical rulers, the floating page indicator, document outline panel + toggle button, plus slots for the toolbar, paged-area body, overlays, dialogs, and hidden file inputs.

This shell renders NO review highlight of its own. Marking the active comment or tracked change belongs to the engine, which paints docx-comment-band--active and docx-revision-band--active for the item the caret is in, or for the one an Editor.setActiveReviewItem pin names instead. One source for which item is active, so a host sidebar and the painted document cannot disagree about it.

declare function DocxEditorShell(input: {
    i18n: React.ComponentProps<typeof LocaleProvider>['i18n'];
    isDark?: boolean;
    onEditorError: (error: Error) => void;
    containerRef: React.Ref<HTMLDivElement>;
    scrollContainerRef: React.Ref<HTMLDivElement>;
    editorContentRef: React.Ref<HTMLDivElement>;
    className: string | undefined;
    containerStyle: CSSProperties;
    mainContentStyle: CSSProperties;
    editorContainerStyle: CSSProperties;
    showRuler: boolean;
    readOnlyProp: boolean | undefined;
    showOutline: boolean;
    showOutlineButton: boolean;
    sidebarOpen: boolean;
    minLayoutWidth: number;
    toolbarHeight: number;
    editorScrollLeft: number;
    expandedSidebarItem?: string | null;
    trackedChanges?: readonly TrackedChangeSummary[];
    onScrollContainerMouseDown: (e: React.MouseEvent) => void;
    onEditorBgMouseDown: (e: React.MouseEvent) => void;
    onEditorContextMenu: (e: React.MouseEvent) => void;
    horizontalRulerProps: HorizontalRulerProps;
    verticalRulerProps: VerticalRulerProps$1;
    outlineProps: OutlineProps;
    onToggleOutline: () => void;
    scrollPageInfo: ScrollPageInfo;
    toolbar: ReactNode;
    pagedArea: ReactNode;
    overlays: ReactNode;
    dialogs: ReactNode;
    fileInputs: ReactNode;
}): react.JSX.Element;

DocxEditorVerticalRulerfunctionSource ↗

The vertical ruler as a context-fed part (DocxEditor.VerticalRuler): page height, margins and zoom straight from the editor. Top/bottom margin handles are draggable when the engine supports page-setup writes, committing one undoable step on release.

Renders nothing while the editor holds no document — see [selectDocumentAbsent](selectDocumentAbsent) — and nothing while the page is wider than the viewport: the ruler rides the scroller at content x=0, so a horizontal scroll would carry it out of view, and pinning it instead would paint ticks over page text. Word's web peers drop it on cramped viewports; so does this part, and it returns as soon as the page fits again.

declare function DocxEditorVerticalRuler(props: DocxEditorRulerProps): ReactElement | null;

DocxEditorViewportfunctionSource ↗

The sole scroll container for the painted document. Put DocxEditor.Content inside it; the engine discovers this element by class and manages scrolling against it.

declare function DocxEditorViewport(input: DocxEditorViewportProps): react.JSX.Element;

HorizontalRulerfunctionSource ↗

declare function HorizontalRuler(input: HorizontalRulerProps$1): react__default.ReactElement;

ImageAltTextfunctionSource ↗

Opens a small panel to edit image description (and optional title).

declare function ImageAltText(input: ImageAltTextProps): react.JSX.Element | null;

ImageInsertProviderfunctionSource ↗

declare function ImageInsertProvider(input: ImageInsertProviderProps): react.JSX.Element;

ImageInsertTriggerfunctionSource ↗

Toolbar insert-image control — opens the shared file picker.

declare function ImageInsertTrigger(input: ImageInsertTriggerProps): react.JSX.Element | null;

ImagePropertiesTriggerfunctionSource ↗

Opens the image properties dialog for the selected drawing.

declare function ImagePropertiesTrigger(input: ImagePropertiesTriggerProps): react.JSX.Element | null;

ImageWrapfunctionSource ↗

Wrap-text dropdown presenting all nine Word choices.

declare function ImageWrap(input: ImageWrapProps): react.JSX.Element | null;

isFieldLinkfunctionSource ↗

A field-derived link (a HYPERLINK field's instruction) rather than a typed w:hyperlink. Structurally signalled: the field registry mints every record with no addressable range (paragraphId stays empty), because no w:hyperlink node backs it. The typed editing lane (edit / unlink) can never resolve its id, so chrome offers neither action. Caret dismissal DOES apply: the field is a one-unit atom, and fieldLinkAtCaret resolves the caret onto it (boundary-inclusive) so the panel closes when the caret leaves.

declare function isFieldLink(link: SurfaceHyperlink): boolean;

LocaleProviderfunctionSource ↗

declare function LocaleProvider(input: LocaleProviderProps): react.JSX.Element;

LogofunctionSource ↗

Deprecated. Use `<DocxEditor>` title slots instead.

declare function Logo(input: LogoProps): react__default.JSX.Element;

MenuBarfunctionSource ↗

Deprecated. Use `DocxEditor.Menu` from the composition layer instead.

declare function MenuBar(): react__default.JSX.Element;

NavigationClosefunctionSource ↗

The back arrow that closes the pane.

declare function NavigationClose(input: NavigationPartProps): ReactElement;

NavigationFindfunctionSource ↗

The find panel: a query box, a result counter with previous/next, the match-case and whole-word toggles, and the result list. Selecting a result moves the caret onto the match and reveals its page.

declare function NavigationFind(input: NavigationPartProps): ReactElement;

NavigationHeaderfunctionSource ↗

The pane's title row. With no children it renders the close arrow and the title.

declare function NavigationHeader(input: NavigationPartProps): ReactElement;

NavigationHeadingsfunctionSource ↗

The heading list, indented by outline depth. Clicking a row moves the caret to that heading and brings it into view.

The filter box narrows the list CLIENT-SIDE — it hides rows whose text does not contain what you typed. It is deliberately not the document search: filtering an outline and searching a document are different questions, and the Find tab answers the second one.

declare function NavigationHeadings(input: NavigationPartProps): ReactElement;

navigationPaneReservationfunctionSource ↗

Total left space an open pane needs before the page may start.

declare function navigationPaneReservation(paneWidth?: number): number;

navigationShiftfunctionSource ↗

The viewport's left padding, in px, that puts the page's left edge exactly at reservation — and 0 whenever the gutter is already wide enough.

Returns 0 for a degenerate measurement (a viewport that has not been laid out yet, a document with no page setup) rather than guessing: shifting on a zero measurement would make the pane jump on the first frame and settle on the second.

declare function navigationShift(input: NavigationShiftInput): number;

NavigationTabfunctionSource ↗

One tab button. Children replace the label.

declare function NavigationTab(input: NavigationTabProps): ReactElement;

NavigationTabsfunctionSource ↗

The tab strip. With no children it renders one Tab per tab the pane supports.

A real role="tablist", so arrow keys move between tabs and a screen reader announces the panel each one controls.

declare function NavigationTabs(input: NavigationPartProps): ReactElement;

NavigationTitlefunctionSource ↗

The pane's heading text.

declare function NavigationTitle(input: NavigationPartProps): ReactElement;

NavigationTogglefunctionSource ↗

The collapsed pane's disc button. DocxEditor.Navigation renders one for you while the pane is closed; place it yourself (a toolbar, a menu) with toggle={false} on the root.

declare function NavigationToggle(input: NavigationPartProps): ReactElement;

normalizeImageBytesfunctionSource ↗

Preflight raster bytes for insert/replace. Never allocates from file-supplied dimensions alone.

declare function normalizeImageBytes(bytes: Uint8Array): NormalizedImagePayload;

PageIndicatorfunctionSource ↗

Floating page indicator shown next to the scrollbar while the user scrolls a multi-page document. Wrapped so the {current} of {total} template runs through t(); useTranslation() only works inside <LocaleProvider>, which DocxEditor's own body is not.

declare function PageIndicator(input: PageIndicatorProps): react.JSX.Element;

PaginatedDocxEditorfunctionSource ↗

declare function PaginatedDocxEditor(input: PaginatedDocxEditorProps): react.JSX.Element;

PaginatedDocxEditorShellfunctionSource ↗

Deprecated. Use `<DocxEditor>` from the composition layer instead.

declare function PaginatedDocxEditorShell(input: PaginatedDocxEditorShellProps): react.JSX.Element;

provideDocxEditorfunctionSource ↗

Prepares Root props and listeners while exposing the instance created by that Root. Call this function during render, like a React hook.

declare function useProvidedDocxEditor(options: DocxEditorRootProps): ProvideDocxEditorResult;

reviewGutterfunctionSource ↗

The paddings, in px, the scroll container reserves for the review rail.

Returns the FULL column for a degenerate measurement (a viewport that has not been laid out yet, a document with no page setup) rather than guessing: that is the value the stylesheet fell back to before this measurement existed, so an unmeasured first frame paints exactly as it always did and collapses only once there is a real width to decide by.

declare function reviewGutter(input: ReviewGutterInput): ReviewGutter;

SlotfunctionSource ↗

Renders its single child element with the slot's props merged in.

declare function Slot(input: SlotProps): ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;

TitleBarfunctionSource ↗

Deprecated. Use `<DocxEditor>` from the composition layer instead.

declare function TitleBar(input: TitleBarProps): react__default.JSX.Element;

TitleBarRightfunctionSource ↗

Deprecated. Use `<DocxEditor>` title slots instead.

declare function TitleBarRight(input: TitleBarRightProps): react__default.JSX.Element;

ToolbarfunctionSource ↗

Deprecated. Use `DocxEditor.Toolbar` from the composition layer instead.

declare function Toolbar(explicitProps: ToolbarProps): react__default.JSX.Element;

ToolbarButtonfunctionSource ↗

Deprecated. Use `DocxEditor.Toolbar` button parts instead.

declare function ToolbarButton(input: ToolbarButtonProps): react__default.JSX.Element;

ToolbarGroupfunctionSource ↗

Deprecated. Use `DocxEditor.Toolbar` group parts instead.

declare function ToolbarGroup(input: ToolbarGroupProps): react__default.JSX.Element;

useChromeTranslatefunctionSource ↗

The catalogue-backed resolver for composed chrome, ready to pass as any part's t.

useTranslation().t is keyed by the strict TranslationKey union, which does not assign to the parts' plain-string t props — so before this hook, every composing host hand-wrote the same cast wrapper <DocxEditor> builds internally. This is that wrapper, exported: it resolves through the active LocaleContext catalogue (bundled English by default), with overrides consulted first for key-level renames.

```tsx const MY_LABELS = new Map([['formattingBar.bold', 'Heavy']]); // module-level: stable identity

const t = useChromeTranslate(MY_LABELS); <DocxEditor.Toolbar t={t} /> ```

Keep the overrides Map identity stable (module-level or memoized) — the returned resolver is memoized on it, and an inline new Map(...) re-creates the resolver, and with it every consuming part's props, on each render.

overrides is a Map on purpose: the key is caller input, and an object literal would answer constructor and toString off the prototype chain. Parts pass no params today for overridden keys, so override values are literal strings.

declare function useChromeTranslate(overrides?: ReadonlyMap<string, string>): ChromeTranslate;

useContentControlfunctionSource ↗

Headless content-control chrome. Mount under DocxEditor.Root.

Both the context-provided instance and a local fallback run every render (same order), matching useHyperlinkPopup.

declare function useContentControl(): UseContentControlResult;

useContentControlInstancefunctionSource ↗

Create the content-control chrome state. Used by DocxEditor.Root to publish one shared instance; also usable in tests without the provider.

declare function useContentControlInstance(): UseContentControlResult;

useContextMenuTargetfunctionSource ↗

The element the opening right-click landed on, or null while the menu is closed.

Public so capability packages can render contextual sections — a row that only exists when the press landed on their own painted chrome — without a second listener.

declare function useContextMenuTarget(): HTMLElement | null;

useDocumentOutlinefunctionSource ↗

The document outline's behavior, with no UI attached: the headings, their nesting depth, and the jump. DocxEditor.Navigation.Headings is this hook plus rows; a host that wants a different list takes the hook and renders its own.

declare function useDocumentOutline(): UseDocumentOutlineResult;

useDocumentSearchfunctionSource ↗

The find panel's behavior, with no UI attached.

declare function useDocumentSearch(): UseDocumentSearchResult;

useDocxEditorfunctionSource ↗

The editor instance from the nearest DocxEditor.Root, or null before the Root's mount effect has created it (and outside any Root). Deliberately not a throwing variant: pre-mount is a normal frame every consumer renders through, and the state hooks built on this already answer it with a typed loading snapshot.

declare function useDocxEditor(): DocxEditorInstance | null;

useDocxSourcefunctionSource ↗

Load a document (and optionally fonts) for DocxEditor.

tsx const { document, fonts, error } = useDocxSource(url, { fonts: packagedFonts() }); if (error) return <p>{error.message}</p>; return <DocxEditor document={document} fonts={fonts} />;

FONTS NEVER FAIL THE DOCUMENT. A face that will not load degrades that family to fixed-width measurement — the document still opens, it just paginates less like Word — so a font failure leaves error null and is the loader's to report. A document failure is different: there is nothing to show, so it lands on error.

THE DOCUMENT WAITS FOR THE FONTS, on the eager path. They fetch concurrently, but document stays undefined until fonts have settled — resolved OR failed — because layout MEASURES with them. Handing the editor bytes first paginates the whole document on the fixed fallback and then re-paginates when the real faces arrive, which the reader sees as the text jumping. One slightly longer wait beats a visible reflow. Without a fonts option there is nothing to wait for and the bytes go straight through.

AN ON-DEMAND ORIGIN CANNOT BE WAITED FOR, and this hook does not pretend otherwise. A resolver is answered with the families the file declares, which nothing knows until the engine has parsed it, so holding the bytes back would wait on work that only the bytes can start. document is released at once, fonts is a stable resolver, and the engine re-paginates when the faces land. That one reflow is what buys loading the faces a document uses rather than everything an origin would load up front; { fonts: defaultFonts } is still there when the no-reflow guarantee matters more than the megabytes.

A URL is fetched with the browser's own fetch, exactly as the caller wrote it. Validate it first if it came from user input: this hook adds no allowlist of its own, and inventing one would only give callers a false sense of where the trust boundary is.

declare function useDocxSource(source: DocxSource | null | undefined, options?: UseDocxSourceOptions): UseDocxSourceResult;

useEditorCaretfunctionSource ↗

The caret's paragraph and offset, or null when nothing is placed.

Compared by value, so a consumer re-renders only when the caret actually moves.

tsx const caret = useEditorCaret(); // …later, in a menu row that inserts at where the user was reading: insertCustomNode(editor, citation, attrs, label, caret ? { at: caret } : {});

declare function useEditorCaret(): EditorCaret | null;

useEditorCommandfunctionSource ↗

Bind a chrome slot ('text.bold', 'history.undo', …) or a raw EditorCommand ({ type: 'selectAll' }) to the editor. The result object is identity-stable while its fields are unchanged, so it can sit in dependency arrays and memo props without churn.

declare function useEditorCommand(target: ChromeSlotId | EditorCommand): EditorCommandState;

useEditorEventfunctionSource ↗

Subscribe to an editor event ('change', 'selectionChange', 'error', …) for the lifetime of the component. No-op until the nearest DocxEditor.Root has created the editor; resubscribes automatically when the instance is replaced.

declare function useEditorEvent<E extends keyof EditorEvents>(event: E, handler: EditorEvents[E]): void;

useEditorSnapshotfunctionSource ↗

Re-render the caller whenever the editor commits a change, moves the selection, or republishes display. Returns a counter that changes on each such event, so it can also be used as a dependency.

declare function useEditorSnapshot(editor: Editor | null): number;

useEditorStatefunctionSource ↗

Subscribe to a slice of the editor's read model. Re-renders the component ONLY when selector's result changes (by isEqual, default Object.is).

Before the editor exists — outside a DocxEditor.Root, pre-mount, and on the server — the selector receives a frozen loading snapshot (isLoading: true, page: {current: 0, total: 0}), never null.

declare function useEditorState<T>(selector: (snapshot: EditorSnapshot) => T, isEqual?: (a: T, b: T) => boolean, options?: UseEditorStateOptions): T;

useEditorValueCommandfunctionSource ↗

Bind a value-typed chrome slot (image.wrap, image.altText) to the editor.

declare function useEditorValueCommand(slotId: 'image.wrap'): EditorValueCommandState<ImageWrapTarget>;

useEditorValueCommandfunctionSource ↗

declare function useEditorValueCommand(slotId: 'image.altText'): EditorValueCommandState<string>;

useFontFamilyfunctionSource ↗

The font-family picker's behavior, UI-free.

declare function useFontFamily(): UseFontFamilyResult;

useFontsfunctionSource ↗

Merge font origins into one stable value for DocxEditor.Root's fonts prop.

```tsx // The bundled substitutes: the families this document names, plus its default face. const fonts = useFonts(packagedFonts());

// The same, plus the Google catalog for everything they do not cover. const fonts = useFonts(packagedFonts(), googleFonts());

// Brand faces first, then whatever is left. const fonts = useFonts(brandFragment, packagedFonts());

return <DocxEditor.Root fonts={fonts}>{children}</DocxEditor.Root>; ```

EVERY argument takes the same union, so adding an origin is adding an argument and never a change of shape. Origins compose first-wins in argument order, exactly like composeFontConfiguration: the first argument beats later ones, and any of them beats a substitution for a family some origin supplies directly.

They resolve ONE AFTER ANOTHER, not concurrently, so that each can be told which faces the ones before it already cover and skip fetching them. That costs one extra origin's latency on the critical path and saves a duplicate download — and, for a network origin, a request that would have told a font host which families the document uses for nothing. Order origins cheapest-first.

The returned resolver never changes identity, so the editor is never rebuilt on account of this prop — which also means the arguments are re-read per LOAD rather than per render. Changing them mid-document does not re-resolve fonts; load a document, or remount, for new fonts to take effect.

It is marked (defineFontResolver), so it can itself be an origin of another list or useDocxSource's fonts option without being mistaken for a zero-argument loader.

declare function useFonts(source: FontsInput, ...fragments: readonly (FontConfigurationFragment | undefined)[]): MarkedFontResolver;

useFontsfunctionSource ↗

The uniform form: every position takes the same [FontOrigin](FontOrigin), so composing two resolvers is one extra argument.

A resolver in any position but the first must carry the defineFontResolver mark. The first position keeps the older, looser type so that every call that compiled before this overload existed still compiles.

declare function useFonts(...origins: readonly FontOrigin[]): MarkedFontResolver;

useHeaderFooterStatefunctionSource ↗

Subscribe to getHeaderFooterState() with reference-stable results when unchanged.

declare function useHeaderFooterState(): HeaderFooterState | null;

useHyperlinkPopupfunctionSource ↗

The hyperlink popover's behavior.

Inside a DocxEditor.HyperLink (which the packaged editor mounts by default) this is the SHARED state that compound is driving, so a custom toolbar button and the popover agree. Outside one it is a standalone instance that registers with the engine itself — a host building its own link UI from scratch needs nothing else.

declare function useHyperlinkPopup(): UseHyperlinkPopupResult;

useHyperlinkPopupInstancefunctionSource ↗

A popover instance. active gates ENGINE REGISTRATION only — an instance created inside a provider still exists, it just does not compete for the surface's chrome handlers.

declare function useHyperlinkPopupInstance(active?: boolean): UseHyperlinkPopupResult;

useNavigationPanefunctionSource ↗

The navigation pane's behavior, with no UI attached: open state, the active tab, and the document displacement an open pane is entitled to.

DocxEditor.Navigation calls this and shares the result with its parts. Call it directly to drive a pane of your own.

declare function useNavigationPane(options?: UseNavigationPaneOptions): UseNavigationPaneResult;

useNavigationShiftfunctionSource ↗

The px the chrome is currently displaced by an open navigation pane. 0 when no pane is mounted, when it is closed, and whenever the left gutter was already wide enough.

declare function useNavigationShift(): number;

useNotePropertiesStatefunctionSource ↗

Subscribe to getNotePropertiesState() with reference-stable results when unchanged.

declare function useNotePropertiesState(): NotePropertiesState | null;

useNoteScopeStatefunctionSource ↗

Subscribe to the active note view scope with reference-stable results when unchanged.

declare function useNoteScopeState(): Extract<ViewScope, {
    kind: 'note';
}> | null;

usePageSetupfunctionSource ↗

The section's page setup — size, orientation, margins — plus the command to change it.

Reads snapshot().pageSetup, which is reference-stable across ticks that did not move the section, so a subscriber re-renders only when the page actually changes shape. In a multi-section document it reflects the CARET's section, as Word's ruler does.

declare function usePageSetup(): UsePageSetupReturn;

useParagraphFormatfunctionSource ↗

The selection's paragraph formatting, plus the command to change it.

apply sends ONE setParagraphFormat, so a dialog's worth of changes is one undo step and the page repaints once.

declare function useParagraphFormat(): UseParagraphFormatReturn;

useParagraphIndentfunctionSource ↗

The selection's paragraph indent — left, right, and the signed first line — plus the command to change it.

This is what DocxEditor.HorizontalRuler drives its four handles from. A host that wants its own indent chrome takes the hook and renders whatever it likes; the ruler's drag geometry is separately available as pure functions (dragIndent / handlePosition from the engine).

declare function useParagraphIndent(): UseParagraphIndentReturn;

useParagraphStylefunctionSource ↗

The paragraph-style picker's behavior, UI-free.

declare function useParagraphStyle(): UseParagraphStyleResult;

useReviewAuthorsfunctionSource ↗

Every author the review surface DRAWS, in Word's slot order, with the colour and style each resolves to. [] before an editor or document exists.

Both halves of review: authors of tracked changes first, numbered by where their first change appears, then authors who only commented. One person is one colour across the two. Once assigned, a slot stays with that author for the attached document session.

The complete attached-document roster. An author remains here while the current review view hides their revisions and comments, so reviewer chrome can turn them on again.

The array is reference-stable between changes (the facade caches per layout and colour state), so it is safe as a dependency and under useSyncExternalStore.

Pairs with the declarative components: read the roster here, declare the styling as <DocxEditor.AuthorStyle> elements.

tsx const authors = useReviewAuthors(); authors.map(({ author }) => ( <DocxEditor.AuthorStyle key={author} author={author} color={myTeam[author]?.color} /> ));

declare function useReviewAuthors(): readonly ReviewAuthorInfo[];

useReviewGutterfunctionSource ↗

The gutter the review rail reserves right now: nothing with no rail mounted, and the measured reviewGutter pair otherwise. The one source for the scroll container's paddings and both rulers.

The result is reference-stable — the pure function answers with one of three shared constants — and the hook stores THAT, never the raw width: a resize sweeps through hundreds of widths that all resolve to the same constant, and holding the width as state re-rendered every consumer (the review rail among them) once per pixel. Storing the derived constant lets the state setter bail on identity, so consumers re-render only when the reservation actually flips.

declare function useReviewGutter(): ReviewGutter;

useScopeClassNamefunctionSource ↗

The scope class a chrome part should add to its own root element: the class when nothing above it is scoped, an empty string when something already is.

tsx const scope = useScopeClassName(); <div className={${scope}docx-toolbar} />

Returns a trailing space so it concatenates cleanly, and '' collapses away.

declare function useScopeClassName(): '' | 'docx-editor ';

useScopedChromeAnchorfunctionSource ↗

Attach contextual chrome to a painted story instead of the top of the editor viewport.

The engine owns and may replace everything inside the paginated surface, so React cannot portal controls into a header, footer, or note node. This hook keeps the controls as a sibling overlay and derives only their screen placement from the current painted host.

declare function useScopedChromeAnchor(findAnchor: (viewport: HTMLElement) => HTMLElement | null, placement: AnchorPlacement): ScopedChromeAnchor;

useTableBorderTargetLabelfunctionSource ↗

Resolved label for the active border target in the shared draft.

For custom table chrome that shows the current target name outside the packaged picker.

declare function useTableBorderTargetLabel(): string;

useToolbarContextfunctionSource ↗

The toolbar root's published value. Internal: parts read it, hosts pass props.

declare function useToolbarContext(): ToolbarContextValue;

useToolbarLabelfunctionSource ↗

The label for an i18n key: the host's translation, else the locale catalogue.

declare function useToolbarLabel(): (key: string) => string;

useToolbarLabelForfunctionSource ↗

The label for an i18n key given a host resolver: the host's translation, else the locale catalogue. The toolbar ROOT needs this before it publishes its context, so the resolver is separate from the context read below — a raw key must never reach the DOM.

declare function useToolbarLabelFor(t: ToolbarTranslate | undefined): (key: string) => string;

useTranslationfunctionSource ↗

declare function useTranslation(): {
    t: TFunction;
    catalogue: LocaleStrings;
};

useZoomfunctionSource ↗

Read and drive the document's zoom.

tsx const { zoom, isFit, auto, zoomIn } = useZoom(); <button onClick={auto} aria-pressed={isFit}>Fit</button> <span>{Math.round(zoom * 100)}%</span>

Outside a DocxEditor.Root — and before the editor is created — this reports 100% fixed and every action is a no-op, so a control can render unconditionally.

declare function useZoom(): UseZoomResult;

VerticalRulerfunctionSource ↗

declare function VerticalRuler(input: VerticalRulerProps): react__default.ReactElement;

ContentControlActionPropsinterfaceSource ↗

Props for action parts that also take an icon.

interface ContentControlActionProps extends ContentControlPartProps

ContentControlInspectorStateinterfaceSource ↗

Live inspector model for the control at the caret.

locked is the content-edit axis. Removal lock is reported separately via removalLocked from the boundary's effective lock / surface disabled reason.

interface ContentControlInspectorState

ContentControlPartPropsinterfaceSource ↗

Shared props for every part.

interface ContentControlPartProps

ContentControlPropsinterfaceSource ↗

Props for DocxEditor.ContentControl.

interface ContentControlProps extends ContentControlPartProps

ContextMenuAnchorinterfaceSource ↗

Where the panel opened, in client coordinates.

interface ContextMenuAnchor

ContextMenuCommandPropsinterfaceSource ↗

Props for a packaged context-menu row.

interface ContextMenuCommandProps

ContextMenuContextValueinterfaceSource ↗

interface ContextMenuContextValue

ContextMenuItemPropsinterfaceSource ↗

Props for DocxEditor.ContextMenu.Item: a host-owned row.

interface ContextMenuItemProps

ContextMenuTableRowPropsinterfaceSource ↗

Props for packaged table context-menu rows.

interface ContextMenuTableRowProps extends ContextMenuCommandProps

DocxEditorAuthorStylePropsinterfaceSource ↗

Props for DocxEditor.AuthorStyle: one author, and the [RevisionAuthorStyle](RevisionAuthorStyle) fields to apply — color (document ink and the review chrome's accent), background (the wash), spanClassName (classes on the painted spans), and avatarUrl.

interface DocxEditorAuthorStyleProps extends RevisionAuthorStyle

DocxEditorContentControlNamespaceinterfaceSource ↗

The content-control inspector compound. Parts live on the namespace statics.

interface DocxEditorContentControlNamespace

DocxEditorContentPropsinterfaceSource ↗

Props for DocxEditor.Content.

interface DocxEditorContentProps

DocxEditorContextMenuNamespaceinterfaceSource ↗

DocxEditor.ContextMenu with its rows attached as statics.

interface DocxEditorContextMenuNamespace

DocxEditorContextMenuPropsinterfaceSource ↗

Props for DocxEditor.ContextMenu.

interface DocxEditorContextMenuProps

DocxEditorDocumentOutlinePropsinterfaceSource ↗

Props for the context-fed outline part.

interface DocxEditorDocumentOutlineProps

DocxEditorFontNoticePropsinterfaceSource ↗

Props for DocxEditor.FontNotice.

interface DocxEditorFontNoticeProps

DocxEditorHeaderFooterChromePropsinterfaceSource ↗

Props for DocxEditor.HeaderFooterChrome.

interface DocxEditorHeaderFooterChromeProps

DocxEditorHyperLinkNamespaceinterfaceSource ↗

The link popover compound.

interface DocxEditorHyperLinkNamespace

DocxEditorImagePropertiesDialogPropsinterfaceSource ↗

Props for DocxEditor.ImagePropertiesDialog.

interface DocxEditorImagePropertiesDialogProps

DocxEditorLoadingComponentinterfaceSource ↗

The loading part with the packaged spinner attached as a static.

interface DocxEditorLoadingComponent

DocxEditorLoadingPropsinterfaceSource ↗

Props for DocxEditor.Loading.

interface DocxEditorLoadingProps

DocxEditorLoadingSpinnerPropsinterfaceSource ↗

Props for DocxEditor.Loading.Spinner.

interface DocxEditorLoadingSpinnerProps

DocxEditorMenuNamespaceinterfaceSource ↗

The menu bar with its parts attached as statics.

interface DocxEditorMenuNamespace

DocxEditorMenuPropsinterfaceSource ↗

Props for DocxEditor.Menu.

interface DocxEditorMenuProps

DocxEditorNamespaceinterfaceSource ↗

The composed editor component with its composition primitives attached as statics, so <DocxEditor.Root>, <DocxEditor.Viewport>, and <DocxEditor.Content> work without extra imports.

interface DocxEditorNamespace extends ForwardRefExoticComponent<DocxEditorProps & RefAttributes<DocxEditorRef>>

DocxEditorNavigationNamespaceinterfaceSource ↗

DocxEditor.Navigation with its parts attached as statics.

interface DocxEditorNavigationNamespace

DocxEditorNavigationPropsinterfaceSource ↗

Props for DocxEditor.Navigation.

interface DocxEditorNavigationProps extends UseNavigationPaneOptions

DocxEditorNotesChromePropsinterfaceSource ↗

Props for DocxEditor.NotesChrome.

interface DocxEditorNotesChromeProps

DocxEditorPageNumberPropsinterfaceSource ↗

Props for DocxEditor.PageNumber.

interface DocxEditorPageNumberProps

DocxEditorPageSetupDialogPropsinterfaceSource ↗

Props for DocxEditor.PageSetupDialog.

interface DocxEditorPageSetupDialogProps

DocxEditorParagraphDialogPropsinterfaceSource ↗

Props for DocxEditor.ParagraphDialog.

interface DocxEditorParagraphDialogProps

DocxEditorPropsinterfaceSource ↗

Props for the React DocxEditor. The adapter is a thin renderer over the Editor contract; it holds no editing-engine state of its own and never imports ProseMirror or OOXML feature logic.

interface DocxEditorProps

DocxEditorRefinterfaceSource ↗

The imperative handle, identical on both adapters (enforced by bun run check:parity-contract). Every member forwards to the Editor facade and is safe to call before the editor has mounted — mutations no-op, reads return the honest empty answer (null, a notFound refusal, a loading snapshot) — so a host can hold the ref from first render without guarding it.

The ref deliberately stays small: everything else (zoom, paging, formatting queries, document state) is reachable through the full facade via getEditor, so the ref never mirrors capabilities the Editor contract already names.

interface DocxEditorRef

DocxEditorRootListenersinterfaceSource ↗

Vue-only lifecycle listeners; exported for cross-adapter API parity.

interface DocxEditorRootListeners

DocxEditorRootPropsinterfaceSource ↗

Props for DocxEditor.Root. Only document, fonts, and imageDecodePort identity remounts the editor. Later author, locale, mode, translate, zoom, and zoomMode changes use instance setters. modules is sampled at mount only.

interface DocxEditorRootProps

DocxEditorRulerPropsinterfaceSource ↗

Props for the context-fed ruler parts.

interface DocxEditorRulerProps

DocxEditorToolbarNamespaceinterfaceSource ↗

The toolbar with its parts attached as statics.

interface DocxEditorToolbarNamespace

DocxEditorToolbarPropsinterfaceSource ↗

Props for DocxEditor.Toolbar.

interface DocxEditorToolbarProps

DocxEditorViewportPropsinterfaceSource ↗

Props for DocxEditor.Viewport.

interface DocxEditorViewportProps

EditorCaretinterfaceSource ↗

A caret position: a paragraph and a UTF-16 offset inside it — the shape the write APIs take as their at.

interface EditorCaret

EditorCommandStateinterfaceSource ↗

The live state of one editor control, plus its action.

interface EditorCommandState

EditorValueCommandStateinterfaceSource ↗

Live state for a value-typed toolbar control.

interface EditorValueCommandState<T extends string | number>

FontFamilyItemPropsinterfaceSource ↗

Props for FontFamily.Item.

interface FontFamilyItemProps extends FontFamilyPartProps

FontFamilyNamespaceinterfaceSource ↗

The compound part with its sub-parts attached as statics.

interface FontFamilyNamespace

FontFamilyPartPropsinterfaceSource ↗

Props for DocxEditorToolbar.FontFamily and its sub-parts.

interface FontFamilyPartProps

FontFamilyPropsinterfaceSource ↗

Props for the compound root.

interface FontFamilyProps extends FontFamilyPartProps

HorizontalRulerPropsinterfaceSource ↗

interface HorizontalRulerProps$1

HyperLinkActionPropsinterfaceSource ↗

Props for the action parts, which also take an icon.

interface HyperLinkActionProps extends HyperLinkPartProps

HyperLinkPartPropsinterfaceSource ↗

Shared props for every part.

interface HyperLinkPartProps

HyperlinkPopupAnchorinterfaceSource ↗

Where the popover sits, in viewport coordinates.

interface HyperlinkPopupAnchor

HyperlinkPopupStateinterfaceSource ↗

The popover's observable state.

interface HyperlinkPopupState

HyperLinkPropsinterfaceSource ↗

Props for DocxEditor.HyperLink.

interface HyperLinkProps extends HyperLinkPartProps

ImagePropertiesTriggerPropsinterfaceSource ↗

Props for the toolbar properties trigger.

interface ImagePropertiesTriggerProps

IndentUpdateinterfaceSource ↗

The fields apply accepts — twips throughout, like every other read shape here.

Omitted fields are left as authored; null CLEARS one, so the paragraph falls back to its style. That is a different thing from zero, which blocks the cascade — the same distinction setParagraphSpacing draws.

firstLine is ONE SIGNED offset from the left indent: negative IS the hanging indent. OOXML spells it as two mutually exclusive attributes, and a caller should not have to know which of them wins.

interface IndentUpdate

LocaleProviderPropsinterfaceSource ↗

interface LocaleProviderProps

MenuActionPropsinterfaceSource ↗

Props for the pinned File rows.

interface MenuActionProps

MenuGroupPropsinterfaceSource ↗

Props for DocxEditor.Menu.Group: a titled section of rows.

interface MenuGroupProps

MenuItemPropsinterfaceSource ↗

Props for DocxEditor.Menu.Item: one chrome slot as a menu row.

interface MenuItemProps

MenuPartComponentinterfaceSource ↗

A menu pinned to one registry id, for DocxEditor.Menu.File and friends.

interface MenuPartComponent

MenuPropsinterfaceSource ↗

Props for DocxEditor.Menu.Menu and the five pinned menu parts.

interface MenuProps

MenuReportIssuePropsinterfaceSource ↗

Props for DocxEditor.Menu.ReportIssue.

interface MenuReportIssueProps

MenuRowPropsinterfaceSource ↗

Props for DocxEditor.Menu.Row: one presentational menu row.

interface MenuRowProps

MenuSeparatorPropsinterfaceSource ↗

Props for DocxEditor.Menu.Separator.

interface MenuSeparatorProps

MenuSubmenuPropsinterfaceSource ↗

interface MenuSubmenuProps

MenuTableGridPropsinterfaceSource ↗

Props for DocxEditor.Menu.TableGrid.

interface MenuTableGridProps

NavigationPartPropsinterfaceSource ↗

Shared props for the pane's structural parts.

interface NavigationPartProps

NavigationShiftInputinterfaceSource ↗

interface NavigationShiftInput

NavigationTabPropsinterfaceSource ↗

Props for one tab.

interface NavigationTabProps extends NavigationPartProps

OutlineHeadingIteminterfaceSource ↗

A heading plus how deep to indent it in a rendered list.

interface OutlineHeadingItem

PageIndicatorPropsinterfaceSource ↗

interface PageIndicatorProps

PageSetupUpdateinterfaceSource ↗

The fields apply accepts — twips throughout, like every read shape. Omitted fields are left as authored. scope is Word's "Apply to": 'document' (the default) writes every section, 'section' only the one the selection is in.

interface PageSetupUpdate

PaginatedDocxEditorHandleinterfaceSource ↗

What a host can drive from outside.

Commands only. There is no accessor for the document or the layout, because a caller holding either could act on a revision the model has already left behind.

interface PaginatedDocxEditorHandle

PaginatedDocxEditorPropsinterfaceSource ↗

interface PaginatedDocxEditorProps

PaginatedDocxEditorShellPropsinterfaceSource ↗

interface PaginatedDocxEditorShellProps

ParagraphFormatReadinterfaceSource ↗

What the Paragraph dialog reads: every field, as the selection currently stands.

A null means the selection's paragraphs DISAGREE about that field, which a control shows as an indeterminate checkbox or an empty box rather than as a value. indent is the exception the engine already documents — it reports the first touched paragraph and flags disagreement per field, because a ruler has to draw its handles somewhere.

interface ParagraphFormatRead

ParagraphFormatUpdateinterfaceSource ↗

The fields apply accepts. Omitted fields are left as authored; null where allowed REMOVES the setting so the style supplies it again, which is not the same as a zero.

interface ParagraphFormatUpdate

ParagraphStyleItemPropsinterfaceSource ↗

Props for ParagraphStyle.Item.

interface ParagraphStyleItemProps extends ParagraphStylePartProps

ParagraphStyleNamespaceinterfaceSource ↗

The compound part with its sub-parts attached as statics.

interface ParagraphStyleNamespace

ParagraphStyleOptioninterfaceSource ↗

One pickable paragraph style, as the document defines it.

interface ParagraphStyleOption

ParagraphStylePartPropsinterfaceSource ↗

Props for DocxEditorToolbar.StylePicker and its sub-parts.

interface ParagraphStylePartProps

ParagraphStylePropsinterfaceSource ↗

Props for the compound root.

interface ParagraphStyleProps extends ParagraphStylePartProps

ParagraphTabStopinterfaceSource ↗

One custom tab stop, as a control reads and writes it.

interface ParagraphTabStop

ProvideDocxEditorResultinterfaceSource ↗

Vue-only setup result; exported for cross-adapter API parity.

interface ProvideDocxEditorResult

ReviewGutterinterfaceSource ↗

What the scroll container reserves on each edge, in px.

interface ReviewGutter

ReviewGutterInputinterfaceSource ↗

interface ReviewGutterInput

ReviewRailRegistryinterfaceSource ↗

Whether a review rail is mounted under this Root, and how much room it wants.

The GUTTER is the reason this exists. DocxEditor.Viewport reserves space beside the page for the pane, and the ruler shifts by the same amount — but neither of them can see whether a rail was actually composed in. Keyed on the pane's open state alone, every consumer of the tier-2 <DocxEditor> sugar (which mounts no rail) had its page pushed 158px off centre beside an empty column.

A rail registers on mount and unregisters on unmount, so the reservation follows what is really on screen. Count rather than boolean: StrictMode mounts twice, and a host may legitimately compose two rails.

interface ReviewRailRegistry

ScopedChromeAnchorinterfaceSource ↗

interface ScopedChromeAnchor

SlotPropsinterfaceSource ↗

interface SlotProps extends HTMLAttributes<HTMLElement>

TableBorderColorNamespaceinterfaceSource ↗

Border-colour split compound with a quick-apply main button and swatch dialog (DocxEditor.Toolbar.TableBorderColor).

interface TableBorderColorNamespace extends TableChromePartComponent

TableBorderStyleNamespaceinterfaceSource ↗

Border-style menu compound (DocxEditor.Toolbar.TableBorderStyle).

interface TableBorderStyleNamespace extends TableChromePartComponent

TableBorderTargetNamespaceinterfaceSource ↗

Border-target picker compound (DocxEditor.Toolbar.TableBorderTarget).

interface TableBorderTargetNamespace extends TableChromePartComponent

TableBorderWidthNamespaceinterfaceSource ↗

Border-width menu compound (DocxEditor.Toolbar.TableBorderWidth).

interface TableBorderWidthNamespace extends TableChromePartComponent

TableCellFillNamespaceinterfaceSource ↗

Cell-fill split compound (DocxEditor.Toolbar.TableCellFill).

interface TableCellFillNamespace extends TableChromePartComponent

TableChromeItemPropsinterfaceSource ↗

Props for a value-driven row or swatch inside a table compound menu.

interface TableChromeItemProps extends TableChromePartProps

TableChromePartComponentinterfaceSource ↗

Shared compound contract for menu-style table chrome parts ([TableBorderTargetNamespace](TableBorderTargetNamespace), [TableBorderStyleNamespace](TableBorderStyleNamespace), [TableBorderWidthNamespace](TableBorderWidthNamespace)).

interface TableChromePartComponent extends ToolbarSlotPartComponent

TableChromePartPropsinterfaceSource ↗

Props shared by contextual table toolbar compound parts.

interface TableChromePartProps

ToolbarActionPropsinterfaceSource ↗

Props for DocxEditorToolbar.Action.

interface ToolbarActionProps

ToolbarAlignmentComponentinterfaceSource ↗

The merged part is keyed by its GROUP id — it stands in for all four slots.

interface ToolbarAlignmentComponent

ToolbarButtonPropsinterfaceSource ↗

Props for DocxEditorToolbar.Button.

interface ToolbarButtonProps$1

ToolbarContextValueinterfaceSource ↗

interface ToolbarContextValue

ToolbarPartComponentinterfaceSource ↗

interface ToolbarPartComponent

ToolbarPropsinterfaceSource ↗

Deprecated. Use `DocxEditor.Toolbar` from the composition layer instead.

Props for the Toolbar (formatting rail) component

interface ToolbarProps

ToolbarSeparatorPropsinterfaceSource ↗

Props for DocxEditorToolbar.Separator.

interface ToolbarSeparatorProps

ToolbarSlotPartComponentinterfaceSource ↗

A non-button part pinned to one slot.

interface ToolbarSlotPartComponent

ToolbarSlotPartPropsinterfaceSource ↗

Props for the non-button parts (pickers, steppers, color splits, save).

interface ToolbarSlotPartProps

UseContentControlResultinterfaceSource ↗

What useContentControl answers.

interface UseContentControlResult

UseDocumentOutlineResultinterfaceSource ↗

What useDocumentOutline answers.

interface UseDocumentOutlineResult

UseDocumentSearchResultinterfaceSource ↗

What useDocumentSearch answers.

interface UseDocumentSearchResult

UseDocxSourceOptionsinterfaceSource ↗

Options for [useDocxSource](useDocxSource).

interface UseDocxSourceOptions

UseDocxSourceResultinterfaceSource ↗

What [useDocxSource](useDocxSource) reports.

interface UseDocxSourceResult

UseFontFamilyResultinterfaceSource ↗

What useFontFamily answers.

interface UseFontFamilyResult

UseHyperlinkPopupResultinterfaceSource ↗

What useHyperlinkPopup answers.

interface UseHyperlinkPopupResult

UseNavigationPaneOptionsinterfaceSource ↗

How useNavigationPane is configured.

interface UseNavigationPaneOptions

UseNavigationPaneResultinterfaceSource ↗

What useNavigationPane answers.

interface UseNavigationPaneResult

UsePageSetupReturninterfaceSource ↗

What usePageSetup returns.

interface UsePageSetupReturn

UseParagraphFormatReturninterfaceSource ↗

What useParagraphFormat returns.

interface UseParagraphFormatReturn

UseParagraphIndentReturninterfaceSource ↗

What useParagraphIndent returns.

interface UseParagraphIndentReturn

UseParagraphStyleResultinterfaceSource ↗

What useParagraphStyle answers.

interface UseParagraphStyleResult

UseZoomResultinterfaceSource ↗

What [useZoom](useZoom) answers.

interface UseZoomResult

VerticalRulerPropsinterfaceSource ↗

VerticalRuler Component

A vertical ruler that displays alongside the document with: - Page height scale with tick marks - Top and bottom margin indicators - Optional dragging to adjust margins - Support for zoom levels

Similar to Google Docs' vertical ruler.

interface VerticalRulerProps

ChromeTranslatetypeSource ↗

A chrome-part label resolver: plain string keys, optional interpolation params.

This is the shape every packaged part's t prop accepts. It takes string rather than the TranslationKey union so a host can route its own extra keys through the same resolver.

type ChromeTranslate = (key: string, params?: Record<string, string | number>) => string;

ContentControlLocktypeSource ↗

OOXML content-control lock axis, mirrored from layout boundary records for the React-only inspector surface — adapters must not import the layout package.

type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';

ContentControlSlotIdtypeSource ↗

type ContentControlSlotId = (typeof CONTENT_CONTROL_SLOTS)[keyof typeof CONTENT_CONTROL_SLOTS];

DocxEditorChildrentypeSource ↗

Slot and icon content in public component props.

React hosts pass [ReactNode](ReactNode). Vue hosts pass [VNode](https://vuejs.org/api/utility-types.html#vnode) through the paired [DocxEditorChildren](DocxEditorChildren) alias in @docx-editor.dev/vue.

type DocxEditorChildren = ReactNode;

DocxFontOrigintypeSource ↗

One entry of a fonts list: any [FontOrigin](FontOrigin), or the older zero-argument loader.

The resolver arm of FontOrigin is a MARKED resolver, so handing this a function that takes a request but never went through defineFontResolver is a compile error rather than a silent total loss of fonts — it matches neither arm, because a one-argument function is not assignable to the zero-argument loader.

type DocxFontOrigin = FontOrigin | (() => DocxFontsInput | Promise<DocxFontsInput>);

DocxFontsInputtypeSource ↗

A complete configuration, or a fragment this hook composes with the defaults.

type DocxFontsInput = FontConfiguration | FontConfigurationFragment;

DocxFontsSourcetypeSource ↗

How a host supplies fonts: one origin, or a list of them in precedence order.

packagedFonts() and googleFonts() are the useful ones — they resolve per document, loading a family when the file names it or when it is that file's default face, rather than loading every family they could serve. A list composes them first-wins: { fonts: [packagedFonts(), googleFonts()] } serves the bundled faces and reaches the catalog only for what they do not cover.

The zero-argument loader form ({ fonts: defaultFonts }) still works and still loads everything up front. It is the one form that holds the document back until fonts settle.

type DocxFontsSource = DocxFontOrigin | readonly DocxFontOrigin[];

DocxSourcetypeSource ↗

What the document itself can be: a URL to fetch, or bytes already in hand.

A string here is ALWAYS a URL — this hook exists to fetch one. That is the opposite of the document prop, whose DocumentSource reads the string 'blank' as Word's blank template; useDocxSource('blank') would request ./blank and report the 404. There is nothing to fetch for an empty document, so pass 'blank' straight to document.

type DocxSource = string | URL | Uint8Array | ArrayBuffer;

EditorModetypeSource ↗

type EditorMode = 'edit' | 'view' | 'suggesting';

FontsInputtypeSource ↗

Anything that can describe fonts: a resolved configuration, a bare fragment, a promise for either (what a loader like defaultFonts() returns), or an on-demand [FontResolver](FontResolver) (what packagedFonts() and googleFonts() return).

The resolver arm is BARE FontResolver, unmarked. FontOrigin — what a list position takes — requires the defineFontResolver mark, because a list may also hold a zero-argument loader and only the mark separates the two. There is no such ambiguity in the first argument of [useFonts](useFonts), which has never accepted a loader, so it keeps taking any resolver.

type FontsInput = FontConfiguration | FontConfigurationFragment | FontResolver | Promise<FontConfiguration | FontConfigurationFragment | undefined> | undefined;

HeaderFooterStatetypeSource ↗

Live furniture scope state from Editor.getHeaderFooterState().

type HeaderFooterState = Exclude<ReturnType<Editor['getHeaderFooterState']>, null>;

HyperlinkPopupModetypeSource ↗

What the popover is showing.

type HyperlinkPopupMode = 
/** Not shown. */
'closed'
/** An existing link: its target, plus copy / edit / unlink. */
 | 'reading'
/** Text + URL fields, for a new link or a change to an existing one. */
 | 'editing';

MaybeRefOrGettertypeSource ↗

React composables take plain values; parity name matches the Vue surface.

type MaybeRefOrGetter<T> = T;

MenuIdtypeSource ↗

A menu's identity: one of the registry's five, or a HOST'S OWN.

The (string & {}) arm keeps the registry ids as editor autocomplete while accepting any other string, so a product can add "Review" or "Clauses" without the library having to know about it. Lives here rather than in parts because the bar's open/active state is keyed on it and both modules read that state.

type MenuId = ChromeMenuId | (string & {});

MenuReviewersPropstypeSource ↗

type MenuReviewersProps = {
    className?: string;
    hidden?: boolean;
};

NavigationTabValuetype

The pane's tabs. Word's Replace tab is a later slice; nothing here pretends it exists.

type NavigationTab$1 = 'headings' | 'find';

NormalizedImagePayloadtypeSource ↗

type NormalizedImagePayload = {
    readonly ok: true;
    readonly bytes: Uint8Array;
    readonly mime: SupportedImageMime;
    readonly widthPoints: number;
    readonly heightPoints: number;
} | {
    readonly ok: false;
    readonly reasonKey: string;
};

NotePropertiesStatetypeSource ↗

type NotePropertiesState = Exclude<ReturnType<Editor['getNotePropertiesState']>, null>;

OutlineHeadingtypeSource ↗

One heading of the engine's outline: text, 0-based level, and the block id Editor.scrollToBlock accepts.

type OutlineHeading$1 = ReturnType<Editor['getOutline']>[number];

PaginatedDocxEditorExposetypeSource ↗

Vue name for the same handle contract.

type PaginatedDocxEditorExpose = PaginatedDocxEditorHandle;

ParagraphFlagStatetypeSource ↗