♻️ Require await in async functions

This commit enables the ESLint rule `require-await` which requires the
use of `await` in async functions and fixes issues that have been
uncovered by this rule. This rule helps to spot unintentional and
leftover `async` keywords.

The `loadFont` function in `FontLoader` was unnecessarily asynchronous
and has been changed to be synchronous. This change does not affect the
API.

eslint.config.js

@@ -35,6 +35,7 @@ export default tseslint.config(
       'no-else-return': ['error', { allowElseIf: false }],
       'dot-notation': 'error',
       'one-var': ['error', 'never'],
+      'require-await': 'error',
       '@typescript-eslint/no-explicit-any': 'off',
       '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
       'simple-import-sort/imports': 'error',

src/font-loader.test.ts

@@ -27,22 +27,22 @@ describe('font-loader', () => {
       fontLoader = new FontLoader([normalFont, italicFont, boldFont, italicBoldFont, otherFont]);
     });
 
-    it('rejects when no fonts defined', async () => {
+    it('rejects when no fonts defined', () => {
       const loader = new FontLoader([]);
 
-      await expect(loader.loadFont({})).rejects.toThrowError('No fonts defined');
+      expect(() => loader.loadFont({})).toThrowError('No fonts defined');
     });
 
-    it('rejects for unknown font name', async () => {
-      await expect(fontLoader.loadFont({ fontFamily: 'Unknown' })).rejects.toThrowError(
+    it('rejects for unknown font name', () => {
+      expect(() => fontLoader.loadFont({ fontFamily: 'Unknown' })).toThrowError(
         "No font defined for 'Unknown'",
       );
     });
 
-    it('rejects when no matching font style can be found', async () => {
-      await expect(() =>
-        fontLoader.loadFont({ fontFamily: 'Other', fontStyle: 'italic' }),
-      ).rejects.toThrowError("No font defined for 'Other', style=italic");
+    it('rejects when no matching font style can be found', () => {
+      expect(() => fontLoader.loadFont({ fontFamily: 'Other', fontStyle: 'italic' })).toThrowError(
+        "No font defined for 'Other', style=italic",
+      );
     });
 
     it('selects different font variants', async () => {
@@ -68,61 +68,53 @@ describe('font-loader', () => {
       });
     });
 
-    it('selects first matching font if no family specified', async () => {
-      await expect(fontLoader.loadFont({})).resolves.toEqual({
+    it('selects first matching font if no family specified', () => {
+      expect(fontLoader.loadFont({})).toEqual({
         name: 'Test',
         data: normalFont.data,
       });
-      await expect(fontLoader.loadFont({ fontWeight: 'bold' })).resolves.toEqual({
+      expect(fontLoader.loadFont({ fontWeight: 'bold' })).toEqual({
         name: 'Test',
         data: boldFont.data,
       });
-      await expect(fontLoader.loadFont({ fontStyle: 'italic' })).resolves.toEqual({
+      expect(fontLoader.loadFont({ fontStyle: 'italic' })).toEqual({
         name: 'Test',
         data: italicFont.data,
       });
-      await expect(
-        fontLoader.loadFont({ fontStyle: 'italic', fontWeight: 'bold' }),
-      ).resolves.toEqual({
+      expect(fontLoader.loadFont({ fontStyle: 'italic', fontWeight: 'bold' })).toEqual({
         name: 'Test',
         data: italicBoldFont.data,
       });
     });
 
-    it('selects font with matching font family', async () => {
-      await expect(fontLoader.loadFont({ fontFamily: 'Other' })).resolves.toEqual({
+    it('selects font with matching font family', () => {
+      expect(fontLoader.loadFont({ fontFamily: 'Other' })).toEqual({
         name: 'Other',
         data: otherFont.data,
       });
     });
 
-    it('falls back to oblique when no italic font can be found', async () => {
+    it('falls back to oblique when no italic font can be found', () => {
       fontLoader = new FontLoader([normalFont, obliqueFont, boldFont, obliqueBoldFont]);
-      await expect(
-        fontLoader.loadFont({ fontFamily: 'Test', fontStyle: 'italic' }),
-      ).resolves.toEqual({
+      expect(fontLoader.loadFont({ fontFamily: 'Test', fontStyle: 'italic' })).toEqual({
         name: 'Test',
         data: obliqueFont.data,
       });
     });
 
-    it('falls back to italic when no oblique font can be found', async () => {
-      await expect(
-        fontLoader.loadFont({ fontFamily: 'Test', fontStyle: 'oblique' }),
-      ).resolves.toEqual({
+    it('falls back to italic when no oblique font can be found', () => {
+      expect(fontLoader.loadFont({ fontFamily: 'Test', fontStyle: 'oblique' })).toEqual({
         name: 'Test',
         data: italicFont.data,
       });
     });
 
-    it('falls back when no matching font weight can be found', async () => {
-      await expect(
-        fontLoader.loadFont({ fontFamily: 'Other', fontWeight: 'bold' }),
-      ).resolves.toEqual({
+    it('falls back when no matching font weight can be found', () => {
+      expect(fontLoader.loadFont({ fontFamily: 'Other', fontWeight: 'bold' })).toEqual({
         name: 'Other',
         data: otherFont.data,
       });
-      await expect(fontLoader.loadFont({ fontFamily: 'Other', fontWeight: 200 })).resolves.toEqual({
+      expect(fontLoader.loadFont({ fontFamily: 'Other', fontWeight: 200 })).toEqual({
         name: 'Other',
         data: otherFont.data,
       });
@@ -136,7 +128,7 @@ describe('font-loader', () => {
     beforeEach(() => {
       testFont = fakeFont('Test');
       fontLoader = new FontLoader([]);
-      fontLoader.loadFont = vi.fn(async (selector: FontSelector) => {
+      fontLoader.loadFont = vi.fn((selector: FontSelector) => {
         if (selector.fontFamily === 'Test') return testFont;
         throw new Error('No such font defined');
       });

src/font-loader.ts

@@ -18,7 +18,7 @@ export class FontLoader {
     this.#fontDefs = fontDefs;
   }
 
-  async loadFont(selector: FontSelector): Promise<LoadedFont> {
+  loadFont(selector: FontSelector): LoadedFont {
     if (!this.#fontDefs.length) {
       throw new Error('No fonts defined');
     }

src/image-loader.test.ts

@@ -57,9 +57,9 @@ describe('image-loader', () => {
 
     beforeEach(() => {
       imageLoader = new ImageLoader([]);
-      imageLoader.loadImage = vi.fn(async (selector: ImageSelector) => {
-        if (selector.name === 'liberty') return { data: libertyJpg };
-        if (selector.name === 'torus') return { data: torusPng };
+      imageLoader.loadImage = vi.fn((selector: ImageSelector) => {
+        if (selector.name === 'liberty') return Promise.resolve({ data: libertyJpg });
+        if (selector.name === 'torus') return Promise.resolve({ data: torusPng });
         throw new Error('No such image');
       });
     });

src/image-loader.ts

@@ -43,7 +43,7 @@ export class ImageStore {
     this.#imageLoader = imageLoader;
   }
 
-  async selectImage(selector: ImageSelector): Promise<Image> {
+  selectImage(selector: ImageSelector): Promise<Image> {
     const cacheKey = selector.name;
     return (this.#imageCache[cacheKey] ??= this.loadImage(selector));
   }

src/images/jpeg.test.ts

@@ -7,13 +7,13 @@ import { isJpeg, readJpegInfo } from './jpeg.ts';
 
 describe('jpeg', () => {
   describe('isJpeg', () => {
-    it('returns true for JPEG header', async () => {
+    it('returns true for JPEG header', () => {
       const data = new Uint8Array([0xff, 0xd8, 0xff]);
 
       expect(isJpeg(data)).toBe(true);
     });
 
-    it('returns false for other data', async () => {
+    it('returns false for other data', () => {
       expect(isJpeg(new Uint8Array())).toBe(false);
       expect(isJpeg(new Uint8Array([1, 2, 3]))).toBe(false);
     });

src/images/png.test.ts

@@ -7,13 +7,13 @@ import { isPng, readPngInfo } from './png.ts';
 
 describe('png', () => {
   describe('isPng', () => {
-    it('returns true if PNG header found', async () => {
+    it('returns true if PNG header found', () => {
       const info = isPng(new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
 
       expect(info).toBe(true);
     });
 
-    it('returns false for other data', async () => {
+    it('returns false for other data', () => {
       expect(isPng(new Uint8Array())).toBe(false);
       expect(isPng(new Uint8Array([1, 2, 3, 4, 5]))).toBe(false);
     });

src/layout/layout-columns.test.ts

@@ -13,8 +13,8 @@ describe('layout-columns', () => {
 
   beforeEach(() => {
     const fontStore = new FontStore(new FontLoader([]));
-    fontStore.selectFont = async () => {
-      return fakeFont('Test');
+    fontStore.selectFont = () => {
+      return Promise.resolve(fakeFont('Test'));
     };
     ctx = { fontStore } as MakerCtx;
     box = { x: 20, y: 30, width: 400, height: 700 };

src/layout/layout-image.test.ts

@@ -14,10 +14,10 @@ describe('layout-image', () => {
 
   beforeEach(() => {
     const imageStore = new ImageStore(new ImageLoader([]));
-    imageStore.selectImage = vi.fn(async (selector: ImageSelector) => {
+    imageStore.selectImage = vi.fn((selector: ImageSelector) => {
       const match = /^img-(\d+)-(\d+)$/.exec(selector.name);
       if (match) {
-        return fakeImage(selector.name, Number(match[1]), Number(match[2]));
+        return Promise.resolve(fakeImage(selector.name, Number(match[1]), Number(match[2])));
       }
       throw new Error(`Unknown image: ${selector.name}`);
     });

src/layout/layout-rows.test.ts

@@ -14,7 +14,7 @@ describe('layout-rows', () => {
 
   beforeEach(() => {
     const fontStore = new FontStore(new FontLoader([]));
-    fontStore.selectFont = async () => fakeFont('Test');
+    fontStore.selectFont = () => Promise.resolve(fakeFont('Test'));
     ctx = { fontStore } as MakerCtx;
     box = { x: 20, y: 30, width: 400, height: 700 };
   });

src/layout/layout-text.test.ts

@@ -17,8 +17,8 @@ describe('layout-text', () => {
     defaultFont = fakeFont('Test');
     const italicFont = fakeFont('Test', { style: 'italic' });
     const fontStore = new FontStore(new FontLoader([]));
-    fontStore.selectFont = async (selector: FontSelector) => {
-      return selector.fontStyle === 'italic' ? italicFont : defaultFont;
+    fontStore.selectFont = (selector: FontSelector) => {
+      return Promise.resolve(selector.fontStyle === 'italic' ? italicFont : defaultFont);
     };
     box = { x: 20, y: 30, width: 400, height: 700 };
     ctx = { fontStore } as MakerCtx;

src/layout/layout.test.ts

@@ -18,7 +18,7 @@ describe('layout', () => {
 
   beforeEach(() => {
     const fontStore = new FontStore(new FontLoader([]));
-    fontStore.loadFont = async () => fakeFont('Test');
+    fontStore.loadFont = () => Promise.resolve(fakeFont('Test'));
     ctx = { fontStore } as MakerCtx;
     box = { x: 20, y: 30, width: 400, height: 700 };
   });

src/print-value.test.ts

@@ -27,7 +27,7 @@ describe('print-value', () => {
 
     it('prints functions', () => {
       expect(printValue((x: unknown) => x)).toEqual('anonymous function');
-      expect(printValue(async (x: unknown) => x)).toEqual('anonymous function');
+      expect(printValue((x: unknown) => x)).toEqual('anonymous function');
       expect(printValue(printValue)).toEqual('function printValue');
     });
 

src/text.test.ts

@@ -21,8 +21,8 @@ describe('text', () => {
     normalFont = fakeFont('Test');
     const italicFont = fakeFont('Test', { style: 'italic' });
     fontStore = new FontStore(new FontLoader([]));
-    fontStore.selectFont = async (selector) => {
-      return selector.fontStyle === 'italic' ? italicFont : normalFont;
+    fontStore.selectFont = (selector) => {
+      return Promise.resolve(selector.fontStyle === 'italic' ? italicFont : normalFont);
     };
   });