@oxide/react-asciidoc 1.2.0 → 1.3.0-canary.5535dcb

package/dist/types/index.d.ts

@@ -1,5 +1,7 @@
 import parse from 'html-react-parser';
-import { Admonition, Audio, CoList, DList, Document, Example, FloatingTitle, Image, Listing, Literal, OList, Open, PageBreak, Paragraph, Pass, Preamble, Quote, Section, Sidebar, Table, TableOfContents, ThematicBreak, UList, Verse, Video } from './templates';
+import RenderInline, { type InlineOverrides, inlineHtml } from './RenderInline';
+import * as Inline from './inline';
+import { Admonition, Audio, CoList, DList, Document, Example, FloatingTitle, Image, Listing, Literal, OList, Open, PageBreak, Paragraph, Pass, Preamble, Quote, Section, Sidebar, Stem, Table, TableOfContents, ThematicBreak, UList, Verse, Video } from './templates';
 import { Title } from './templates/util';
 import { isOption, prepareDocument, processDocument } from './utils/prepareDocument';
 import type { AdmonitionBlock, AudioBlock, Block, CoListBlock, DListBlock, DocumentBlock, DocumentSection, ImageBlock, ListBlock, LiteralBlock, ParagraphBlock, SectionBlock, TableBlock, VideoBlock } from './utils/prepareDocument';
@@ -22,6 +24,7 @@ type Overrides = {
     quote?: typeof Quote;
     section?: typeof Section;
     sidebar?: typeof Sidebar;
+    stem?: typeof Stem;
     table?: typeof Table;
     toc?: typeof TableOfContents;
     thematic_break?: typeof ThematicBreak;
@@ -31,6 +34,7 @@ type Overrides = {
 };
 export type Options = {
     overrides?: Overrides;
+    inlineOverrides?: InlineOverrides;
     customDocument?: typeof Document;
 };
 export declare const Context: import("react").Context<Options & {
@@ -52,6 +56,7 @@ export declare const useConverterContext: () => Options & {
         sections?: DocumentSection[];
     };
 };
-export { Asciidoc, Content, prepareDocument, Title, parse, processDocument, isOption };
+export { Asciidoc, Content, prepareDocument, Title, parse, processDocument, isOption, RenderInline, inlineHtml, Inline, };
+export type { InlineOverrides };
 export type { AdmonitionBlock, AudioBlock, Block, CoListBlock, DListBlock, DocumentBlock, DocumentSection, ImageBlock, ListBlock, LiteralBlock, ParagraphBlock, SectionBlock, TableBlock, VideoBlock, };
 export * from './templates';

package/dist/types/inline/index.d.ts

@@ -0,0 +1,4 @@
+export { parseInline, subSpecialchars, subCallouts, subCalloutsRaw } from './parser';
+export type { ParseOptions, ParseState } from './parser';
+export { renderInline, renderInlineAsString } from './renderer';
+export * from './types';

package/dist/types/inline/parser.d.ts

@@ -0,0 +1,90 @@
+import { InlineNode } from './types';
+export interface ParseOptions {
+    compatMode?: boolean;
+    attributes?: Record<string, string>;
+    /** Shared state for cross-call numbering (footnotes, etc.). If not
+     *  provided, a fresh state is allocated for the call. */
+    state?: ParseState;
+    /** Internal: true when this parseInline call is processing text that
+     *  has already been through subSpecialchars (e.g. recursive call from
+     *  subQuotes on inner text). Skip specialchars to avoid double-escape. */
+    _alreadyEscaped?: boolean;
+    /** Internal: true when parsing the inner content of a quoted span. The
+     *  email macro uses this to suppress linkification at position 0 (the
+     *  quote tag's `>` is a non-linking context in stock asciidoctor). */
+    _quoted?: boolean;
+    /** Internal: index into the quote-subs list to start from when parsing the
+     *  inner content of a quoted span. Asciidoctor applies the substitution
+     *  passes sequentially over the whole string, so a span's content is only
+     *  subject to the passes that come AFTER the one that matched it — earlier
+     *  passes already ran (replacing their matches with placeholders) and the
+     *  matching pass itself never re-scans its own replacement. Re-applying
+     *  earlier passes here would wrongly re-format literal content such as the
+     *  `_un_` inside `\__un__` → `<em>_un_</em>`. */
+    _quoteFromIndex?: number;
+    /** Internal: restrict which substitution steps run, by asciidoctor sub name
+     *  (`specialcharacters`, `quotes`, `attributes`, `replacements`, `macros`,
+     *  `post_replacements`). Used for verbatim blocks with an explicit `subs`
+     *  list (e.g. a listing with `subs=+macros` runs macros but NOT quotes). When
+     *  undefined, all normal subs run. */
+    _subs?: string[];
+}
+export interface ParseState {
+    footnoteIndex: number;
+    footnotesById: Map<string, number>;
+    /** Collected footnote definitions (in source order) so that the document
+     *  template can render a footnote section without calling
+     *  asciidoctor's `getFootnotes()`. Each entry carries the 1-based
+     *  index and the parsed-inline `text` array. */
+    footnoteDefs?: InlineNode[][];
+    /** Document-wide counters for `{counter:name}` / `{counter2:name}`. Shared
+     *  across the whole document (including titles) so values increment in
+     *  source order, matching asciidoctor. */
+    counters?: Map<string, number | string>;
+    /** Source-order resets for counters. A `:!name:` (or `:name!:`) attribute
+     *  entry in the document body unsets the attribute; the next `{counter:name}`
+     *  then restarts from 1. Those entries aren't AST blocks, so the inline
+     *  parser can't see them — `prepareDocument` pre-scans the raw source and
+     *  records, per name, the set of use-indices BEFORE which the counter must
+     *  reset. `counterUses` tracks how many times each counter has been used. */
+    counterResets?: Map<string, Set<number>>;
+    counterUses?: Map<string, number>;
+    /** Attribute-set counter seeds: when `:name: VALUE` appears in the document
+     *  body with a non-empty value, the next `{counter:name}` after that point
+     *  uses `succ(VALUE)` as its value (e.g. `:c: 10` → 11, `:c: @` → A) instead
+     *  of starting at 1. Maps counter name → (use-index → raw seed value). */
+    counterSeeds?: Map<string, Map<number, string>>;
+}
+export declare function subSpecialchars(text: string): string;
+/** Replace callout markers in specialchars-escaped text.
+ *  `iconsFont=true` uses `<i>` / `<b>` (font-icons mode, the default in
+ *  tests). Otherwise asciidoctor emits bare `&lt;N&gt;` text.
+ *
+ *  In listing/literal/verse source, callout markers look like `<1>`, `<.>`
+ *  (auto-numbered), and can be preceded by a comment prefix (`//`, `#`,
+ *  `--`, or `;;`). When icons=font (the default test mode), the prefix is
+ *  stripped and the marker is replaced with an icon+badge. When icons is
+ *  not font-mode, the marker is preserved as `&lt;N&gt;`.
+ *
+ *  Callouts can also appear inside HTML comment guards: `<!--1-->`. After
+ *  subSpecialchars these become `&lt;!--1--&gt;`. When icons=font the
+ *  guard is stripped and the callout is rendered as an icon; otherwise the
+ *  guard is preserved around `&lt;N&gt;`. */
+export declare function subCallouts(text: string, iconsFont?: boolean, lineComment?: string): string;
+/** Like {@link subCallouts}, but keyed to RAW (un-escaped) callout markers.
+ *
+ *  `subCallouts` matches specialchars-escaped markers (`&lt;N&gt;`) because it
+ *  runs on the escaped content the default `innerHTML` renderer needs.
+ *  Consumers that post-process the raw `block.source` instead — e.g. a syntax
+ *  highlighter — need callouts resolved against the original `<N>` markers,
+ *  which never went through specialchars. This is that counterpart: same
+ *  matching rules (comment-guard callouts, comment-prefix stripping, escape
+ *  with `\`, end-of-line lookahead, auto-numbered `.`), but the literal
+ *  delimiters are `<`/`>` rather than `&lt;`/`&gt;`.
+ *
+ *  With `iconsFont=true` the marker is replaced with conum markup
+ *  (`<i class="conum" data-value="N"></i><b>(N)</b>`); otherwise the bare
+ *  `<N>` marker is preserved (with any comment prefix). All non-callout text
+ *  is returned untouched and un-escaped, ready to feed to a highlighter. */
+export declare function subCalloutsRaw(text: string, iconsFont?: boolean, lineComment?: string): string;
+export declare function parseInline(text: string, opts?: ParseOptions): InlineNode[];

package/dist/types/inline/quotes.d.ts

@@ -0,0 +1,5 @@
+import { QSubEntry } from './types';
+export declare const QUOTE_SUBS: {
+    nonCompat: QSubEntry[];
+    compat: QSubEntry[];
+};

package/dist/types/inline/renderer.d.ts

@@ -0,0 +1,3 @@
+import { InlineNode } from './types';
+export declare function renderInline(nodes: InlineNode[], iconsFont?: boolean): string;
+export declare function renderInlineAsString(nodes: InlineNode[], iconsFont?: boolean): string;

package/dist/types/inline/rx.d.ts

@@ -0,0 +1,28 @@
+export declare const InlineAnchorRx: RegExp;
+export declare const InlineBiblioAnchorRx: RegExp;
+export declare const InlineEmailRx: RegExp;
+export declare const InlineFootnoteMacroRx: RegExp;
+export declare const InlineImageMacroRx: RegExp;
+export declare const InlineIndextermMacroRx: RegExp;
+export declare const InlineKbdBtnMacroRx: RegExp;
+export declare const InlineLinkRx: RegExp;
+export declare const InlineLinkMacroRx: RegExp;
+export declare const InlineMenuMacroRx: RegExp;
+export declare const InlineMenuRx: RegExp;
+export declare const InlinePassRxNonCompat: RegExp;
+export declare const InlinePassRxCompat: RegExp;
+export declare const InlinePassMacroRx: RegExp;
+export declare const InlineStemMacroRx: RegExp;
+export declare const InlineXrefMacroRx: RegExp;
+export declare const HardLineBreakRx: RegExp;
+export declare const CalloutSourceRx: RegExp;
+export declare const SpecialCharsRx: RegExp;
+export declare const AttributeReferenceRx: RegExp;
+export declare const QuotedTextSniffRx: Record<string, RegExp>;
+export declare const PassSlotRx: RegExp;
+export declare const ReplaceableTextRx: RegExp;
+export declare const SpecialCharsTr: Record<string, string>;
+export declare const REPLACEMENTS: Array<[RegExp, string]>;
+export declare const NORMAL_SUBS: readonly ["specialcharacters", "quotes", "attributes", "replacements", "macros", "post_replacements"];
+export declare const HARD_LINE_BREAK = " +";
+export declare const ATTR_REF_HEAD = "{";

package/dist/types/inline/types.d.ts

@@ -0,0 +1,105 @@
+export type QuoteSubType = 'emphasis' | 'strong' | 'monospaced' | 'double' | 'single' | 'superscript' | 'subscript' | 'mark' | 'asciimath' | 'latexmath' | 'unquoted';
+export interface QSubEntry {
+    type: QuoteSubType;
+    scope: 'constrained' | 'unconstrained';
+    rx: RegExp;
+}
+export type InlineNode = TextNode | QuotedNode | AnchorNode | ImageNode | FootnoteNode | IndexTermNode | CalloutNode | BreakNode | ButtonNode | KeyboardNode | MenuNode;
+export interface TextNode {
+    type: 'text';
+    text: string;
+    /** Raw HTML from a no-subs passthrough (`+++…+++`, `pass:[…]`). Must be
+     *  emitted verbatim — the React renderer parses it into elements rather
+     *  than escaping it as text. */
+    raw?: boolean;
+}
+export interface QuotedNode {
+    type: 'quoted';
+    subtype: 'emphasis' | 'strong' | 'monospaced' | 'double' | 'single' | 'superscript' | 'subscript' | 'mark' | 'asciimath' | 'latexmath' | 'unquoted';
+    text: InlineNode[];
+    id?: string;
+    role?: string;
+}
+export interface AnchorNode {
+    type: 'anchor';
+    subtype: 'link' | 'ref' | 'xref' | 'bibref';
+    text: InlineNode[];
+    target: string;
+    id?: string;
+    role?: string;
+    window?: string;
+    /** Per-xref display style from `xref:id[xrefstyle=short|full]`. Overrides
+     *  the document `:xrefstyle:` when computing the fallback label. */
+    xrefstyle?: string;
+    /** Set when the xref carried an explicit reftext (e.g. `<<id,text>>` or
+     *  `xref:id[text]`). Distinguishes a user-typed label that happens to equal
+     *  `[id]` from the auto-generated fallback, so `resolveXrefs` leaves it be. */
+    explicitText?: boolean;
+    /** Set for the macro form (`xref:target[]`) as opposed to the shorthand
+     *  (`<<target>>`). Only the macro form treats a target with a file extension
+     *  (`.adoc`, …) as an inter-document path. */
+    macro?: boolean;
+    /** Resolved external URL when an xref points at a `[bibliography]` entry
+     *  whose citation carries a link. Set by `prepareDocument`; the default
+     *  renderer ignores it (preserving stock parity), but an
+     *  `inlineOverrides.anchor` can read it to link straight to the resource. */
+    externalHref?: string;
+    /** Inline content of the `[bibliography]` entry an xref resolves to, with
+     *  the leading `[[[id]]]` bibref label stripped (the citation body: free
+     *  text + links). Set by `prepareDocument` alongside `externalHref`; the
+     *  default renderer ignores it (preserving stock parity), but an
+     *  `inlineOverrides.anchor` can read it to show the reference's content in a
+     *  hover tooltip. */
+    referenceInlines?: InlineNode[];
+}
+export interface ImageNode {
+    type: 'image';
+    subtype: 'image' | 'icon';
+    target: string;
+    alt?: string;
+    width?: string;
+    height?: string;
+    id?: string;
+    role?: string;
+    title?: string;
+    /** `float` attribute — rendered as an extra class on the wrapper span. */
+    float?: string;
+    /** `link` attribute — wraps the image/icon in `<a class="image" href>`. */
+    link?: string;
+    /** `window` (`^` or `window=`) for the link wrapper. */
+    window?: string;
+    iconType?: 'text' | 'image' | 'font';
+}
+export interface FootnoteNode {
+    type: 'footnote';
+    text: InlineNode[];
+    id?: string;
+    refid?: string;
+    /** Sequential index assigned during parsing (1-based). */
+    index?: number;
+}
+export interface IndexTermNode {
+    type: 'indexterm';
+    terms: string[];
+    visible?: boolean;
+}
+export interface CalloutNode {
+    type: 'callout';
+    number: string;
+}
+export interface BreakNode {
+    type: 'break';
+    subtype: 'line';
+}
+export interface ButtonNode {
+    type: 'button';
+    text: InlineNode[];
+}
+export interface KeyboardNode {
+    type: 'kbd';
+    keys: string[];
+}
+export interface MenuNode {
+    type: 'menu';
+    items: string[];
+}

package/dist/types/templates/FloatingTitle.d.ts

@@ -1,5 +1,9 @@
 import { type BaseBlock } from '../utils/prepareDocument';
 declare const FloatingTitle: ({ node }: {
     node: BaseBlock;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => import("react").ReactElement<{
+    'data-lineno'?: number | undefined;
+    id: string | undefined;
+    className: string;
+}, string | import("react").JSXElementConstructor<any>>;
 export default FloatingTitle;

package/dist/types/templates/Stem.d.ts

@@ -0,0 +1,5 @@
+import { type Block } from '../utils/prepareDocument';
+declare const Stem: ({ node }: {
+    node: Block;
+}) => import("react/jsx-runtime").JSX.Element;
+export default Stem;

package/dist/types/templates/index.d.ts

@@ -18,10 +18,11 @@ import Preamble from './Preamble';
 import Quote from './Quote';
 import Section from './Section';
 import Sidebar from './Sidebar';
+import Stem from './Stem';
 import Table from './Table';
 import TableOfContents from './TableOfContents';
 import ThematicBreak from './ThematicBreak';
 import UList from './UList';
 import Verse from './Verse';
 import Video from './Video';
-export { Audio, Admonition, CoList, Document, DList, Example, Outline, FloatingTitle, Listing, Literal, Image, OList, Open, PageBreak, Pass, Paragraph, Preamble, Section, Sidebar, Table, ThematicBreak, UList, Quote, Verse, TableOfContents, Video, };
+export { Audio, Admonition, CoList, Document, DList, Example, Outline, FloatingTitle, Listing, Literal, Image, OList, Open, PageBreak, Pass, Paragraph, Preamble, Section, Sidebar, Stem, Table, ThematicBreak, UList, Quote, Verse, TableOfContents, Video, };

package/dist/types/utils/prepareDocument.d.ts

@@ -1,11 +1,18 @@
 import type * as AdocTypes from '@asciidoctor/core';
+import type { InlineNode } from '../inline';
 type NodeType = 'audio' | 'admonition' | 'colist' | 'cell' | 'dlist' | 'document' | 'embedded' | 'example' | 'floating_title' | 'image' | 'inline_anchor' | 'inline_break' | 'inline_button' | 'inline_callout' | 'inline_footnote' | 'inline_image' | 'inline_kbd' | 'inline_menu' | 'inline_quoted' | 'listing' | 'list_item' | 'literal' | 'olist' | 'open' | 'outline' | 'page_break' | 'paragraph' | 'pass' | 'preamble' | 'quote' | 'section' | 'sidebar' | 'stem' | 'table' | 'table_cell' | 'thematic_break' | 'toc' | 'ulist' | 'verse' | 'video';
 type ContentModel = 'compound' | 'simple' | 'verbatim' | 'raw' | 'empty';
 export type BaseBlock = {
     id?: string;
     type: NodeType;
     blocks: Block[];
-    content?: string | undefined;
+    content?: string | string[] | undefined;
+    /** Inline AST parsed from this block's source (only set for simple-content
+     *  leaves). Templates may render this directly to compose React inline
+     *  components, or fall back to `content` (HTML). */
+    inlines?: InlineNode[] | undefined;
+    /** Inline AST for the block's title, if present. */
+    titleInlines?: InlineNode[] | undefined;
     attributes: Record<string, string | number>;
     contentModel: ContentModel | undefined;
     lineNumber?: number | undefined;
@@ -20,10 +27,15 @@ export type DocumentSection = {
     title: string;
     level: number;
     num: string;
+    numbered: boolean;
+    hasCaption: boolean;
     sections: DocumentSection[];
 };
 export type DocumentBlock = {
     type: 'document';
+    /** Explicit id on the document title (`[[abstract]]` / `[#abstract]`),
+     *  emitted on the title `<h1>`. */
+    id?: string;
     title: string;
     hasHeader: boolean;
     noHeader: boolean;
@@ -31,8 +43,8 @@ export type DocumentBlock = {
     blocks: Block[];
     contentModel: ContentModel | undefined;
     footnotes: {
-        text: string | undefined;
-        index: number | undefined;
+        index: number;
+        textInlines: InlineNode[];
     }[];
     sections: DocumentSection[];
     authors: {
@@ -65,9 +77,13 @@ export interface VideoBlock extends BaseBlock {
 export interface ImageBlock extends BaseBlock {
     type: 'image';
     imageUri: string;
+    /** Substituted alt text (asciidoctor `getAlt()` — entities like `&#8217;`
+     *  already applied). Must be emitted verbatim, not via a JSX attribute,
+     *  which would re-escape the `&`. */
+    alt: string;
 }
 export interface ListItemBlock extends BaseBlock {
-    text: string | undefined;
+    textInlines?: InlineNode[] | undefined;
 }
 export interface ListBlock extends BaseBlock {
     items: ListItemBlock[];
@@ -91,6 +107,7 @@ export interface SectionBlock extends BaseBlock {
     title: string;
     num: string;
     name: string;
+    hasCaption: boolean;
 }
 export interface TableBlock extends BaseBlock {
     type: 'table';
@@ -121,7 +138,17 @@ export interface Cell extends BaseBlock {
     type: 'table_cell';
     columnSpan: number | undefined;
     rowSpan: number | undefined;
-    text: string;
+    text: string | undefined;
+    textInlines?: InlineNode[] | undefined;
+    /** Per-paragraph HTML strings for cell rendering. Empty array for asciidoc
+     *  cells (rendered via `<Content>`) and for empty cells. */
+    content: string[] | undefined;
+    /** Per-paragraph inline ASTs mirroring the paragraph boundaries of
+     *  `content`. Lets the Table template render cell inline content through
+     *  `<RenderInline>` (so `inlineOverrides` apply) instead of injecting the
+     *  serialized HTML string. Undefined for asciidoc/literal cells, which
+     *  don't go through the inline-string path. */
+    contentInlines?: InlineNode[][] | undefined;
     source: string;
     lines: string[];
     column: Column | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxide/react-asciidoc",
-  "version": "1.2.0",
+  "version": "1.3.0-canary.5535dcb",
   "files": [
     "dist"
   ],
@@ -23,9 +23,8 @@
     "dev": "vite --port 8000",
     "clean": "rimraf dist/",
     "build": "npm run clean && vite build && tsc",
-    "test:init": "rm -rf ./tests/renderer.spec.ts-snapshots & npx playwright test -g html",
-    "test:run": "npx playwright test -g react",
-    "release": "auto shipit",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "fmt": "prettier --write --ignore-path ./.gitignore  .",
     "fmt:check": "prettier --check --ignore-path ./.gitignore . ",
     "tsc": "tsc"
@@ -33,45 +32,38 @@
   "author": "Oxide Computer Company <bots@oxidecomputer.com>",
   "license": "MPL 2.0",
   "dependencies": {
+    "entities": "^6.0.1",
     "html-react-parser": "^5.2.6"
   },
   "devDependencies": {
-    "@playwright/test": "^1.55.1",
+    "@asciidoctor/core": "^3.0.4",
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
     "@types/node": "^24.5.2",
     "@types/react": "^18.0.18",
     "@types/react-dom": "^18.0.6",
     "@vitejs/plugin-react": "^5.0.3",
-    "auto": "^11.3.0",
     "classnames": "^2.5.1",
     "eslint": "^9.36.0",
     "html-entities": "^2.6.0",
+    "jsdom": "^29.1.1",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.6.2",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
     "rimraf": "^6.0.1",
     "rollup-plugin-dts": "^6.2.3",
     "typescript": "^5.9.2",
     "vite": "^7.1.7",
     "vite-dts": "^1.0.4",
     "vite-plugin-dts": "^4.5.4",
-    "vite-tsconfig-paths": "^5.1.4"
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^4.1.7"
   },
   "peerDependencies": {
     "@asciidoctor/core": "^3.0.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },
-  "auto": {
-    "plugins": [
-      [
-        "npm",
-        {
-          "setRcToken": false
-        }
-      ],
-      "released"
-    ]
-  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"