fix: include src/build sources excluded by gitignore

The template .gitignore ignored 'build/' (a build-output convention), which also
matched the source directory src/build/ — so images-to-pdf.ts and page-sizes.ts
were never committed and CI's clean checkout failed to build. Anchor the ignore
to /build/ (repo root only) and add the two source files.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ECgear

.gitignore

@@ -1,9 +1,9 @@
 # Rename to .gitignore
 
-# Dependencies / build
+# Dependencies / build (anchored to repo root so source dirs like src/build/ are kept)
 node_modules/
-dist/
-build/
+/dist/
+/build/
 coverage/
 *.tsbuildinfo
 

src/build/images-to-pdf.ts

@@ -0,0 +1,79 @@
+/** Combine multiple images into one PDF (pdf-lib). JPEG/PNG embed natively; other
+ *  formats (WebP/GIF/BMP/AVIF) are decoded on a canvas and re-encoded to JPEG. */
+import { PDFDocument, type PDFImage } from 'pdf-lib';
+import { fitRect, resolvePageSize } from './page-sizes';
+import { bytesToImageData } from '../codecs/canvas';
+import { encodeJpeg } from '../codecs/jpeg';
+import { throwIfAborted, type AbortLike } from '../util/errors';
+import type { FitMode, ImagesToPdfResult, OnProgress, Orientation, PageSize } from '../types';
+
+export interface ImagesToPdfParams {
+  pageSize: PageSize;
+  fit: FitMode;
+  orientation: Orientation;
+  margin: number;
+  jpegWasmUrl: string;
+}
+
+export interface NamedImage {
+  name: string;
+  bytes: Uint8Array;
+}
+
+function isJpeg(b: Uint8Array): boolean {
+  return b.length > 2 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff;
+}
+function isPng(b: Uint8Array): boolean {
+  return b.length > 7 && b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47;
+}
+
+export async function buildPdfFromImages(
+  items: NamedImage[],
+  params: ImagesToPdfParams,
+  onProgress?: OnProgress,
+  signal?: AbortLike,
+): Promise<ImagesToPdfResult> {
+  const out = await PDFDocument.create();
+  const skipped: string[] = [];
+  const total = items.length;
+  const margin = Math.max(0, params.margin || 0);
+
+  for (let i = 0; i < total; i++) {
+    throwIfAborted(signal);
+    const { name, bytes } = items[i];
+    try {
+      let image: PDFImage;
+      if (isJpeg(bytes)) {
+        image = await out.embedJpg(bytes);
+      } else if (isPng(bytes)) {
+        image = await out.embedPng(bytes);
+      } else {
+        const imageData = await bytesToImageData(bytes, { fillWhite: true });
+        const jpeg = await encodeJpeg(imageData, 90, params.jpegWasmUrl);
+        image = await out.embedJpg(jpeg);
+      }
+      const imgW = image.width;
+      const imgH = image.height;
+      const { width: pw, height: ph } = resolvePageSize(params.pageSize, params.orientation, imgW, imgH);
+      const page = out.addPage([pw, ph]);
+      const boxW = Math.max(1, pw - margin * 2);
+      const boxH = Math.max(1, ph - margin * 2);
+      const rect =
+        params.pageSize === 'fit'
+          ? { x: 0, y: 0, width: boxW, height: boxH }
+          : fitRect(imgW, imgH, boxW, boxH, params.fit);
+      page.drawImage(image, {
+        x: margin + rect.x,
+        y: margin + rect.y,
+        width: rect.width,
+        height: rect.height,
+      });
+    } catch {
+      skipped.push(name);
+    }
+    onProgress?.({ phase: 'assemble', done: i + 1, total, label: `画像を追加中… ${i + 1} / ${total}` });
+  }
+
+  const bytes = await out.save();
+  return { bytes, pages: out.getPageCount(), skipped };
+}

src/build/page-sizes.ts

@@ -0,0 +1,83 @@
+import type { FitMode, Orientation, PageSize } from '../types';
+
+export const PT_PER_INCH = 72;
+
+/** Portrait dimensions in PDF points (1pt = 1/72 inch). */
+export const PAGE_DIMENSIONS_PT: Record<'a4' | 'letter', readonly [number, number]> = {
+  a4: [595.28, 841.89],
+  letter: [612, 792],
+};
+
+export interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+function applyOrientation(w: number, h: number, orientation: Orientation, imgW: number, imgH: number): [number, number] {
+  let landscape: boolean;
+  if (orientation === 'portrait') landscape = false;
+  else if (orientation === 'landscape') landscape = true;
+  else landscape = imgW > imgH; // auto: follow the image
+  const long = Math.max(w, h);
+  const short = Math.min(w, h);
+  return landscape ? [long, short] : [short, long];
+}
+
+/** Resolve the page box (in points) for one image. */
+export function resolvePageSize(
+  pageSize: PageSize,
+  orientation: Orientation,
+  imgWpx: number,
+  imgHpx: number,
+): { width: number; height: number } {
+  if (pageSize === 'fit') {
+    // page matches the image, mapping pixels 1:1 to points (96dpi-ish baseline)
+    const landscape =
+      orientation === 'landscape' || (orientation === 'auto' && imgWpx > imgHpx);
+    const w = imgWpx;
+    const h = imgHpx;
+    if (orientation === 'portrait' && w > h) return { width: h, height: w };
+    if (landscape && w < h) return { width: h, height: w };
+    return { width: w, height: h };
+  }
+  const [pw, ph] = PAGE_DIMENSIONS_PT[pageSize];
+  const [width, height] = applyOrientation(pw, ph, orientation, imgWpx, imgHpx);
+  return { width, height };
+}
+
+/**
+ * Place an image of (imgW x imgH) inside a content box of (boxW x boxH) given a
+ * fit mode. Returns the draw rect (origin at bottom-left, PDF convention).
+ */
+export function fitRect(
+  imgW: number,
+  imgH: number,
+  boxW: number,
+  boxH: number,
+  fit: FitMode,
+): Rect {
+  if (imgW <= 0 || imgH <= 0 || boxW <= 0 || boxH <= 0) {
+    return { x: 0, y: 0, width: Math.max(0, boxW), height: Math.max(0, boxH) };
+  }
+  let drawW: number;
+  let drawH: number;
+  if (fit === 'actual') {
+    drawW = imgW;
+    drawH = imgH;
+  } else {
+    const scale =
+      fit === 'cover'
+        ? Math.max(boxW / imgW, boxH / imgH)
+        : Math.min(boxW / imgW, boxH / imgH); // 'contain'
+    drawW = imgW * scale;
+    drawH = imgH * scale;
+  }
+  return {
+    x: (boxW - drawW) / 2,
+    y: (boxH - drawH) / 2,
+    width: drawW,
+    height: drawH,
+  };
+}