Set error cause property

Since EcmaScript 2022, `Error` objects support a `cause` property,
allowing for tracking the root cause of an error.

This commit set this property where appropriate.

Author: ralfstx

src/font-loader.test.ts

@@ -142,8 +142,11 @@ describe('font-loader', () => {
     it('rejects if font could not be loaded', async () => {
       const store = new FontStore(fontLoader);
 
-      await expect(store.selectFont({ fontFamily: 'foo' })).rejects.toThrowError(
-        "Could not load font for 'foo', style=normal, weight=normal: No such font defined",
+      await expect(() => store.selectFont({ fontFamily: 'foo' })).rejects.toThrow(
+        expect.objectContaining({
+          message: "Could not load font for 'foo', style=normal, weight=normal",
+          cause: new Error('No such font defined'),
+        }),
       );
     });
 
@@ -186,13 +189,12 @@ describe('font-loader', () => {
     it('caches errors from font loader', async () => {
       const store = new FontStore(fontLoader);
 
-      await expect(store.selectFont({ fontFamily: 'foo' })).rejects.toThrowError(
-        "Could not load font for 'foo', style=normal, weight=normal: No such font defined",
+      await expect(() => store.selectFont({ fontFamily: 'foo' })).rejects.toThrow(
+        expect.objectContaining({
+          message: "Could not load font for 'foo', style=normal, weight=normal",
+          cause: new Error('No such font defined'),
+        }),
       );
-      await expect(store.selectFont({ fontFamily: 'foo' })).rejects.toThrowError(
-        "Could not load font for 'foo', style=normal, weight=normal: No such font defined",
-      );
-      expect(fontLoader.loadFont).toHaveBeenCalledTimes(1);
     });
   });
 });

src/font-loader.ts

@@ -111,9 +111,7 @@ export class FontStore {
     } catch (error) {
       const { fontFamily: family, fontStyle: style, fontWeight: weight } = selector;
       const selectorStr = `'${family}', style=${style ?? 'normal'}, weight=${weight ?? 'normal'}`;
-      throw new Error(
-        `Could not load font for ${selectorStr}: ${(error as Error)?.message ?? error}`,
-      );
+      throw new Error(`Could not load font for ${selectorStr}`, { cause: error });
     }
     const fkFont = fontkit.create(loadedFont.data);
     return pickDefined({

src/image-loader.test.ts

@@ -21,8 +21,11 @@ describe('image-loader', () => {
     it('rejects if image cannot be loaded', async () => {
       const loader = new ImageLoader([]);
 
-      await expect(loader.loadImage({ name: 'foo' })).rejects.toThrowError(
-        "Could not load image 'foo': ENOENT: no such file or directory, open 'foo'",
+      await expect(() => loader.loadImage({ name: 'foo' })).rejects.toThrow(
+        expect.objectContaining({
+          message: "Could not load image 'foo'",
+          cause: new Error("ENOENT: no such file or directory, open 'foo'"),
+        }),
       );
     });
 
@@ -64,8 +67,11 @@ describe('image-loader', () => {
     it('rejects if image could not be loaded', async () => {
       const store = new ImageStore(imageLoader);
 
-      await expect(store.selectImage({ name: 'foo' })).rejects.toThrowError(
-        "Could not load image 'foo': No such image",
+      await expect(() => store.selectImage({ name: 'foo' })).rejects.toThrow(
+        expect.objectContaining({
+          message: "Could not load image 'foo'",
+          cause: new Error('No such image'),
+        }),
       );
     });
 
@@ -120,13 +126,12 @@ describe('image-loader', () => {
     it('caches errors from image loader', async () => {
       const store = new ImageStore(imageLoader);
 
-      await expect(store.selectImage({ name: 'foo' })).rejects.toThrowError(
-        "Could not load image 'foo': No such image",
+      await expect(() => store.selectImage({ name: 'foo' })).rejects.toThrow(
+        expect.objectContaining({
+          message: "Could not load image 'foo'",
+          cause: new Error('No such image'),
+        }),
       );
-      await expect(store.selectImage({ name: 'foo' })).rejects.toThrowError(
-        "Could not load image 'foo': No such image",
-      );
-      expect(imageLoader.loadImage).toHaveBeenCalledTimes(1);
     });
   });
 });

src/image-loader.ts

@@ -28,9 +28,7 @@ export class ImageLoader {
       data = await readFile(selector.name);
       return { data };
     } catch (error) {
-      throw new Error(
-        `Could not load image '${selector.name}': ${(error as Error)?.message ?? error}`,
-      );
+      throw new Error(`Could not load image '${selector.name}'`, { cause: error });
     }
   }
 }
@@ -53,9 +51,7 @@ export class ImageStore {
     try {
       loadedImage = await this.#imageLoader.loadImage(selector);
     } catch (error) {
-      throw new Error(
-        `Could not load image '${selector.name}': ${(error as Error)?.message ?? error}`,
-      );
+      throw new Error(`Could not load image '${selector.name}'`, { cause: error });
     }
     const { data } = loadedImage;
     const format = determineImageFormat(data);

src/images.ts

@@ -50,9 +50,7 @@ export function registerImage(image: Image, pdfDoc: PDFDocument) {
           : JpegEmbedder.for(image.data));
         embedder.embedIntoContext(pdfDoc.context, ref);
       } catch (error) {
-        throw new Error(
-          `Could not embed image "${image.name}": ${(error as Error)?.message ?? error}`,
-        );
+        throw new Error(`Could not embed image "${image.name}"`, { cause: error });
       }
     },
   });

src/types.test.ts

@@ -190,10 +190,11 @@ describe('types', () => {
       });
 
       it('throws when function returns invalid value', () => {
-        const resolve = validate(() => 23);
-
-        expect(() => resolve()).toThrowError(
-          'Supplied function for "test" returned invalid value: Expected string, got: 23',
+        expect(validate(() => 23)).toThrow(
+          expect.objectContaining({
+            message: 'Supplied function for "test" returned invalid value',
+            cause: new Error('Expected string, got: 23'),
+          }),
         );
       });
 
@@ -202,8 +203,11 @@ describe('types', () => {
           throw new Error('test error');
         });
 
-        expect(() => resolve()).toThrowError(
-          'Supplied function for "test" threw: Error: test error',
+        expect(resolve).toThrow(
+          expect.objectContaining({
+            message: 'Supplied function for "test" threw error',
+            cause: new Error('test error'),
+          }),
         );
       });
     });

src/types.ts

@@ -100,8 +100,7 @@ export function dynamic<T = unknown>(
       try {
         return asType(result, type);
       } catch (error) {
-        const errorStr = error instanceof Error ? (error.message ?? String(error)) : String(error);
-        throw new Error(`${subject} returned invalid value: ${errorStr}`);
+        throw new Error(`${subject} returned invalid value`, { cause: error });
       }
     };
   };
@@ -110,10 +109,8 @@ export function dynamic<T = unknown>(
 function safeCall(fn: (...params: unknown[]) => unknown, args: unknown[], subject: string) {
   try {
     return fn(...args);
-  } catch (error: unknown) {
-    const errorStr =
-      error instanceof Error ? (error.stack ?? error.message ?? String(error)) : String(error);
-    throw new Error(`${subject} threw: ${errorStr}`);
+  } catch (error) {
+    throw new Error(`${subject} threw error`, { cause: error });
   }
 }