pagyra-js 0.0.1

package/playground/server.d.ts

@@ -0,0 +1 @@
+export {};

package/playground/server.js

@@ -0,0 +1,68 @@
+import express from "express";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { renderHtmlToPdf, DEFAULT_PAGE_WIDTH_PX, DEFAULT_PAGE_HEIGHT_PX, resolvePageMarginsPx, sanitizeDimension, maxContentDimension, } from "../src/html-to-pdf.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PUBLIC_DIR = path.join(__dirname, "public");
+const app = express();
+app.use(express.json({ limit: "2mb" }));
+// Add a logger middleware to debug static file requests
+app.use((req, res, next) => {
+    console.log(`[playground] request: ${req.method} ${req.url}`);
+    next();
+});
+app.use(express.static(PUBLIC_DIR));
+app.post("/render", async (req, res) => {
+    try {
+        const body = req.body;
+        if (!body || typeof body.html !== "string") {
+            res.status(400).json({ error: "Request must include an 'html' field." });
+            return;
+        }
+        const cssInput = typeof body.css === "string" ? body.css : "";
+        const htmlInput = body.html;
+        const pageWidth = sanitizeDimension(body.pageWidth, DEFAULT_PAGE_WIDTH_PX);
+        const pageHeight = sanitizeDimension(body.pageHeight, DEFAULT_PAGE_HEIGHT_PX);
+        const marginsPx = resolvePageMarginsPx(pageWidth, pageHeight);
+        const maxContentWidth = maxContentDimension(pageWidth, marginsPx.left + marginsPx.right);
+        const maxContentHeight = maxContentDimension(pageHeight, marginsPx.top + marginsPx.bottom);
+        const viewportWidth = Math.min(sanitizeDimension(body.viewportWidth, maxContentWidth), maxContentWidth);
+        const viewportHeight = Math.min(sanitizeDimension(body.viewportHeight, maxContentHeight), maxContentHeight);
+        let resourceBaseDir = PUBLIC_DIR;
+        const documentPath = typeof body.documentPath === "string" ? body.documentPath : undefined;
+        if (documentPath) {
+            const normalized = documentPath.startsWith("/") ? documentPath.slice(1) : documentPath;
+            const candidate = path.resolve(PUBLIC_DIR, normalized);
+            if (candidate.startsWith(PUBLIC_DIR)) {
+                resourceBaseDir = path.dirname(candidate);
+            }
+        }
+        const pdfBytes = await renderHtmlToPdf({
+            html: htmlInput,
+            css: cssInput,
+            viewportWidth,
+            viewportHeight,
+            pageWidth,
+            pageHeight,
+            margins: marginsPx,
+            debugLevel: "TRACE",
+            debugCats: ["PARSE", "STYLE", "RENDER_TREE", "ENCODING", "FONT", "PAINT"],
+            resourceBaseDir,
+            assetRootDir: PUBLIC_DIR,
+        });
+        res.setHeader("Content-Type", "application/pdf");
+        res.send(Buffer.from(pdfBytes));
+    }
+    catch (error) {
+        console.error("[playground] render error:", error);
+        res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
+    }
+});
+const port = Number.parseInt(process.env.PORT ?? "", 10) || 5177;
+const entryUrl = process.argv[1] ? pathToFileURL(process.argv[1]).href : undefined;
+if (entryUrl === import.meta.url) {
+    app.listen(port, () => {
+        console.log(`Pagyra HTML-to-PDF playground running at http://localhost:${port}`);
+    });
+}

package/playground/server.ts

@@ -0,0 +1,128 @@
+import express from "express";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { renderHtmlToPdf } from "../src/html-to-pdf.js";
+import {
+  DEFAULT_PAGE_WIDTH_PX,
+  DEFAULT_PAGE_HEIGHT_PX,
+  resolvePageMarginsPx,
+  sanitizeDimension,
+  maxContentDimension,
+} from "../src/units/page-utils.js";
+import type { HeaderFooterHTML } from "../src/pdf/types.js";
+import { type LogLevel, LOG_CATEGORIES } from "../src/logging/debug.js";
+
+interface RenderRequestBody {
+  html?: string;
+  css?: string;
+  viewportWidth?: number;
+  viewportHeight?: number;
+  pageWidth?: number;
+  pageHeight?: number;
+  documentPath?: string;
+  headerHtml?: string;
+  footerHtml?: string;
+  debugLevel?: LogLevel;
+  debugCats?: string[];
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PUBLIC_DIR = path.join(__dirname, "public");
+
+const app = express();
+app.use(express.json({ limit: "2mb" }));
+
+// Add a logger middleware to debug static file requests
+app.use((req: express.Request, _res: express.Response, next: express.NextFunction) => {
+  console.log(`[playground] request: ${req.method} ${req.url}`);
+  next();
+});
+
+app.use(express.static(PUBLIC_DIR));
+
+app.get("/debug-categories", (_req, res) => {
+  res.json(LOG_CATEGORIES);
+});
+
+app.post("/render", async (req: express.Request, res: express.Response) => {
+  try {
+    const body = req.body as RenderRequestBody;
+    if (!body || typeof body.html !== "string") {
+      res.status(400).json({ error: "Request must include an 'html' field." });
+      return;
+    }
+
+    const cssInput = typeof body.css === "string" ? body.css : "";
+    const htmlInput = body.html;
+    const pageWidth = sanitizeDimension(body.pageWidth, DEFAULT_PAGE_WIDTH_PX);
+    const pageHeight = sanitizeDimension(body.pageHeight, DEFAULT_PAGE_HEIGHT_PX);
+    const marginsPx = resolvePageMarginsPx(pageWidth, pageHeight);
+    const maxContentWidth = maxContentDimension(pageWidth, marginsPx.left + marginsPx.right);
+    const maxContentHeight = maxContentDimension(pageHeight, marginsPx.top + marginsPx.bottom);
+    const viewportWidth = Math.min(sanitizeDimension(body.viewportWidth, maxContentWidth), maxContentWidth);
+    const viewportHeight = Math.min(sanitizeDimension(body.viewportHeight, maxContentHeight), maxContentHeight);
+
+    let resourceBaseDir = PUBLIC_DIR;
+    const documentPath = typeof body.documentPath === "string" ? body.documentPath : undefined;
+    if (documentPath) {
+      const normalized = documentPath.startsWith("/") ? documentPath.slice(1) : documentPath;
+      const candidate = path.resolve(PUBLIC_DIR, normalized);
+      if (candidate.startsWith(PUBLIC_DIR)) {
+        resourceBaseDir = path.dirname(candidate);
+      }
+    }
+
+    const headerHtml = typeof body.headerHtml === "string" ? body.headerHtml.trim() : "";
+    const footerHtml = typeof body.footerHtml === "string" ? body.footerHtml.trim() : "";
+    const levelCandidate = typeof body.debugLevel === "string" ? (body.debugLevel.toLowerCase() as LogLevel) : undefined;
+    const allowedLevels: LogLevel[] = ["trace", "debug", "info", "warn", "error"];
+    let debugLevel: LogLevel = levelCandidate && allowedLevels.includes(levelCandidate) ? levelCandidate : "info";
+    const debugCats = Array.isArray(body.debugCats) ? body.debugCats.map(String).filter(Boolean) : undefined;
+
+    const headerFooter: Partial<HeaderFooterHTML> = {};
+    if (headerHtml) {
+      headerFooter.headerHtml = headerHtml;
+      headerFooter.maxHeaderHeightPx = headerFooter.maxHeaderHeightPx ?? 64;
+    }
+    if (footerHtml) {
+      headerFooter.footerHtml = footerHtml;
+      headerFooter.maxFooterHeightPx = headerFooter.maxFooterHeightPx ?? 64;
+    }
+
+    // If categories are selected, the user likely wants to see debug output for them.
+    // If the level is at the default 'info', we lower it to 'debug' to ensure they see something.
+    if (debugCats?.length && debugLevel === "info") {
+      debugLevel = "debug";
+    }
+
+    const pdfBytes = await renderHtmlToPdf({
+      html: htmlInput,
+      css: cssInput,
+      viewportWidth,
+      viewportHeight,
+      pageWidth,
+      pageHeight,
+      margins: marginsPx,
+      debugLevel,
+      debugCats: debugCats?.length ? debugCats : undefined,
+      resourceBaseDir,
+      assetRootDir: PUBLIC_DIR,
+      headerFooter: Object.keys(headerFooter).length > 0 ? headerFooter : undefined,
+    });
+
+    res.setHeader("Content-Type", "application/pdf");
+    res.send(Buffer.from(pdfBytes));
+  } catch (error) {
+    console.error("[playground] render error:", error);
+    res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
+  }
+});
+
+const port = Number.parseInt(process.env.PORT ?? "", 10) || 5177;
+const entryUrl = process.argv[1] ? pathToFileURL(process.argv[1]).href : undefined;
+if (entryUrl === import.meta.url) {
+  app.listen(port, () => {
+    console.log(`Pagyra HTML-to-PDF playground running at http://localhost:${port}`);
+  });
+}

package/scripts/browser-build.ts

@@ -0,0 +1,101 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import esbuild, { type BuildOptions, type BuildFailure, type Plugin, type PluginBuild } from "esbuild";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, "..");
+
+const resolveProjectPath = (relativePath: string): string => path.resolve(PROJECT_ROOT, relativePath);
+
+const alias: Record<string, string> = {
+  "node:path": resolveProjectPath("src/shim/empty.ts"),
+  path: resolveProjectPath("src/shim/empty.ts"),
+  "node:url": resolveProjectPath("src/shim/url-empty.ts"),
+  url: resolveProjectPath("src/shim/url-empty.ts"),
+  "node:fs/promises": resolveProjectPath("src/shim/fs-empty.ts"),
+  fs: resolveProjectPath("src/shim/fs-empty.ts"),
+  "node:zlib": resolveProjectPath("src/shim/zlib-empty.ts"),
+  zlib: resolveProjectPath("src/shim/zlib-empty.ts"),
+  "node:util": resolveProjectPath("src/shim/empty.ts"),
+  util: resolveProjectPath("src/shim/empty.ts"),
+  "src/environment/node-environment.ts": resolveProjectPath("src/environment/node-environment.browser.ts"),
+  "src/pdf/font/builtin-fonts.ts": resolveProjectPath("src/pdf/font/builtin-fonts.browser.ts"),
+};
+
+export interface BrowserBundleOptions {
+  entry: string;
+  outfile: string;
+  minify?: boolean;
+  sourcemap?: boolean | "external" | "inline";
+  watch?: boolean;
+  onRebuild?: (error: BuildFailure | null, result: unknown | null) => void;
+}
+
+function buildOptionsFor(opts: BrowserBundleOptions): BuildOptions {
+  const entryPoints = [resolveProjectPath(opts.entry)];
+  const outfile = resolveProjectPath(opts.outfile);
+
+  const plugins: Plugin[] = [];
+
+  if (opts.watch) {
+    let isFirst = true;
+    plugins.push({
+      name: "watch-callback",
+      setup(build: PluginBuild) {
+        build.onEnd((result) => {
+          if (isFirst) {
+            isFirst = false;
+            return;
+          }
+          if (opts.onRebuild) {
+            const hasErrors = result.errors?.length;
+            opts.onRebuild(hasErrors ? (result as unknown as BuildFailure) : null, result);
+            return;
+          }
+          if (result.errors?.length) {
+            console.error("[browser bundle] rebuild failed:", result.errors);
+          } else {
+            console.log("[browser bundle] rebuild succeeded.");
+          }
+        });
+      },
+    } as esbuild.Plugin);
+  }
+
+  const config: BuildOptions = {
+    entryPoints,
+    outfile,
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    mainFields: ["browser", "module", "main"],
+    alias,
+    minify: opts.minify ?? false,
+    sourcemap: opts.sourcemap ?? false,
+    plugins,
+  };
+
+  return config;
+}
+
+export interface BrowserBundleResult {
+  stop?: () => Promise<void> | void;
+}
+
+export async function buildBrowserBundle(opts: BrowserBundleOptions): Promise<BrowserBundleResult> {
+  console.log(`[browser bundle] ${opts.entry} → ${opts.outfile} (${opts.watch ? "watch" : "build"})`);
+  const config = buildOptionsFor(opts);
+
+  if (!opts.watch) {
+    await esbuild.build(config);
+    console.log("[browser bundle] build complete");
+    return {};
+  }
+
+  const context = await esbuild.context(config);
+  await context.watch();
+  console.log("[browser bundle] initial build complete, watching for changes…");
+  return {
+    stop: () => context.dispose(),
+  };
+}

package/scripts/build-browser-bundle.ts

@@ -0,0 +1,52 @@
+import { buildBrowserBundle } from "./browser-build.js";
+
+const args = process.argv.slice(2);
+const getArg = (prefix: string): string | undefined => {
+  const match = args.find((arg) => arg.startsWith(prefix));
+  return match ? match.slice(prefix.length) : undefined;
+};
+
+const target = getArg("--target=") ?? "dist";
+const watch = args.includes("--watch");
+const explicitMinify = args.includes("--minify");
+const explicitSourcemap = args.includes("--sourcemap");
+
+const targetConfigs: Record<
+  string,
+  { entry: string; outfile: string; minify: boolean; sourcemap: boolean }
+> = {
+  dist: {
+    entry: "src/browser-entry.ts",
+    outfile: "dist/browser/pagyra.min.js",
+    minify: true,
+    sourcemap: true,
+  },
+  playground: {
+    entry: "playground/browser-entry.ts",
+    outfile: "playground/public/vendor/pagyra-playground-browser.js",
+    minify: false,
+    sourcemap: true,
+  },
+};
+
+const targetConfig = targetConfigs[target] ?? targetConfigs.dist;
+
+const entry = getArg("--entry=") ?? targetConfig.entry;
+const outfile = getArg("--outfile=") ?? targetConfig.outfile;
+const minify = explicitMinify || targetConfig.minify;
+const sourcemap = explicitSourcemap || targetConfig.sourcemap;
+
+const buildOptions = {
+  entry,
+  outfile,
+  minify,
+  sourcemap,
+  watch,
+};
+
+try {
+  await buildBrowserBundle(buildOptions);
+} catch (error) {
+  console.error("[build-browser-bundle] failed:", error);
+  process.exit(1);
+}