@docx-editor.dev/pro/react

activatedCustomNodeOffunctionSource ↗

The activation every host hook receives: identity, POST-fromDocx attrs, and — when the review module derived a card for the node — its literal text and canonical node id.

One enrichment step for every surface (click, hover, edit, context-menu card), so a hook written against the review rail's attrs shape sees the SAME shape from the chip. Without a review module the definition's fromDocx runs over the raw decode with text: ''; its veto (null) drops the activation, exactly as recognition would have.

declare function activatedCustomNodeOf(resolved: ResolvedCustomNodeActivation, editor: Editor | null | undefined): ActivatedCustomNode | null;

CustomNodeChromefunctionSource ↗

Paints custom-node chips and dispatches pointer activation on them.

Renders nothing itself — it installs the chip styles and the activation listeners, so mount it once anywhere inside the editor provider. Chip colours come from each definition's chrome, which is host-authored and never file data.

declare function CustomNodeChrome(props: CustomNodeChromeProps): null;

```tsx
<DocxEditor.Root>
  <CustomNodeChrome onNodeClick={(node) => setPopover(node)} />
  <DocxEditor.Viewport><DocxEditor.Content /></DocxEditor.Viewport>
</DocxEditor.Root>
```

CustomNodeContextMenufunctionSource ↗

Renders the pointed-at node's card data plus its "Edit label" row, or nothing when the right-click landed elsewhere. Carries docxRowPlacement: 'start', so the context menu mounts it above the packaged rows.

declare function CustomNodeContextMenu(props: CustomNodeContextMenuProps): react.JSX.Element | null;

resolveCustomNodeActivationfunctionSource ↗

The recognized custom node a pointer target sits on, or null.

Walks up from target to the painted control boundary, reads its data-tag, and matches the decoded identity against nodes. Returns null for anything that is not a recognized chip — ordinary text, an unclaimed SDT, a tag no definition owns.

Every input is DOM the engine painted from FILE DATA. The tag is attacker-controlled and goes through the codec's guards; it never reaches markup.

declare function resolveCustomNodeActivation(target: EventTarget | null, nodes: readonly AnyCustomNodeDefinition[]): ResolvedCustomNodeActivation | null;

reviewModulefunctionSource ↗

Build the review module. Construction never validates the key and never touches the network.

declare function reviewModule(options?: ReviewModuleOptions): EditorModule;

useCustomNodeDefinitionsfunctionSource ↗

The definitions a chrome surface should act on: the nodes prop when given, else the definitions registered on the editor (customNodesModule). Registering once and letting every surface default to it is the intended shape; the prop exists for a host that wants one surface scoped narrower.

declare function useCustomNodeDefinitions(nodes: readonly AnyCustomNodeDefinition[] | undefined): readonly AnyCustomNodeDefinition[];

useReviewfunctionSource ↗

Read the review queue and act on it.

Subscribes to the editor's own change stream, so the list re-derives when the document does and not on every render.

declare function useReview(query?: ReviewItemQuery): UseReviewReturn;

useReviewItemfunctionSource ↗

The review item the surrounding card (or balloon) renders, or null outside one.

The hook a host's own card content is built from: children passed into the rail's cards — extra actions, a custom body — read the CURRENT item here rather than receiving props, exactly the way the packaged parts do.

declare function useReviewItem(): ReviewItemView | null;

useReviewOffunctionSource ↗

The same hook against an explicit editor, for hosts that hold their own.

declare function useReviewOf(editor: Editor | null, query?: ReviewItemQuery): UseReviewReturn;

useStackedReviewPositionsfunctionSource ↗

Non-overlapping Y positions for cards you have measured.

Separate from useReview because only the CALLER knows how tall its cards are — a host rendering its own markup can be told where each anchor is, but not how much room its card needs. Pass the measured heights back and get positions that do not collide; skip it entirely and cards sit on their raw anchors, which is correct for a rail that does not stack.

Takes anything with a key and an anchor, not only cards: a compose box competes for the same column and has to be stacked WITH them or it lands on top of the card whose text was just re-selected. Entries must arrive in document order — the run is a single sweep.

UNITS. Anchors are in layout POINTS, because that is what the engine publishes; measured heights are in CSS PIXELS, because that is what the DOM reports. Pass scale so the two can be added. Without it a 330px card advanced the run by 330 POINTS — 440px — and two comments on adjacent lines of one paragraph sat a third of a page apart.

declare function useStackedReviewPositions(items: readonly {
    readonly key: string;
    readonly anchorY: number | null;
}[], heights: ReadonlyMap<string, number>, options?: {
    readonly gap?: number;
    readonly scale?: number;
    readonly defaultHeight?: number;
}): ReadonlyMap<string, number>;

CustomNodeChromePropsinterfaceSource ↗

Props for [CustomNodeChrome](CustomNodeChrome): which definitions to paint, and where activation goes.

The two hooks are the component-level twins of a definition's own onClick/onHover. Host UI state belongs here rather than on the definition, which every surface shares and which has no React context to close over.

interface CustomNodeChromeProps

CustomNodeContextMenuPropsinterfaceSource ↗

Props for [CustomNodeContextMenu](CustomNodeContextMenu): which definitions get menu sections, and which rows those sections offer.

The Edit row renders when either the definition's own onEdit or this component's onEditNode is present; the Remove row is on by default but only where the node's canonical id can be resolved.

interface CustomNodeContextMenuProps

DocxEditorReviewNamespaceinterfaceSource ↗

The review rail compound.

interface DocxEditorReviewNamespace

ProLicenseOptionsinterfaceSource ↗

Accepted by every pro entry point.

interface ProLicenseOptions

ResolvedCustomNodeActivationinterfaceSource ↗

What [resolveCustomNodeActivation](resolveCustomNodeActivation) found under a pointer target.

The RAW decode, before the definition's fromDocx has had its say — use activatedCustomNodeOf for the enriched form every host hook receives.

interface ResolvedCustomNodeActivation

ReviewActionPropsinterfaceSource ↗

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

interface ReviewActionProps extends ReviewPartProps

ReviewActivationOptionsinterface

How activating a review item places it in the viewport.

interface ReviewActivationOptions

ReviewMarkersPropsinterfaceSource ↗

Props for the collapsed rail's gutter markers.

scale, offset and window are the rail's own geometry and are supplied for you — an override inherits them, so a host passes only what it wants to change.

interface ReviewMarkersProps

ReviewModuleOptionsinterfaceSource ↗

How [reviewModule](reviewModule) is configured. Carries only the licence key today, so reviewModule() with no argument is the ordinary call.

interface ReviewModuleOptions extends ProLicenseOptions

ReviewPartPropsinterfaceSource ↗

Shared props for every part.

interface ReviewPartProps

ReviewPropsinterfaceSource ↗

Props for DocxEditor.Review.

interface ReviewProps extends Omit<ReviewPartProps, 'children'>

UseReviewReturninterfaceSource ↗

What [useReview](useReview) returns: the review rail's data and the four things a card can do.

interface UseReviewReturn

ReviewItemViewtypeSource ↗

One card's data plus where it belongs on screen.

The engine's own placement, unchanged. It is already presentation-ready — author, initials, date, text, thread — because deriving those from the canonical tree is engine work, and an adapter deriving them would be document derivation in a host and would have to be written once per framework.

type ReviewItemView = ReviewItemPlacement;

DocxEditorReviewconstSource ↗

The review rail: comments and tracked changes as a compound component.

DocxEditorReview is itself the root; every part hangs off it, so a host arranges the pieces it wants rather than accepting one fixed layout. Requires the review module to be registered via createDocxEditor({ modules: [reviewModule()] }) — without it there is nothing to derive cards from.

DocxEditorReview: DocxEditorReviewNamespace

```tsx
<DocxEditorReview>
  <DocxEditorReview.List>
    <DocxEditorReview.Card>
      <DocxEditorReview.Author />
      <DocxEditorReview.Summary />
      <DocxEditorReview.Accept />
      <DocxEditorReview.Reject />
    </DocxEditorReview.Card>
  </DocxEditorReview.List>
</DocxEditorReview>
```

CustomNodeContextMenunamespaceSource ↗

declare namespace CustomNodeContextMenu