@vectojs/markdown 0.23.2 → 0.24.0

package/dist/markdown-image.d.ts

@@ -1,5 +1,10 @@
 import type { InlineObjectBox, InlineObjectSurface } from '@vectojs/core';
 import type { Token, Tokens } from 'marked';
+import type { ImageSource } from '@vectojs/ui';
+/** Resolve a markdown image `src` to a generic {@link ImageSource}. */
+export type MarkdownImageResolver = (src: string) => ImageSource | Promise<ImageSource>;
+/** Default resolver — identity mapping to `{kind:'url'}`. */
+export declare const defaultMarkdownImageResolver: MarkdownImageResolver;
 /**
  * Image predicates over a `marked` token tree, plus the raster store for images
  * that render *inline* rather than as their own block.
@@ -75,16 +80,26 @@ export declare function lastIndexOfImage(tokens: Token[]): number;
  * `InlineObject`, and the box it occupies is fixed when the span is collected, so
  * the natural size has to be readable from here before the next layout rather than
  * applied to an entity afterwards.
+ *
+ * Supports generic {@link ImageSource}: `url` decodes via `HTMLImageElement`,
+ * `blob` via `createImageBitmap` (with object-URL fallback), and `bitmap` is used
+ * directly. The backing `source` is the `CanvasImageSource` drawn by
+ * `paintInlineImage`; `bitmap` is retained as a legacy alias for `url` rasters so
+ * existing tests that reach through `raster.bitmap` keep working.
  */
 export interface InlineImageRaster {
     /** `undefined` when this environment has no `Image` (SSR, plain unit tests). */
     bitmap?: HTMLImageElement;
+    /** Generic backing source for `IRenderer.drawImage` / `InlineObjectSurface`. */
+    source?: CanvasImageSource;
     decoded: boolean;
     /** Natural size, known only once decoded. */
     naturalWidth?: number;
     naturalHeight?: number;
     /** Set when the decode failed, so a broken URL is not retried every frame. */
     failed?: boolean;
+    /** Release `ImageBitmap` / revoke `blob:` URL when evicted or cleared. */
+    dispose?: () => void;
 }
 /** Subscribe `notify` to inline-image decodes. Idempotent per closure. */
 export declare function subscribeInlineImageRaster(notify: () => void): void;
@@ -102,14 +117,22 @@ export declare function unsubscribeInlineImageRaster(notify: () => void): void;
  * paint path calls it on every visible frame, and only the first call starts a
  * decode. Exported because the span collector needs the natural size to size its
  * box, which is the whole reason this store reports one.
+ *
+ * When a resolver is supplied, its result (which may be `blob` or `bitmap`) is
+ * decoded instead of the raw `src` URL. Resolver may be async — the raster stays
+ * square until the promise settles, then notifies waiters so the owner can
+ * re-measure.
  */
-export declare function ensureInlineImageRaster(src: string): InlineImageRaster;
+export declare function ensureInlineImageRaster(src: string, resolver?: MarkdownImageResolver): InlineImageRaster;
 /**
  * Paint one inline image into the box the layout engine reserved for it.
  *
  * Draws nothing until the raster decodes — one frame of empty box, then a repaint
  * through {@link inlineImageRasterWaiters}. Mirrors `paintInlineMath`; a
  * placeholder slab would flash a grey rectangle mid-sentence on every first paint.
+ *
+ * Supports generic {@link ImageSource} backing: `source` may be an `ImageBitmap`
+ * or an `HTMLImageElement`.
  */
 export declare function paintInlineImage(src: string, surface: InlineObjectSurface, box: InlineObjectBox): void;
 /** Drop every cached raster. Tests only — a decode is process-wide state. */

package/dist/markdown-inline.d.ts

@@ -1,6 +1,7 @@
 import { type StyledSpan, type TextStyle } from '@vectojs/core';
 import { RichText } from '@vectojs/ui';
 import type { Token } from 'marked';
+import { type MarkdownImageResolver } from './markdown-image';
 import type { MarkdownTheme } from './theme';
 /**
  * Inline tokens to `RichText` spans: the entity decoder, the span collector and
@@ -62,7 +63,14 @@ blockFontSize?: number,
  * call site that has none to thread — nested recursive calls, and callers
  * predating this feature — costs nothing extra.
  */
-abbr?: ReadonlyMap<string, string>): void;
+abbr?: ReadonlyMap<string, string>, 
+/**
+ * How a markdown image `src` becomes a generic {@link ImageSource}. When
+ * omitted the default identity `{kind:'url'}` mapping is used, so a plain
+ * `![alt](https://…)` keeps its historic path and an app can supply a
+ * CapGlyph adapter that returns `{kind:'bitmap'}` for `capglyph:` URLs.
+ */
+imageResolver?: MarkdownImageResolver): void;
 /**
  * One trailing inline construct that has opened but not closed yet.
  *
@@ -93,4 +101,4 @@ export declare function findUnclosedInline(text: string): UnclosedInline | null;
 /** Parse inline markdown tokens and produce a {@link RichText} entity. */
 export declare function renderInlineToRichText(tokens: Token[] | undefined, fallbackText: string, font: string, color: string, maxWidth: number, theme: Required<MarkdownTheme>, selectable: boolean, onLinkClick?: (url: string) => void, 
 /** The document's `*[TERM]: definition` dictionary — see {@link emitProse}. */
-abbr?: ReadonlyMap<string, string>): RichText;
+abbr?: ReadonlyMap<string, string>, imageResolver?: MarkdownImageResolver): RichText;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/markdown",
-  "version": "0.23.2",
+  "version": "0.24.0",
   "publishConfig": {
     "access": "public"
   },