Image store

src/api/make-pdf.ts

@@ -1,5 +1,5 @@
 import { FontStore } from '../font-store.ts';
-import { ImageLoader, ImageStore } from '../image-loader.ts';
+import { ImageStore } from '../image-store.ts';
 import { layoutPages } from '../layout/layout.ts';
 import { readDocumentDefinition } from '../read-document.ts';
 import { renderDocument } from '../render/render-document.ts';
@@ -15,8 +15,7 @@ import type { DocumentDefinition } from './document.ts';
 export async function makePdf(definition: DocumentDefinition): Promise<Uint8Array> {
   const def = readAs(definition, 'definition', readDocumentDefinition);
   const fontStore = new FontStore(def.fonts ?? []);
-  const imageLoader = new ImageLoader(def.images ?? []);
-  const imageStore = new ImageStore(imageLoader);
+  const imageStore = new ImageStore(def.images ?? []);
   const guides = !!def.dev?.guides;
   const ctx = { fontStore, imageStore, guides };
   const pages = await layoutPages(def, ctx);

src/image-store.test.ts

@@ -0,0 +1,89 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { ImageStore } from './image-store.ts';
+
+const baseDir = import.meta.dirname;
+
+describe('image-loader', () => {
+  let libertyJpg: Uint8Array;
+  let torusPng: Uint8Array;
+
+  beforeAll(async () => {
+    [libertyJpg, torusPng] = await Promise.all([
+      readFile(join(baseDir, './test/resources/liberty.jpg')),
+      readFile(join(baseDir, './test/resources/torus.png')),
+    ]);
+  });
+
+  describe('ImageStore', () => {
+    it('rejects if image could not be loaded', async () => {
+      const store = new ImageStore([]);
+
+      await expect(store.selectImage('foo')).rejects.toThrow("Could not load image 'foo'");
+    });
+
+    it('loads registered images', async () => {
+      const store = new ImageStore([
+        { name: 'liberty', data: libertyJpg, format: 'jpeg' },
+        { name: 'torus', data: torusPng, format: 'png' },
+      ]);
+
+      const torus = await store.selectImage('torus');
+      const liberty = await store.selectImage('liberty');
+
+      expect(torus).toEqual(expect.objectContaining({ name: 'torus', data: torusPng }));
+      expect(liberty).toEqual(expect.objectContaining({ name: 'liberty', data: libertyJpg }));
+    });
+
+    it('loads image from file system', async () => {
+      const store = new ImageStore([]);
+
+      const torusPath = join(baseDir, './test/resources/torus.png');
+      const image = await store.selectImage(torusPath);
+
+      expect(image).toEqual(expect.objectContaining({ name: torusPath, data: torusPng }));
+    });
+
+    it('reads format, width and height from JPEG image', async () => {
+      const store = new ImageStore([{ name: 'liberty', data: libertyJpg, format: 'jpeg' }]);
+
+      const image = await store.selectImage('liberty');
+
+      expect(image).toEqual({
+        name: 'liberty',
+        format: 'jpeg',
+        width: 160,
+        height: 240,
+        data: libertyJpg,
+      });
+    });
+
+    it('reads format, width and height from PNG image', async () => {
+      const store = new ImageStore([{ name: 'torus', data: torusPng, format: 'png' }]);
+
+      const image = await store.selectImage('torus');
+
+      expect(image).toEqual({
+        name: 'torus',
+        format: 'png',
+        width: 256,
+        height: 192,
+        data: torusPng,
+      });
+    });
+
+    it('returns same image object for concurrent calls', async () => {
+      const store = new ImageStore([{ name: 'liberty', data: libertyJpg, format: 'jpeg' }]);
+
+      const [image1, image2] = await Promise.all([
+        store.selectImage('liberty'),
+        store.selectImage('liberty'),
+      ]);
+
+      expect(image1).toBe(image2);
+    });
+  });
+});

src/image-store.ts

@@ -0,0 +1,45 @@
+import { readFile } from 'node:fs/promises';
+
+import { toUint8Array } from 'pdf-lib';
+
+import type { Image, ImageDef, ImageFormat } from './images.ts';
+import { isJpeg, readJpegInfo } from './images/jpeg.ts';
+import { isPng, readPngInfo } from './images/png.ts';
+
+export class ImageStore {
+  readonly #images: ImageDef[];
+  readonly #imageCache: Record<string, Promise<Image>> = {};
+
+  constructor(images: ImageDef[]) {
+    this.#images = images;
+  }
+
+  selectImage(selector: string): Promise<Image> {
+    return (this.#imageCache[selector] ??= this.loadImage(selector));
+  }
+
+  async loadImage(selector: string): Promise<Image> {
+    const data = await this.loadImageData(selector);
+    const format = determineImageFormat(data);
+    const { width, height } = format === 'png' ? readPngInfo(data) : readJpegInfo(data);
+    return { name: selector, format, data, width, height };
+  }
+
+  async loadImageData(selector: string): Promise<Uint8Array> {
+    const imageDef = this.#images.find((image) => image.name === selector);
+    if (imageDef) {
+      return toUint8Array(imageDef.data);
+    }
+    try {
+      return await readFile(selector);
+    } catch (error) {
+      throw new Error(`Could not load image '${selector}'`, { cause: error });
+    }
+  }
+}
+
+function determineImageFormat(data: Uint8Array): ImageFormat {
+  if (isPng(data)) return 'png';
+  if (isJpeg(data)) return 'jpeg';
+  throw new Error('Unknown image format');
+}

src/images.ts

@@ -22,10 +22,6 @@ export type Image = {
   pdfRef?: PDFRef;
 };
 
-export type ImageSelector = {
-  name: string;
-};
-
 export function readImages(input: unknown): ImageDef[] {
   return Object.entries(readObject(input)).map(([name, imageDef]) => {
     const { data, format } = readAs(imageDef, name, required(readImage));