@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;

DocumentNamefunctionSource ↗

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

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;

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;

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;

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 ↗

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.

The expanded-sidebar-item highlight styles are computed here from expandedSidebarItem + trackedChanges because they need to live inside the editor-content <div> for proper scoping.

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).

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;

LocaleProviderfunctionSource ↗

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

LogofunctionSource ↗

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

MenuBarfunctionSource ↗

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: {
    currentPage: number;
    totalPages: number;
    visible: boolean;
}): react.JSX.Element;

PaginatedDocxEditorfunctionSource ↗

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

PaginatedDocxEditorShellfunctionSource ↗

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

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 ↗

TitleBar layout (Google Docs style):

┌──────────┬────────────────────────────┬──────────────────┐ │ │ Document Name │ │ │ Logo │ │ Right Actions │ │ │ File Format Insert │ │ └──────────┴────────────────────────────┴──────────────────┘

Logo and TitleBarRight span full height. DocumentName + MenuBar stack vertically in the center column.

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

TitleBarRightfunctionSource ↗

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

ToolbarfunctionSource ↗

Icon-based formatting toolbar — undo/redo, zoom, styles, fonts, bold/italic/underline, colors, alignment, lists, table/image context, clear formatting.

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

ToolbarButtonfunctionSource ↗

Individual toolbar button with shadcn styling

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

ToolbarGroupfunctionSource ↗

Toolbar button group with modern styling

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([['toolbar.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: defaultFonts }); 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. 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.

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 // On demand: only the families this document names are fetched. const fonts = useFonts(googleFonts());

// On demand, plus brand faces you always want. const fonts = useFonts(googleFonts(), brandFragment);

// Eager, from the bundled substitutes. const fonts = useFonts(defaultFonts());

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

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.

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.

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

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;

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;

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;

useTranslationfunctionSource ↗

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

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

ContextMenuItemPropsinterfaceSource ↗

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

interface ContextMenuItemProps

ContextMenuTableRowPropsinterfaceSource ↗

Props for packaged table context-menu rows.

interface ContextMenuTableRowProps extends ContextMenuCommandProps

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

DocxEditorPageSetupDialogPropsinterfaceSource ↗

Props for DocxEditor.PageSetupDialog.

interface DocxEditorPageSetupDialogProps

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

DocxEditorRootPropsinterfaceSource ↗

Props for DocxEditor.Root. Creation parameters (document, fonts, author, locale, and the initial mode/zoom) are sampled when the instance is created; only document and fonts identity remount it. Later mode and zoom changes flow through Editor.setZoom so edits, the caret, and the undo history survive.

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

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

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 four 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

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

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

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

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

ToolbarPartComponentinterfaceSource ↗

interface ToolbarPartComponent

ToolbarPropsinterfaceSource ↗

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

UseParagraphIndentReturninterfaceSource ↗

What useParagraphIndent returns.

interface UseParagraphIndentReturn

UseParagraphStyleResultinterfaceSource ↗

What useParagraphStyle answers.

interface UseParagraphStyleResult

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];

DocxFontsInputtypeSource ↗

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

type DocxFontsInput = FontConfiguration | FontConfigurationFragment;

DocxFontsSourcetypeSource ↗

How a host supplies fonts: a value, a promise, or a function returning either.

The function form is the useful one — { fonts: defaultFonts } from @docx-editor.dev/fonts — because it defers the work until the hook actually runs it.

type DocxFontsSource = DocxFontsInput | Promise<DocxFontsInput> | (() => DocxFontsInput | Promise<DocxFontsInput>);

DocxSourcetypeSource ↗

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

type DocxSource = string | URL | Uint8Array | ArrayBuffer;

EditorModetypeSource ↗

type EditorMode = 'edit' | 'view';

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).

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';

MenuIdtypeSource ↗

A menu's identity: one of the registry's four, 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 & {});

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];

ToolbarPartPropstypeSource ↗

Props for the named parts (DocxEditorToolbar.Bold, ...): the slot is pinned.

type ToolbarPartProps = Omit<ToolbarButtonProps$1, 'slot'>;

ToolbarTranslatetypeSource ↗

Resolves an i18n key to display text.

type ToolbarTranslate = (key: string) => string;

CONTENT_CONTROL_SLOTSconstSource ↗

Chrome slots for the content-control group (design S14).

CONTENT_CONTROL_SLOTS: {
    readonly showAll: "contentControl.showAll";
    readonly formFill: "contentControl.formFill";
    readonly inspector: "contentControl.inspector";
    readonly remove: "contentControl.remove";
}

ContextMenuCopyconstSource ↗

Copy the selection. Stays available in a read-only document.

ContextMenuCopy: (({ icon, labelKey, shortcutKey, className, hidden }: ContextMenuCommandProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuCutconstSource ↗

Cut the selection to the clipboard. Disabled with the engine's reason when nothing is selected.

ContextMenuCut: (({ icon, labelKey, shortcutKey, className, hidden }: ContextMenuCommandProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuDeleteconstSource ↗

Delete the selection.

ContextMenuDelete: (({ icon, labelKey, shortcutKey, className, hidden }: ContextMenuCommandProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuDeleteTableconstSource ↗

Delete the entire table.

ContextMenuDeleteTable: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuDeleteTableColumnconstSource ↗

Delete the current table column.

ContextMenuDeleteTableColumn: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuDeleteTableRowconstSource ↗

Delete the current table row.

ContextMenuDeleteTableRow: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuInsertColumnLeftconstSource ↗

Insert a column to the left of the current column.

ContextMenuInsertColumnLeft: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuInsertColumnRightconstSource ↗

Insert a column to the right of the current column.

ContextMenuInsertColumnRight: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuInsertRowAboveconstSource ↗

Insert a row above the current table row.

ContextMenuInsertRowAbove: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuInsertRowBelowconstSource ↗

Insert a row below the current table row.

ContextMenuInsertRowBelow: (({ icon, labelKey, className, hidden, destructive }: ContextMenuTableRowProps) => react.JSX.Element | null) & {
    docxRow: string;
}

ContextMenuSelectAllconstSource ↗

Select the whole body.

ContextMenuSelectAll: (({ icon, labelKey, shortcutKey, className, hidden }: ContextMenuCommandProps) => react.JSX.Element | null) & {
    docxRow: string;
}

DocxEditorconstSource ↗

DocxEditor: DocxEditorNamespace

DocxEditorContentControlconstSource ↗

DocxEditorContentControl: DocxEditorContentControlNamespace

DocxEditorHyperLinkconstSource ↗

DocxEditorHyperLink: DocxEditorHyperLinkNamespace

DocxEditorLoadingconstSource ↗

Renders its children while the editor is still waiting for a document, and nothing once one is available. No condition to wire up in the common case:

tsx <DocxEditor.Root document={bytes}> <DocxEditor.Loading> <MySpinner /> </DocxEditor.Loading> <DocxEditor.Viewport> <DocxEditor.Content /> </DocxEditor.Viewport> </DocxEditor.Root>

It clears as soon as bytes are handed over — NOT when pages finish painting — so it is safe to gate a DocxEditor.Content on, and an unmounted viewport does not bring it back. A parse failure clears it too, so a broken document never spins forever; report that from snapshot().parseError or the error event. Add when only for async the editor cannot observe, typically a host that mounts the provider after its own fetch.

Rendered OUTSIDE a DocxEditor.Root it always shows, because there is no editor to report otherwise — the same rule useEditorState documents for a null editor. Place it inside the provider unless a permanently-visible placeholder is what you want.

Carries its own docx-editor, so the theme tokens resolve wherever it is composed.

DocxEditorLoading: DocxEditorLoadingComponent

DocxEditorMenuconstSource ↗

The compound menu bar: <DocxEditor.Menu/> for File · Format · Insert · Help, parts as statics for composition.

Every actionable row is a chrome slot, so a row and its toolbar twin share one label, one icon, one command and one enabled state. Rows the engine cannot honour yet render present and disabled, carrying the engine's own reason.

DocxEditorMenu: DocxEditorMenuNamespace

DocxEditorToolbarconstSource ↗

The compound toolbar: <DocxEditor.Toolbar/> for the full working chrome, parts as statics for composition (<DocxEditor.Toolbar><DocxEditor.Toolbar.Bold/>...).

DocxEditorToolbar: DocxEditorToolbarNamespace

NAVIGATION_PANE_GAPconstSource ↗

Clearance kept between the panel's right edge and the page.

NAVIGATION_PANE_GAP = 16

NAVIGATION_PANE_INSETconstSource ↗

Gap between the viewport's left edge and the panel.

Clears a vertical ruler: RULER_WIDTH is 20px pinned at the viewport's left edge, so anything less puts the panel and its collapsed disc on top of the tick marks.

NAVIGATION_PANE_INSET = 32

NAVIGATION_PANE_WIDTHconstSource ↗

Panel width, in px, when the host does not choose one.

NAVIGATION_PANE_WIDTH = 280

ReviewRailContextconstSource ↗

ReviewRailContext: react.Context<ReviewRailRegistry | null>

RULER_WIDTHconstSource ↗

RULER_WIDTH = 20

SEARCH_DEBOUNCE_MSconstSource ↗

Milliseconds of quiet before a typed query is run against the document.

SEARCH_DEBOUNCE_MS = 150

SEARCH_MATCH_LIMITconstSource ↗

The engine's cap on one search. A full result array means "at least this many"; the hook reports that as [UseDocumentSearchResult.truncated](UseDocumentSearchResult.truncated).

SEARCH_MATCH_LIMIT = 2000

VERSIONconstSource ↗

docx-editor.dev/react

React adapter for the DOCX editor. A thin renderer over the Editor contract from @docx-editor.dev/core: it supplies DOM and paints the engine's positioned display list, and holds no editing-engine state.

VERSION = "0.0.2"

ContextMenuCellVerticalAlignmentnamespaceSource ↗

declare namespace ContextMenuCellVerticalAlignment

ContextMenuPastenamespaceSource ↗

declare namespace ContextMenuPaste

ImageAltTextnamespaceSource ↗

declare namespace ImageAltText

ImageInsertTriggernamespaceSource ↗

declare namespace ImageInsertTrigger

ImagePropertiesTriggernamespaceSource ↗

declare namespace ImagePropertiesTrigger

ImageWrapnamespaceSource ↗

declare namespace ImageWrap