@qrcommunication/gigapdf-lib 0.1.0 → 0.8.0

package/dist/index.js

@@ -84,6 +84,10 @@ var GigaPdfEngine = class _GigaPdfEngine {
       this._free(ptr, b.length);
     }
   }
+  /** Pass an optional string; an absent/empty value runs `fn(0, 0)` (no alloc). */
+  _withOptStr(s, fn) {
+    return s ? this._withStr(s, fn) : fn(0, 0);
+  }
   /** Pass a bytes argument; runs `fn(ptr, len)` then frees. */
   _withBytes(bytes, fn) {
     const ptr = this._toWasm(bytes);
@@ -165,8 +169,194 @@ var GigaPdfEngine = class _GigaPdfEngine {
   parseCssFontUrl(css) {
     return this._withStr(css, (p, l) => this._str((o) => this.ex.gp_parse_css_font_url(p, l, o)));
   }
+  // ── JavaScript engine (no headless browser) ────────────────────────────────
+  /**
+   * Evaluate a JavaScript snippet with the built-in engine and return the
+   * result value as a string (or `Uncaught …` / `SyntaxError: …`).
+   */
+  evalJs(src) {
+    return this._withStr(src, (p, l) => this._str((o) => this.ex.gp_js_eval(p, l, o)));
+  }
+  /**
+   * Run a document's inline `<script>`s and return the resulting HTML. The
+   * `htmlRender`/`htmlNeededFonts` paths already do this automatically; use this
+   * only when you want the post-script HTML on its own.
+   */
+  runInlineScripts(html) {
+    return this._withStr(
+      html,
+      (p, l) => this._str((o) => this.ex.gp_run_inline_scripts(p, l, o))
+    );
+  }
+  // ── HTML rendering engine (replaces a headless browser for HTML→PDF) ───────
+  /**
+   * Phase 1 — the Google fonts the document references. Download each `url`
+   * (→ TTF) and pass the bytes back to {@link htmlRender} for an identical render.
+   */
+  htmlNeededFonts(html) {
+    return this._withStr(
+      html,
+      (p, l) => this._json((o) => this.ex.gp_html_needed_fonts(p, l, o))
+    );
+  }
+  /**
+   * Phase 2 — render HTML + CSS to PDF, with the supplied fonts embedded (real
+   * Google fonts, real metrics → identical or nearest match). Block, inline and
+   * table layout with pagination. Page size and margin are in points
+   * (US-Letter portrait, 0.5in margins by default). JavaScript is not executed.
+   */
+  htmlRender(html, fonts = [], pageWidth = 612, pageHeight = 792, margin = 36) {
+    const blob = packHtmlFonts(fonts);
+    return this._withStr(
+      html,
+      (hp, hl) => this._withBytes(
+        blob,
+        (fp, fl) => this._buffer((o) => this.ex.gp_html_render(hp, hl, fp, fl, pageWidth, pageHeight, margin, o))
+      )
+    );
+  }
+  /**
+   * Resolve a named paper size — `"A4"`, `"a3-landscape"`, `"letter"`, `"legal"`,
+   * `"tabloid"`, `"b5"`, … — to `{ w, h }` in points (portrait unless the name
+   * has a `-landscape` suffix). Returns `null` for an unknown name.
+   */
+  pageSize(name) {
+    const outPtr = this.ex.gp_alloc(16);
+    try {
+      const ok = this._withStr(
+        name,
+        (p, l) => this.ex.gp_page_size(p, l, outPtr, outPtr + 8)
+      );
+      if (!ok) return null;
+      const dv = this.dv();
+      return { w: dv.getFloat64(outPtr, true), h: dv.getFloat64(outPtr + 8, true) };
+    } finally {
+      this._free(outPtr, 16);
+    }
+  }
+  /**
+   * Phase 1 variant that also scans the running `header`/`footer` HTML, so the
+   * Google fonts they reference are requested alongside the body's.
+   */
+  htmlNeededFontsWith(html, header, footer) {
+    return this._withStr(
+      html,
+      (hp, hl) => this._withOptStr(
+        header,
+        (hdp, hdl) => this._withOptStr(
+          footer,
+          (ftp, ftl) => this._json((o) => this.ex.gp_html_needed_fonts_ex(hp, hl, hdp, hdl, ftp, ftl, o))
+        )
+      )
+    );
+  }
+  /**
+   * Phase 2 with full page control: named/explicit size, per-side margins, and a
+   * running header/footer painted in the page margins. `{{page}}` and `{{pages}}`
+   * in the header/footer are replaced with the current / total page number.
+   *
+   * ```ts
+   * const fonts = await fetchFonts(giga.htmlNeededFontsWith(html, header, footer));
+   * const pdf = giga.htmlRenderWith(html, fonts, {
+   *   pageSize: "A4",
+   *   margin: { top: 72, bottom: 72, left: 54, right: 54 },
+   *   header: `<div style="text-align:center">My Report</div>`,
+   *   footer: `<div style="text-align:center">Page {{page}} / {{pages}}</div>`,
+   * });
+   * ```
+   */
+  htmlRenderWith(html, fonts = [], options = {}) {
+    let pw = options.pageWidth ?? 612;
+    let ph = options.pageHeight ?? 792;
+    if (options.pageSize) {
+      const sz = this.pageSize(options.pageSize);
+      if (!sz) throw new Error(`gigapdf: unknown page size "${options.pageSize}"`);
+      pw = sz.w;
+      ph = sz.h;
+    }
+    const m = options.margin ?? 36;
+    const mg = typeof m === "number" ? { top: m, right: m, bottom: m, left: m } : { top: m.top ?? 36, right: m.right ?? 36, bottom: m.bottom ?? 36, left: m.left ?? 36 };
+    const headerOffset = options.headerOffset ?? 18;
+    const footerOffset = options.footerOffset ?? 18;
+    const start = options.startPageNumber ?? 1;
+    const blob = packHtmlFonts(fonts);
+    return this._withStr(
+      html,
+      (hp, hl) => this._withBytes(
+        blob,
+        (fp, fl) => this._withOptStr(
+          options.header,
+          (hdp, hdl) => this._withOptStr(
+            options.footer,
+            (ftp, ftl) => this._buffer(
+              (o) => this.ex.gp_html_render_opts(
+                hp,
+                hl,
+                fp,
+                fl,
+                pw,
+                ph,
+                mg.top,
+                mg.right,
+                mg.bottom,
+                mg.left,
+                hdp,
+                hdl,
+                ftp,
+                ftl,
+                headerOffset,
+                footerOffset,
+                start,
+                o
+              )
+            )
+          )
+        )
+      )
+    );
+  }
 };
+function packHtmlFonts(fonts) {
+  let size = 4;
+  for (const f of fonts) size += 4 + enc.encode(f.family).length + 2 + 1 + 4 + f.ttf.length;
+  const buf = new Uint8Array(size);
+  const dv = new DataView(buf.buffer);
+  let o = 0;
+  dv.setUint32(o, fonts.length, true);
+  o += 4;
+  for (const f of fonts) {
+    const fam = enc.encode(f.family);
+    dv.setUint32(o, fam.length, true);
+    o += 4;
+    buf.set(fam, o);
+    o += fam.length;
+    dv.setUint16(o, f.weight, true);
+    o += 2;
+    buf[o] = f.italic ? 1 : 0;
+    o += 1;
+    dv.setUint32(o, f.ttf.length, true);
+    o += 4;
+    buf.set(f.ttf, o);
+    o += f.ttf.length;
+  }
+  return buf;
+}
 var RGB = (rgb) => rgb & 16777215;
+function styleArgs(s = {}) {
+  const hasBorder = s.border === null ? 0 : 1;
+  const borderRgb = s.border == null ? 0 : s.border;
+  const hasBg = s.background == null ? 0 : 1;
+  const bgRgb = s.background == null ? 0 : s.background;
+  return [
+    s.fontSize ?? 0,
+    RGB(s.color ?? 0),
+    RGB(borderRgb),
+    hasBorder,
+    RGB(bgRgb),
+    hasBg,
+    s.borderWidth ?? 1
+  ];
+}
 var GigaPdfDoc = class {
   constructor(g, h) {
     this.g = g;
@@ -233,7 +423,7 @@ var GigaPdfDoc = class {
    * Draw a vector rectangle. Pass an `0xRRGGBB` colour for `stroke`/`fill`, or
    * `null` to omit that paint. 0 → success.
    */
-  addRectangle(page, x, y, w, h, stroke = null, fill = 0, lineWidth = 1) {
+  addRectangle(page, x, y, w, h, stroke = null, fill = 0, lineWidth = 1, opacity = 1) {
     return this.ex().gp_add_rectangle(
       this.h,
       page,
@@ -245,9 +435,99 @@ var GigaPdfDoc = class {
       stroke === null ? 0 : 1,
       RGB(fill ?? 0),
       fill === null ? 0 : 1,
-      lineWidth
+      lineWidth,
+      opacity
+    ) === 0;
+  }
+  /** Draw a straight line from `(x1,y1)` to `(x2,y2)`. `stroke` is `0xRRGGBB`. */
+  drawLine(page, x1, y1, x2, y2, stroke = 0, lineWidth = 1, opacity = 1) {
+    return this.ex().gp_draw_line(this.h, page, x1, y1, x2, y2, RGB(stroke), lineWidth, opacity) === 0;
+  }
+  /**
+   * Draw an ellipse (circle when `rx === ry`) centred at `(cx,cy)`. Pass an
+   * `0xRRGGBB` colour for `stroke`/`fill`, or `null` to omit that paint.
+   */
+  addEllipse(page, cx, cy, rx, ry, stroke = null, fill = 0, lineWidth = 1, opacity = 1) {
+    return this.ex().gp_add_ellipse(
+      this.h,
+      page,
+      cx,
+      cy,
+      rx,
+      ry,
+      RGB(stroke ?? 0),
+      stroke === null ? 0 : 1,
+      RGB(fill ?? 0),
+      fill === null ? 0 : 1,
+      lineWidth,
+      opacity
+    ) === 0;
+  }
+  /**
+   * Draw a polyline/polygon through flat `[x0,y0,x1,y1,…]` points. `close` joins
+   * the last vertex back to the first. `0xRRGGBB` colours, or `null` to omit.
+   */
+  addPolygon(page, points, close = true, stroke = null, fill = 0, lineWidth = 1, opacity = 1) {
+    return this.g._withF64(
+      points,
+      (p, c) => this.ex().gp_add_polygon(
+        this.h,
+        page,
+        p,
+        c,
+        close ? 1 : 0,
+        RGB(stroke ?? 0),
+        stroke === null ? 0 : 1,
+        RGB(fill ?? 0),
+        fill === null ? 0 : 1,
+        lineWidth,
+        opacity
+      )
+    ) === 0;
+  }
+  /**
+   * Draw an SVG path (`M`/`L`/`C`/`Q`/`Z`…) anchored so the SVG origin maps to
+   * `(ox,oy)` with the Y axis flipped — same convention as `pdf-lib`'s
+   * `drawSvgPath`. Covers freeform/polygon/triangle shapes.
+   */
+  addPath(page, svgPath, ox, oy, stroke = null, fill = 0, lineWidth = 1, opacity = 1) {
+    return this.g._withStr(
+      svgPath,
+      (p, l) => this.ex().gp_add_path(
+        this.h,
+        page,
+        p,
+        l,
+        ox,
+        oy,
+        RGB(stroke ?? 0),
+        stroke === null ? 0 : 1,
+        RGB(fill ?? 0),
+        fill === null ? 0 : 1,
+        lineWidth,
+        opacity
+      )
+    ) === 0;
+  }
+  /**
+   * Embed a raster image (PNG or JPEG bytes) at `(x,y)` sized `(w,h)` in PDF
+   * user space. PNG alpha is honoured; `opacity` (0..1) sets an overall alpha.
+   */
+  addImage(page, data, x, y, w, h, opacity = 1) {
+    return this.g._withBytes(
+      data,
+      (p, l) => this.ex().gp_add_image(this.h, page, p, l, x, y, w, h, opacity)
     ) === 0;
   }
+  /**
+   * Draw SVG markup on a page as **native vector paths** (crisp at any zoom, not
+   * rasterized), fitting its `viewBox` into the box `(x, y, w, h)` in PDF points
+   * (origin bottom-left). Supports shapes, `<path>`, groups, transforms and
+   * fill/stroke/opacity. Returns `false` if the SVG can't be parsed.
+   */
+  addSvg(page, svg, x, y, w, h) {
+    return this.g._withStr(svg, (p, l) => this.ex().gp_add_svg(this.h, page, p, l, x, y, w, h)) === 0;
+  }
   /** True redaction: delete content intersecting the region (no opaque cover by default). */
   redact(page, x, y, w, h, coverRgb = 0, hasCover = false) {
     return this.ex().gp_redact_region(this.h, page, x, y, w, h, RGB(coverRgb), hasCover ? 1 : 0);
@@ -325,6 +605,10 @@ var GigaPdfDoc = class {
   toPptx() {
     return this.g._buffer((o) => this.ex().gp_to_pptx(this.h, o));
   }
+  /** Convert to an editable OpenDocument Presentation (`.odp`). */
+  toOdp() {
+    return this.g._buffer((o) => this.ex().gp_to_odp(this.h, o));
+  }
   toOdt() {
     return this.g._buffer((o) => this.ex().gp_to_odt(this.h, o));
   }
@@ -341,13 +625,54 @@ var GigaPdfDoc = class {
     return this.g._buffer((o) => this.ex().gp_to_pdfa(this.h, o));
   }
   // security
-  saveEncrypted(password, fileId, permissions = -44) {
+  /**
+   * Serialize the document encrypted with the PDF Standard Security Handler.
+   * Defaults to **AES-256 (R6)**. `fileId` is the document `/ID` (any stable
+   * hex/string). For AES-256 a **secret 32-byte key** is required — it is taken
+   * from `opts.keySeed` or generated with Web Crypto; RC4/AES-128 derive their
+   * key from the password and ignore it.
+   */
+  saveEncrypted(password, fileId, opts = {}) {
+    const algo = opts.algorithm ?? "aes256";
+    const algoCode = algo === "rc4" ? 0 : algo === "aes128" ? 1 : 2;
+    const permissions = opts.permissions ?? -44;
+    let key = opts.keySeed ?? new Uint8Array(0);
+    if (algoCode === 2 && key.length < 32) {
+      const c = globalThis.crypto;
+      if (!c?.getRandomValues) {
+        throw new Error(
+          "AES-256 encryption needs Web Crypto (globalThis.crypto.getRandomValues) or an explicit opts.keySeed"
+        );
+      }
+      const fresh = new Uint8Array(32);
+      c.getRandomValues(fresh);
+      key = fresh;
+    }
     return this.g._withStr(
       password,
-      (pwP, pwL) => this.g._withStr(
-        fileId,
-        (idP, idL) => this.g._buffer(
-          (o) => this.ex().gp_save_encrypted(this.h, pwP, pwL, idP, idL, permissions, o)
+      (pwP, pwL) => this.g._withOptStr(
+        opts.ownerPassword,
+        (oP, oL) => this.g._withStr(
+          fileId,
+          (idP, idL) => this.g._withBytes(
+            key,
+            (kP, kL) => this.g._buffer(
+              (o) => this.ex().gp_save_encrypted(
+                this.h,
+                pwP,
+                pwL,
+                oP,
+                oL,
+                idP,
+                idL,
+                kP,
+                kL,
+                algoCode,
+                permissions,
+                o
+              )
+            )
+          )
         )
       )
     );
@@ -491,6 +816,141 @@ var GigaPdfDoc = class {
       (nP, nL) => this.g._withStr(values.join("\n"), (vP, vL) => this.ex().gp_set_choice(this.h, nP, nL, vP, vL))
     ) === 0;
   }
+  // ── form field creation ──────────────────────────────────────────────────
+  /**
+   * Create a text field on `page` covering `rect` = `[x0, y0, x1, y1]` (PDF
+   * user space). Options: `maxLen` character cap, `multiline`, `password`,
+   * and visual `style`.
+   */
+  addTextField(page, name, rect, value = "", opts = {}) {
+    const st = styleArgs(opts.style);
+    return this.g._withStr(
+      name,
+      (nP, nL) => this.g._withStr(
+        value,
+        (vP, vL) => this.ex().gp_add_text_field(
+          this.h,
+          page,
+          nP,
+          nL,
+          rect[0],
+          rect[1],
+          rect[2],
+          rect[3],
+          vP,
+          vL,
+          opts.maxLen ?? -1,
+          opts.multiline ? 1 : 0,
+          opts.password ? 1 : 0,
+          ...st
+        )
+      )
+    ) === 0;
+  }
+  /** Create a checkbox. `export` is the on-state name (default `On`). */
+  addCheckbox(page, name, rect, checked = false, opts = {}) {
+    const st = styleArgs(opts.style);
+    return this.g._withStr(
+      name,
+      (nP, nL) => this.g._withStr(
+        opts.export ?? "On",
+        (eP, eL) => this.ex().gp_add_checkbox(
+          this.h,
+          page,
+          nP,
+          nL,
+          rect[0],
+          rect[1],
+          rect[2],
+          rect[3],
+          checked ? 1 : 0,
+          eP,
+          eL,
+          ...st
+        )
+      )
+    ) === 0;
+  }
+  /**
+   * Create a radio-button group: one logical field whose `options` are the
+   * individual buttons. `selected` is the initially-chosen export value.
+   */
+  addRadioGroup(page, name, options, opts = {}) {
+    const st = styleArgs(opts.style);
+    const exports = options.map((o) => o.export).join("\n");
+    const rects = options.flatMap((o) => o.rect).join(",");
+    return this.g._withStr(
+      name,
+      (nP, nL) => this.g._withStr(
+        exports,
+        (eP, eL) => this.g._withStr(
+          rects,
+          (rP, rL) => this.g._withStr(
+            opts.selected ?? "",
+            (sP, sL) => this.ex().gp_add_radio_group(this.h, page, nP, nL, eP, eL, rP, rL, sP, sL, ...st)
+          )
+        )
+      )
+    ) === 0;
+  }
+  /** Create a drop-down combo box. `editable` permits values outside `options`. */
+  addComboBox(page, name, rect, options, opts = {}) {
+    const st = styleArgs(opts.style);
+    return this.g._withStr(
+      name,
+      (nP, nL) => this.g._withStr(
+        options.join("\n"),
+        (oP, oL) => this.g._withStr(
+          opts.selected ?? "",
+          (sP, sL) => this.ex().gp_add_combo_box(
+            this.h,
+            page,
+            nP,
+            nL,
+            rect[0],
+            rect[1],
+            rect[2],
+            rect[3],
+            oP,
+            oL,
+            sP,
+            sL,
+            opts.editable ? 1 : 0,
+            ...st
+          )
+        )
+      )
+    ) === 0;
+  }
+  /** Create a scrolling list box. `multi` allows selecting several options. */
+  addListBox(page, name, rect, options, opts = {}) {
+    const st = styleArgs(opts.style);
+    return this.g._withStr(
+      name,
+      (nP, nL) => this.g._withStr(
+        options.join("\n"),
+        (oP, oL) => this.g._withStr(
+          opts.selected ?? "",
+          (sP, sL) => this.ex().gp_add_list_box(
+            this.h,
+            page,
+            nP,
+            nL,
+            rect[0],
+            rect[1],
+            rect[2],
+            rect[3],
+            oP,
+            oL,
+            sP,
+            sL,
+            opts.multi ? 1 : 0,
+            ...st
+          )
+        )
+      )
+    ) === 0;
+  }
 };
 export {
   GigaPdfDoc,