@silurus/ooxml 0.62.0 → 0.64.0

package/dist/types/xlsx.d.ts

@@ -462,8 +462,20 @@ export declare interface ImageAnchor {
      *  size. Authoritative when `editAs === "oneCell"`. 0 = unavailable. */
     nativeExtCx: number;
     nativeExtCy: number;
-    /** Data URL (data:image/png;base64,...) */
-    dataUrl: string;
+    /** Zip path of the blip inside the package (e.g. `xl/media/image1.png`). The
+     *  blip's own `r:embed` raster fallback when an svgBlip extension is present;
+     *  otherwise the only source. Falls back to the SVG part itself when the
+     *  picture has no raster `r:embed`. Bytes are fetched lazily by path. */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageAnchor.imagePath} (e.g. `image/png`,
+     *  or `image/svg+xml` for the SVG-only fallback). */
+    mimeType: string;
+    /** Vector original from the Microsoft `asvg:svgBlip` extension (MS-ODRAWXML),
+     *  as a zip path. Preferred over `imagePath` (the raster fallback, or the SVG
+     *  itself when no raster blip is embedded). Absent when the picture carries no
+     *  svgBlip extension. Its MIME is always `image/svg+xml` and is owned by the
+     *  SVG decoder. */
+    svgImagePath?: string;
 }
 
 export declare interface LegendManualLayout {
@@ -743,8 +755,15 @@ export declare interface RenderViewportOptions {
     freezeCols?: number;
     /** Scale factor applied to all cell/header dimensions (default 1). */
     cellScale?: number;
-    /** Pre-decoded image sources keyed by their dataUrl (for ImageAnchor rendering). */
+    /** Pre-decoded image sources keyed by their zip `imagePath` (for ImageAnchor
+     *  and group-leaf image rendering). */
     loadedImages?: Map<string, CanvasImageSource>;
+    /** Fetch an embedded image's bytes by zip path, wrapped in a Blob of the given
+     *  MIME (twin of pptx/docx `fetchImage`). The orchestrator decodes these into
+     *  {@link loadedImages} before the synchronous draw. Supplied by
+     *  {@link XlsxWorkbook} (routing through the worker) or the render worker
+     *  (reading its retained buffer). Absent ⇒ no images are decoded. */
+    fetchImage?: (path: string, mimeType: string) => Promise<Blob>;
     /** Called once per cell that contains text, with canvas-pixel position and cell address. */
     onTextRun?: (info: XlsxTextRunInfo) => void;
     /** Highlighted row range for selected row headers (1-indexed inclusive).
@@ -857,12 +876,22 @@ export declare type ShapeGeom = {
     type: 'custom';
     paths: PathInfo[];
 }
-/** Bitmap picture leaf inside a `<xdr:grpSp>`. `dataUrl` is a pre-encoded
-*  `data:<mime>;base64,…` produced by the Rust parser from the drawing's
-*  relationship target. */
+/** Bitmap (or vector) picture leaf inside a `<xdr:grpSp>`. `imagePath` is the
+*  zip path of the drawing's relationship target — the blip's raster `r:embed`
+*  fallback, or the SVG itself when no raster is embedded — and `mimeType` its
+*  MIME. Bytes are fetched lazily by path; nothing is inlined as base64. */
 | {
     type: 'image';
-    dataUrl: string;
+    imagePath: string;
+    /** MIME type of the blip at {@link imagePath} (e.g. `image/png`, or
+     *  `image/svg+xml` for the SVG-only fallback). */
+    mimeType: string;
+    /** Vector original from the Microsoft `asvg:svgBlip` extension
+     *  (MS-ODRAWXML), as a zip path. Prefer this over `imagePath` (the raster
+     *  fallback, or the SVG itself when no raster blip is embedded). Absent
+     *  when the picture carries no svgBlip extension. Its MIME is always
+     *  `image/svg+xml` and is owned by the SVG decoder. */
+    svgImagePath?: string;
 };
 
 export declare interface ShapeInfo {
@@ -1073,9 +1102,10 @@ export declare interface ViewportRange {
     cols: number;
 }
 
-/** Serializable subset of RenderViewportOptions: drop the callback and the
- *  image cache (the worker owns its own). */
-export declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages'>;
+/** Serializable subset of RenderViewportOptions: drop the callback, the image
+ *  cache, and the `fetchImage` loader (all non-cloneable; the worker owns its
+ *  own cache and supplies its own in-worker fetchImage). */
+export declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages' | 'fetchImage'>;
 
 export declare interface Workbook {
     sheets: SheetMeta[];
@@ -1528,8 +1558,19 @@ export declare class XlsxWorkbook {
     private bridge;
     private parsedWorkbook;
     private sheetCache;
-    /** Cache of decoded image bitmaps keyed by their data URL. Shared across sheets. */
+    /** Cache of decoded image sources keyed by their zip `imagePath`. Shared
+     *  across sheets. */
     private imageCache;
+    /** Cache of fetched image *bytes* (as Blobs) keyed by zip path, populated by
+     *  {@link XlsxWorkbook.getImage}. Twin of pptx/docx's per-instance
+     *  `_imageCache`; kept separate from {@link XlsxWorkbook.imageCache} (decoded
+     *  sources) so each layer dedupes independently. */
+    private imageBlobCache;
+    /** One stable closure per instance: core's path-keyed SVG cache namespaces on
+     *  this identity, so two open workbooks never swap a shared zip path (e.g.
+     *  xl/media/image1.svg). Reusing one reference also lets the SVG cache hit
+     *  across viewport renders. */
+    private readonly _fetchImage;
     private rawData;
     private maxZipEntryBytes;
     /** Opt-in OMML equation engine, injected once at {@link load}. Every
@@ -1547,6 +1588,19 @@ export declare class XlsxWorkbook {
      *  `null` for sheets that declare no tab color. */
     get tabColors(): (string | null)[];
     getWorksheet(sheetIndex: number): Promise<Worksheet>;
+    /**
+     * Fetch an embedded image's bytes by zip path (e.g. `xl/media/image1.png`),
+     * wrapped in a Blob of the given MIME. The bytes are pulled through the
+     * persistent worker via the `extractImage` message (twin of pptx/docx's
+     * `getImage`/`getMedia`); results are cached by path for the lifetime of this
+     * instance. The renderer's `fetchImage` option points here so image bytes are
+     * extracted lazily rather than inlined as base64 at parse time.
+     *
+     * Routed through the worker even though the main thread also retains
+     * `rawData`, to keep all WASM `extract_image` decoding on the worker (the
+     * route-through-worker decision).
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     /**
      * Resolve a `list`-type data-validation `formula1` (ECMA-376 §18.3.1.32) into
      * the set of allowed values to display, evaluated relative to `sheetIndex`