wasm-html-to-image 1.0.14 → 1.0.15

package/dist/cli-options.d.ts

@@ -23,6 +23,8 @@ export interface CliFlags {
      * Absent means infinite (libwebp loop_count 0 = the historical default).
      */
     animationLoop?: number;
+    /** `--font <path-or-glob>` (repeatable); local font files to register. */
+    font?: string[];
 }
 /** Default frame rate for `--animation` when `--animation-fps` is omitted. */
 export declare const DEFAULT_ANIMATION_FPS = 15;
@@ -47,6 +49,19 @@ export interface AnimationResolution {
 }
 /** Map `--animation` / `--animation-fps` / `--animation-loop` to the `render()` animation option. */
 export declare function resolveAnimation(flags: CliFlags): AnimationResolution;
+/** Output format implied by the output file's extension, if recognised. */
+export declare function inferFormat(output: string | undefined): OutputFormat | undefined;
+/** Inline markup passed on the command line (as opposed to a path or URL). */
+export declare function isInlineHtml(input: string): boolean;
+/** Read all of standard input as UTF-8 text. */
+export declare function readStdin(): Promise<string>;
+/** Expand `*` / `?` in the last path segment; other patterns are literal paths. */
+export declare function expandGlob(pattern: string): Promise<string[]>;
+/** Load `--font` files; each is named after its file (without extension). */
+export declare function loadFonts(patterns: string[]): Promise<{
+    name: string;
+    data: Uint8Array;
+}[]>;
 /**
  * URL inputs are fetched, not read from disk. `data:` URLs stay values so
  * image inputs keep flowing through the converter pipeline.

package/dist/cli-options.js

@@ -38,6 +38,73 @@ export function resolveAnimation(flags) {
         },
     };
 }
+const EXTENSION_FORMATS = {
+    png: "png",
+    jpg: "jpeg",
+    jpeg: "jpeg",
+    webp: "webp",
+    apng: "apng",
+    gif: "gif",
+    svg: "svg",
+    pdf: "pdf",
+    tif: "tiff",
+    tiff: "tiff",
+    avif: "avif",
+    jxl: "jxl",
+};
+/** Output format implied by the output file's extension, if recognised. */
+export function inferFormat(output) {
+    if (!output)
+        return undefined;
+    const ext = path.extname(output).slice(1).toLowerCase();
+    return EXTENSION_FORMATS[ext];
+}
+/** Inline markup passed on the command line (as opposed to a path or URL). */
+export function isInlineHtml(input) {
+    return input.trimStart().startsWith("<");
+}
+/** Read all of standard input as UTF-8 text. */
+export async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf-8");
+}
+/** Expand `*` / `?` in the last path segment; other patterns are literal paths. */
+export async function expandGlob(pattern) {
+    if (!/[*?]/.test(pattern))
+        return [pattern];
+    const dir = path.dirname(pattern);
+    const re = new RegExp("^" +
+        path
+            .basename(pattern)
+            .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+            .replace(/\*/g, ".*")
+            .replace(/\?/g, ".") +
+        "$");
+    const names = await fs.readdir(dir);
+    return names
+        .filter((n) => re.test(n))
+        .sort()
+        .map((n) => path.join(dir, n));
+}
+/** Load `--font` files; each is named after its file (without extension). */
+export async function loadFonts(patterns) {
+    const fonts = [];
+    for (const pattern of patterns) {
+        const files = await expandGlob(pattern);
+        if (files.length === 0) {
+            console.warn(`wasm-html-to-image: no font files match "${pattern}"`);
+        }
+        for (const file of files) {
+            fonts.push({
+                name: path.basename(file, path.extname(file)),
+                data: new Uint8Array(await fs.readFile(file)),
+            });
+        }
+    }
+    return fonts;
+}
 /**
  * URL inputs are fetched, not read from disk. `data:` URLs stay values so
  * image inputs keep flowing through the converter pipeline.
@@ -72,9 +139,14 @@ export async function readInput(input) {
  * (`resolveHtmlSource`), while a file input falls back to its own directory.
  */
 export async function buildRenderOptions(input, flags) {
-    const source = isUrlInput(input)
-        ? { url: input }
-        : await readInput(input);
+    const source = isInlineHtml(input)
+        ? { value: input, baseUrl: process.cwd() }
+        : input === "-"
+            ? { value: await readStdin(), baseUrl: process.cwd() }
+            : isUrlInput(input)
+                ? { url: input }
+                : await readInput(input);
+    const fonts = flags.font?.length ? await loadFonts(flags.font) : [];
     const { animation, warning } = resolveAnimation(flags);
     if (warning)
         console.warn(`wasm-html-to-image: ${warning}`);
@@ -89,5 +161,6 @@ export async function buildRenderOptions(input, flags) {
         ...(flags.scale !== undefined ? { scale: flags.scale } : {}),
         ...(flags.dpi !== undefined ? { dpi: flags.dpi } : {}),
         ...(animation ? { animation } : {}),
+        ...(fonts.length ? { fonts } : {}),
     };
 }

package/dist/cli.js

@@ -3,7 +3,7 @@ import { program } from "commander";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { render } from "./single.js";
-import { buildRenderOptions, isUrlInput } from "./cli-options.js";
+import { buildRenderOptions, inferFormat, isInlineHtml, isUrlInput, } from "./cli-options.js";
 const OUTPUT_FORMATS = [
     "svg",
     "png",
@@ -26,11 +26,12 @@ program
     .name("wasm-html-to-image")
     .description("HTML to image converter on the single unified WASM module (svg/pdf direct, png/jpeg/webp/avif/jxl/raw/thumbhash via encode or html_to_image)")
     .version("0.1.0")
-    .argument("<input>", "input HTML/image file path or URL")
+    .argument("<input>", "input HTML/image file path, URL, inline HTML string (starts with <), or - for stdin")
     .option("-o, --output <path>", "output file path")
     .option("-w, --width <number>", "viewport width", (v) => parseInt(v, 10), 800)
     .option("-h, --height <number>", "viewport height (omit for auto)", (v) => parseInt(v, 10))
-    .option("-f, --format <format>", `output format (${OUTPUT_FORMATS.join(", ")})`, "png")
+    .option("-f, --format <format>", `output format (${OUTPUT_FORMATS.join(", ")}); default: from the --output extension, else png`)
+    .option("--font <path>", "local font file or glob such as './fonts/*.woff2' (repeatable)", (v, prev = []) => [...prev, v])
     .option("-q, --quality <number>", "encode quality 0-100 (encode stage only)", (v) => parseFloat(v), 85)
     .option("--base-url <url>", "base URL for relative resources (URL input: defaults to the post-redirect document URL; file input: defaults to the file's directory)")
     .option("--color-space <srgb|cmyk>", "output color space of tiff and pdf (default srgb; cmyk rewrites colors for print, with no ICC profile)", (v) => v.toLowerCase())
@@ -41,7 +42,7 @@ program
     .option("--animation-loop <n>", "how many times the animated WebP / APNG / GIF repeats (0 = infinite, the default; 1 = play once; requires --animation)", (v) => parseInt(v, 10))
     .action(async (input, options) => {
     try {
-        const format = String(options.format).toLowerCase();
+        const format = String(options.format ?? inferFormat(options.output) ?? "png").toLowerCase();
         if (!isOutputFormat(format)) {
             console.error(`Error: unsupported format "${options.format}". Choose from: ${OUTPUT_FORMATS.join(", ")}`);
             process.exit(1);
@@ -53,10 +54,15 @@ program
             process.exit(1);
         }
         const isUrl = isUrlInput(input);
+        const isVirtual = isInlineHtml(input) || input === "-";
+        if (isVirtual && !options.output) {
+            console.error("Error: --output is required for inline HTML or stdin input");
+            process.exit(1);
+        }
         let outputPath = options.output;
         if (!outputPath) {
             const ext = format;
-            outputPath = isUrl
+            outputPath = isUrl || isVirtual
                 ? `output.${ext}`
                 : path.format({
                     dir: path.dirname(input),
@@ -77,6 +83,7 @@ program
             animation: options.animation,
             animationFps: options.animationFps,
             animationLoop: options.animationLoop,
+            font: options.font,
         };
         const result = await render(await buildRenderOptions(input, flags));
         await fs.writeFile(outputPath, typeof result.data === "string"