# React API

Public React component, hook and extension types generated from source.

### QuireMarkdownProps

`@quirekit/incremark-react` · MIT

React reader supporting static text, AI streaming and accepted parser states.

```ts
export interface QuireMarkdownProps extends MarkdownSourceInput, MarkdownRenderOptions {
    readonly status?: MarkdownStatus;
    readonly locale?: MarkdownLocale;
    readonly className?: string;
    readonly style?: CSSProperties;
    readonly onError?: (failure: MarkdownReadingError) => void;
}
```

**status** — Transport status; changing it does not reparse or finalize source.

**locale** — Control language, independent of document text.

**className** — Outer reader class.

**style** — Outer reader style.

**onError** — @param failure - Source-preserving local error; observers cannot break fallback.

**content** — Exact authoritative host source, including a streaming prefix.

**state** — Advanced existing parser snapshot.

**identity** — Document/message identity; replacement resets resources.

**options** — Pure parser configuration; replace identity to reconfigure.

**ssr** — Deterministic first-render strategy; semantic is the default.

**components** — Semantic element/component overrides.

**cache** — Disable reuse for diagnostics; parsing remains incremental.

**html** — Explicit safe HTML opt-in; omitted preserves source.

**renderNode** — Trusted product adapter.

**renderNodeKey** — @param state - Accepted snapshot.
@returns Identity covering external adapter reads; omit to conservatively reproject.

### MarkdownComponents

`@quirekit/incremark-react` · MIT

Instance-local native tag/component replacements; application components are trusted code.

```ts
export type MarkdownComponents = Readonly<Partial<Record<string, ComponentType<MarkdownComponentProps> | string>>>;
```

### MarkdownComponentProps

`@quirekit/incremark-react` · MIT

Props supplied to a custom semantic component; consume node before forwarding DOM props.

```ts
export interface MarkdownComponentProps {
    readonly node: MarkdownNodeInfo;
    readonly children?: ReactNode;
    readonly [attribute: string]: unknown;
}
```

**node** — Canonical source metadata, supplied to custom components only.

**children** — Projected semantic children.

### MarkdownRenderOptions

`@quirekit/incremark-react` · MIT

Instance-local React rendering options over shared cache and HTML policy.

```ts
export interface MarkdownRenderOptions extends CoreOptions<ReactNode> {
    readonly components?: MarkdownComponents;
}
```

**components** — Semantic element/component overrides.

**cache** — Disable reuse for diagnostics; parsing remains incremental.

**html** — Explicit safe HTML opt-in; omitted preserves source.

**renderNode** — Trusted product adapter.

**renderNodeKey** — @param state - Accepted snapshot.
@returns Identity covering external adapter reads; omit to conservatively reproject.

### MarkdownReadingContext

`@quirekit/incremark-react` · MIT

React reading inputs over the validated source codec.

```ts
export interface MarkdownReadingContext<Attrs extends object = Readonly<Record<string, unknown>>> extends CoreContext<ReactNode, Attrs> {
}
```

**name** — Installed semantic owner.

**attrs** — Fields validated by the extension's existing source codec.

**node** — Confirmed UTF-16 source syntax.

**document** — Canonical read-only source and shared reference resolution.

**locale** — Host control language.

**renderInline** — @param from - Inclusive content start without splitting a child.
@param to - Exclusive content end.
@returns Ordered projected inline children.

**renderBlocks** — @param omitted - Direct syntax markers excluded from content.
@returns Projected direct blocks.

### MarkdownReadingDefinition

`@quirekit/incremark-react` · MIT

React presentation with instance-owned asynchronous resources.

```ts
export interface MarkdownReadingDefinition<Attrs extends object = Readonly<Record<string, unknown>>, Resource = unknown> extends CoreDefinition<ReactNode, Attrs, Resource> {
}
```

**cacheKey** — @param document - Current accepted source.
@returns Identity covering codec/render/load reads outside the node; absence disables block reuse.

**load** — @param context - Captured immutable inputs.
@param signal - Aborted on replacement/unmount.
@returns Owned resource; late leases are released, and SSR never loads.

**render** — @param context - Validated source.
@param resource - Accepted resource or undefined without a loader.
@returns Trusted presentation; undefined preserves source.

### withMarkdownReading

`@quirekit/incremark-react` · MIT

@param extension - Configured source extension; configure/extend before wrapping.
@param definition - Trusted React presentation and optional abortable resource.
@returns The original MSFE definition with its canonical semantic codec and React reading entry.

```ts
function withMarkdownReading<Attrs extends object = Readonly<Record<string, unknown>>, Resource = unknown>(extension: AnyExtension, definition: MarkdownReadingDefinition<Attrs, Resource>): AnyExtension
```

### MarkdownSourceInput

`@quirekit/incremark-react` · MIT

Accepted source inputs; content and state are mutually exclusive.

```ts
export interface MarkdownSourceInput {
    readonly content?: string | undefined;
    readonly state?: EditorState | undefined;
    readonly identity?: string | undefined;
    readonly options?: MarkdownOptions | undefined;
    readonly ssr?: "semantic" | "source" | undefined;
}
```

**content** — Exact authoritative host source, including a streaming prefix.

**state** — Advanced existing parser snapshot.

**identity** — Document/message identity; replacement resets resources.

**options** — Pure parser configuration; replace identity to reconfigure.

**ssr** — Deterministic first-render strategy; semantic is the default.

### MarkdownSourceSnapshot

`@quirekit/incremark-react` · MIT

Immutable cached external-store snapshot; unchanged inputs keep object identity.

```ts
export interface MarkdownSourceSnapshot {
    readonly state: EditorState | undefined;
    readonly pending: boolean;
    readonly generation: number;
    readonly error: MarkdownReadingError | undefined;
}
```

**state** — Accepted canonical parse, or undefined for deferred/failed parsing.

**pending** — Whether a cooperative parse continuation remains.

**generation** — Document generation for resource and cache ownership.

**error** — Isolated source failure, delivered after commit.

### useMarkdownSource

`@quirekit/incremark-react` · MIT

@param input - Authoritative source and immutable parser configuration.
@param onError - Committed parser failure observer.
@returns Cached immutable source snapshot with a single cancellable parse continuation.

```ts
function useMarkdownSource(input: MarkdownSourceInput, onError?: (failure: MarkdownReadingError) => void): MarkdownSourceSnapshot
```

### MarkdownRenderer

`@quirekit/incremark-react` · MIT

React cache owner; prepare is safe during render and commit accepts only the current attempt.

```ts
export class MarkdownRenderer extends CoreRenderer<ReactNode> {
    constructor(limits?: MarkdownCacheLimits);
    override get work(): Readonly<MarkdownRenderWork>;
    override clear(): void;
    override prepare(state: EditorState, locale: MarkdownLocale, prefix?: string, onError?: (error: MarkdownReadingError) => void, options?: MarkdownRenderOptions): MarkdownRenderFrame<ReactNode>;
    override render(state: EditorState, locale: MarkdownLocale, prefix?: string, onError?: (error: MarkdownReadingError) => void, options?: MarkdownRenderOptions): ReactNode;
}
```

### renderMarkdown

`@quirekit/incremark-react` · MIT

@param state - Accepted source.
@param locale - Control language.
@param prefix - Instance navigation namespace.
@param onError - Isolated failure observer.
@param options - Presentation policy.
@returns Ordinary React projection with no retained block output.

```ts
function renderMarkdown(state: EditorState, locale: MarkdownLocale, prefix?: string, onError?: (error: MarkdownReadingError) => void, options?: MarkdownRenderOptions): ReactNode
```