@markii/html 0.17.0-next.0 → 0.17.0-next.1

package/dist/failure-presentation.d.ts

@@ -34,6 +34,8 @@ export declare const NOTICE_ATTRIBUTE = "data-mk-notice";
 export declare function invalidAttributeValueTitle(directive: string, attribute: string, value: string): string;
 /** The `title` tooltip for `NOTICE_ATTRIBUTE` on a `figure` with a refused `src`. Ported verbatim from `@markii/react`. */
 export declare function unsafeImageSrcTitle(directive: string): string;
+/** The diagnostic text for a host `renderCode` callback that threw; the code block rendered as usual. Identical across the engines. */
+export declare function codeRendererFailedTitle(): string;
 /** The diagnostic text for a registered block component written as an inline directive, which renders as the inline fallback instead. */
 export declare function formMismatchTitle(directive: string): string;
 /**

package/dist/failure-presentation.js

@@ -82,6 +82,10 @@ export function invalidAttributeValueTitle(directive, attribute, value) {
 export function unsafeImageSrcTitle(directive) {
     return `${directive}: image source was refused as unsafe and was not shown`;
 }
+/** The diagnostic text for a host `renderCode` callback that threw; the code block rendered as usual. Identical across the engines. */
+export function codeRendererFailedTitle() {
+    return 'code block: the host code renderer failed, so the plain block was shown';
+}
 /** The diagnostic text for a registered block component written as an inline directive, which renders as the inline fallback instead. */
 export function formMismatchTitle(directive) {
     return `${directive}: block component was written inline and was not rendered`;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { renderMarkToHtml, renderMarkNodeToHtml, renderMarkInlineToHtml, type RenderMarkOptions, } from './render.js';
+export { renderMarkToHtml, renderMarkNodeToHtml, renderMarkInlineToHtml, type RenderCode, type RenderCodeBlock, type RenderMarkOptions, } from './render.js';
 export { type ResolveImageSrc } from './image-resolve.js';
 export { type ResolveHref } from './href-resolve.js';
 export { escapeHtml } from './escape.js';

package/dist/render.d.ts

@@ -12,6 +12,15 @@ import type { ResolveHref } from './href-resolve.js';
  * `@markii/react`'s identical `MarkRoot` type alias.
  */
 type MarkRoot = ReturnType<typeof parse>;
+/** A fenced code block as offered to `RenderMarkOptions.renderCode`. */
+export interface RenderCodeBlock {
+    /** The info-string language, or `undefined` when the fence names none. */
+    readonly lang: string | undefined;
+    /** The raw code text, without the fence lines. */
+    readonly code: string;
+}
+/** The `renderCode` callback: host HTML for a code block, or `undefined` to render it as usual. */
+export type RenderCode = (code: RenderCodeBlock) => string | undefined;
 /**
  * Renders Markii text to a static HTML string using `registry` to resolve
  * directive names. Pipeline: `@markii/core`'s `toHast` (parse -> tag directive
@@ -65,6 +74,20 @@ type MarkRoot = ReturnType<typeof parse>;
  * `RenderMarkOptions`, so the two engines cannot diverge.
  */
 export interface RenderMarkOptions {
+    /**
+     * Replaces the output for an ordinary fenced code block. Called with the
+     * info-string language (`undefined` when the fence names none) and the
+     * raw code text. Return an HTML string to use it, or `undefined` to render
+     * the block as usual. Never called for script fences (the collapsed
+     * `{name=...}` markers) or for inline code.
+     *
+     * The returned string is HOST-TRUSTED output and is inserted as-is, with
+     * no escaping and no sanitizing: the host owns the escaping. Escape the
+     * code text yourself if you wrap it in markup. A callback that throws
+     * renders the block as usual and reports a `'code-renderer-failed'`
+     * event through `onDiagnostic`.
+     */
+    readonly renderCode?: RenderCode;
     readonly resolveImageSrc?: ResolveImageSrc;
     readonly resolveHref?: ResolveHref;
     readonly onDiagnostic?: OnDiagnostic;

package/dist/render.js

@@ -4,7 +4,7 @@ import { readRegistryComponent, registryLayoutAxis, resolveDirectiveAlias, } fro
 import { resolveLayoutAttributes } from './layout.js';
 import { escapeHtml } from './escape.js';
 import { resolveScopedPath } from './resolve.js';
-import { failureKindClass, failureTitle, EMPTY_INLINE_MARKER_CLASS, emptyInlineTitle, formMismatchTitle, INLINE_FALLBACK_SEPARATOR, invalidAttributeValueTitle, NO_ENGINE_VIEW_LABEL, noEngineViewTitle, } from './failure-presentation.js';
+import { failureKindClass, failureTitle, EMPTY_INLINE_MARKER_CLASS, emptyInlineTitle, codeRendererFailedTitle, formMismatchTitle, INLINE_FALLBACK_SEPARATOR, invalidAttributeValueTitle, NO_ENGINE_VIEW_LABEL, noEngineViewTitle, } from './failure-presentation.js';
 import { createUnavailableComponentLookup, formatValue, getContract, reportDiagnostic, INTERACTIVE_ATTRIBUTE, } from '@markii/stdlib';
 import { resolveImageAttribute } from './image-resolve.js';
 import { resolveHrefAttribute } from './href-resolve.js';
@@ -507,7 +507,35 @@ function applyHrefResolver(node, resolveHref) {
         node.properties.href = resolveHrefAttribute(href, resolveHref);
     }
 }
-function makeTransform(registry, ctx, scope, resolveHref, unavailable) {
+/**
+ * Offers one ordinary fenced code block (a `<pre>` holding a `<code>`) to the
+ * host's `renderCode`. Returns the host's HTML, or `undefined` to render the
+ * block as usual: no callback, a callback that declines, or one that throws
+ * (reported through `onDiagnostic`, never breaking the render). A callback
+ * result that is not a string is treated as declining.
+ */
+function applyRenderCode(node, renderCode, onDiagnostic) {
+    if (!renderCode)
+        return undefined;
+    const codeNode = findChildElement(node, 'code');
+    if (!codeNode)
+        return undefined;
+    try {
+        const result = renderCode({
+            lang: getLanguage(codeNode) || undefined,
+            code: getCodeText(codeNode),
+        });
+        return typeof result === 'string' ? result : undefined;
+    }
+    catch {
+        reportDiagnostic(onDiagnostic, {
+            kind: 'code-renderer-failed',
+            message: codeRendererFailedTitle(),
+        });
+        return undefined;
+    }
+}
+function makeTransform(registry, ctx, scope, resolveHref, unavailable, renderCode) {
     function transform(node) {
         if (node.type !== 'element')
             return node;
@@ -518,6 +546,9 @@ function makeTransform(registry, ctx, scope, resolveHref, unavailable) {
             const marker = renderScriptMarker(node);
             if (marker !== undefined)
                 return raw(marker);
+            const custom = applyRenderCode(node, renderCode, ctx.onDiagnostic);
+            if (custom !== undefined)
+                return raw(custom);
         }
         if (node.tagName === 'img') {
             applyImageResolver(node, ctx.resolveImageSrc);
@@ -536,15 +567,15 @@ function renderFailureFallback(error) {
         `<p class="mk-unknown__label">failed to render document</p>` +
         `<pre class="mk-unknown__content">${escapeHtml(message)}</pre></div>`);
 }
-function renderRoot(root, registry, scope, resolveImageSrc, resolveHref, onDiagnostic, unavailable) {
+function renderRoot(root, registry, scope, resolveImageSrc, resolveHref, onDiagnostic, unavailable, renderCode) {
     const ctx = createBaseContext(scope, resolveImageSrc, onDiagnostic);
-    const transform = makeTransform(registry, ctx, scope, resolveHref, unavailable);
+    const transform = makeTransform(registry, ctx, scope, resolveHref, unavailable, renderCode);
     root.children = root.children.map(transform);
     return serialize(root.children);
 }
 export function renderMarkToHtml(text, registry, store, vault, options) {
     try {
-        return renderRoot(toHast(text), registry, { store: options?.store ?? store, vault: options?.vault ?? vault }, options?.resolveImageSrc, options?.resolveHref, options?.onDiagnostic, createUnavailableComponentLookup(options?.unavailableComponents));
+        return renderRoot(toHast(text), registry, { store: options?.store ?? store, vault: options?.vault ?? vault }, options?.resolveImageSrc, options?.resolveHref, options?.onDiagnostic, createUnavailableComponentLookup(options?.unavailableComponents), options?.renderCode);
     }
     catch (error) {
         return renderFailureFallback(error);
@@ -565,7 +596,7 @@ export function renderMarkToHtml(text, registry, store, vault, options) {
  */
 export function renderMarkNodeToHtml(node, registry, store, vault, options) {
     try {
-        return renderRoot(nodeOrRootToHast(node), registry, { store: options?.store ?? store, vault: options?.vault ?? vault }, options?.resolveImageSrc, options?.resolveHref, options?.onDiagnostic, createUnavailableComponentLookup(options?.unavailableComponents));
+        return renderRoot(nodeOrRootToHast(node), registry, { store: options?.store ?? store, vault: options?.vault ?? vault }, options?.resolveImageSrc, options?.resolveHref, options?.onDiagnostic, createUnavailableComponentLookup(options?.unavailableComponents), options?.renderCode);
     }
     catch (error) {
         return renderFailureFallback(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markii/html",
-  "version": "0.17.0-next.0",
+  "version": "0.17.0-next.1",
   "description": "A framework-free static HTML renderer for Markii (.mk.md): a registry-driven hast-to-HTML string engine. Zero React; for stopped-changing documents (publish, CI, email, archive).",
   "keywords": [
     "markdown",
@@ -54,9 +54,9 @@
   },
   "dependencies": {
     "hast-util-to-html": "^9.0.0",
-    "@markii/core": "^0.17.0-next.0",
-    "@markii/runtime": "^0.17.0-next.0",
-    "@markii/stdlib": "^0.17.0-next.0"
+    "@markii/core": "^0.17.0-next.1",
+    "@markii/runtime": "^0.17.0-next.1",
+    "@markii/stdlib": "^0.17.0-next.1"
   },
   "devDependencies": {
     "@types/hast": "^3.0.4"