refactor: make error types and messages more consistent

Author: targos

src/Image.ts

@@ -264,9 +264,9 @@ export class Image {
       );
     } else {
       if (bitDepth === 8 && data instanceof Uint16Array) {
-        throw new Error(`bitDepth is ${bitDepth} but data is Uint16Array`);
+        throw new RangeError(`bitDepth is ${bitDepth} but data is Uint16Array`);
       } else if (bitDepth === 16 && data instanceof Uint8Array) {
-        throw new Error(`bitDepth is ${bitDepth} but data is Uint8Array`);
+        throw new RangeError(`bitDepth is ${bitDepth} but data is Uint8Array`);
       }
       const expectedLength = this.size * this.channels;
       if (data.length !== expectedLength) {
@@ -493,7 +493,7 @@ export class Image {
     } else {
       if (value.length !== this.channels) {
         throw new RangeError(
-          `the size of value must match the number of channels (${this.channels}). Got ${value.length} instead`,
+          `the size of value must match the number of channels (${this.channels}). Received ${value.length}`,
         );
       }
       for (const val of value) validateValue(val, this);
@@ -546,7 +546,7 @@ export class Image {
   public fillAlpha(value: number): this {
     validateValue(value, this);
     if (!this.alpha) {
-      throw new Error(
+      throw new TypeError(
         'fillAlpha can only be called if the image has an alpha channel',
       );
     }
@@ -600,7 +600,7 @@ export class Image {
       case 'bottom-right':
         return { column: this.width - 1, row: this.height - 1 };
       default:
-        throw new Error(`Unknown image coordinates ${coordinates}`);
+        throw new RangeError(`invalid image coordinates: ${coordinates}`);
     }
   }
 
@@ -1075,7 +1075,7 @@ function createPixelArray(
       arr = new Uint16Array(length);
       break;
     default:
-      throw new Error(`unexpected bitDepth: ${bitDepth}`);
+      throw new RangeError(`invalid bitDepth: ${bitDepth}`);
   }
 
   // Alpha channel is 100% by default.

src/Mask.ts

@@ -762,6 +762,8 @@ function printData(mask: Mask): string {
  */
 function checkChannel(channel: number) {
   if (channel !== 0) {
-    throw new Error(`Channel value must be 0 on type Mask, got ${channel}.`);
+    throw new RangeError(
+      `channel value must be 0 on type Mask. Received ${channel}`,
+    );
   }
 }

src/__tests__/Image.test.ts

@@ -1,6 +1,7 @@
 import { inspect } from 'node:util';
 
-import { Image } from '../Image';
+import { Image, ImageCoordinates } from '../Image';
+import { Point } from '../geometry';
 
 describe('create new images', () => {
   it('should create a 8-bit image', () => {
@@ -86,7 +87,7 @@ describe('create new images', () => {
   it('should throw on wrong bit depth', () => {
     // @ts-expect-error we want to test the error.
     expect(() => new Image(1, 1, { bitDepth: 20 })).toThrow(
-      /unexpected bitDepth: 20/,
+      /invalid bitDepth: 20/,
     );
   });
   it('should throw with bit depth 8 but data 16', () => {
@@ -181,32 +182,31 @@ test('changeEach', () => {
   ]);
 });
 
-test('getCoordinates', () => {
+test.each<[ImageCoordinates, Point]>([
+  ['bottom-left', { column: 0, row: 4 }],
+  ['bottom-right', { column: 3, row: 4 }],
+  ['center', { column: 1.5, row: 2 }],
+  ['top-left', { column: 0, row: 0 }],
+  ['top-right', { column: 3, row: 0 }],
+])('getCoordinates - %s', (coordinates, point) => {
+  const img = new Image(4, 5);
+  expect(img.getCoordinates(coordinates)).toStrictEqual(point);
+});
+
+test('getCoordinates - with rounding', () => {
   const img = new Image(4, 5);
-  expect(img.getCoordinates('bottom-left')).toStrictEqual({
-    column: 0,
-    row: 4,
-  });
-  expect(img.getCoordinates('bottom-right')).toStrictEqual({
-    column: 3,
-    row: 4,
-  });
-  expect(img.getCoordinates('center')).toStrictEqual({
-    column: 1.5,
-    row: 2,
-  });
   expect(img.getCoordinates('center', true)).toStrictEqual({
     column: 2,
     row: 2,
   });
-  expect(img.getCoordinates('top-left')).toStrictEqual({
-    column: 0,
-    row: 0,
-  });
-  expect(img.getCoordinates('top-right')).toStrictEqual({
-    column: 3,
-    row: 0,
-  });
+});
+
+test('getCoordinates - bad parameter', () => {
+  const img = new Image(4, 5);
+  // @ts-expect-error bad parameter
+  expect(() => img.getCoordinates('bad')).toThrow(
+    /invalid image coordinates: bad/,
+  );
 });
 
 test('fill with a constant color', () => {
@@ -253,7 +253,7 @@ test('fill with out of range value in array', () => {
 test('fill with channel mismatch', () => {
   const img = new Image(1, 1);
   expect(() => img.fill([0, 1, 2, 3])).toThrow(
-    /the size of value must match the number of channels \(3\). Got 4 instead/,
+    /the size of value must match the number of channels \(3\). Received 4/,
   );
 });
 

src/__tests__/Mask.test.ts

@@ -82,7 +82,7 @@ describe('get and set value', () => {
     const mask = new Mask(10, 20);
     expect(() => {
       mask.getValue(2, 1, 2);
-    }).toThrow(/Channel value must be 0 on type Mask, got 2./);
+    }).toThrow(/channel value must be 0 on type Mask. Received 2/);
   });
 });
 

src/compare/__tests__/subtract.test.ts

@@ -45,7 +45,7 @@ test('difference size images should throw', async () => {
   const other = testUtils.createRgbImage([[5, 5, 5, 10, 10, 10]]);
   expect(() => {
     image.subtract(other);
-  }).toThrow(`subtract: both images must have the same size`);
+  }).toThrow(`both images must have the same size`);
 });
 
 test('different alpha should throw', async () => {
@@ -55,13 +55,13 @@ test('different alpha should throw', async () => {
   const other = testUtils.createRgbImage([[1, 1, 1, 5, 5, 5, 10, 10, 10]]);
   expect(() => {
     image.subtract(other);
-  }).toThrow(`subtract: both images must have the same alpha and bitDepth`);
+  }).toThrow(`both images must have the same alpha and bitDepth`);
 });
 
 test('different number of channels should throw', async () => {
   const image = testUtils.createGreyImage([[5, 10, 15]]);
   const other = testUtils.createRgbImage([[1, 1, 1, 5, 5, 5, 10, 10, 10]]);
   expect(() => {
     image.subtract(other);
-  }).toThrow(`subtract: both images must have the same number of channels`);
+  }).toThrow(`both images must have the same number of channels`);
 });

src/compare/computeSsim.ts

@@ -53,17 +53,17 @@ export function computeSsim(
 
   if (windowSize) {
     if (windowSize > image.width || windowSize > image.height) {
-      throw new Error('windowSize cannot exceed image dimensions');
+      throw new RangeError('windowSize cannot exceed image dimensions');
     }
   } else {
     windowSize = Math.min(11, image.height, image.width);
   }
-  checkProcessable(image, 'ssim', {
+  checkProcessable(image, {
     bitDepth: [8],
     channels: [1, 3, 4],
   });
 
-  validateForComparison('ssim', image, otherImage);
+  validateForComparison(image, otherImage);
 
   if (image.colorModel !== 'RGBA') {
     image = image.convertColor('RGBA');

src/compare/subtract.ts

@@ -42,14 +42,14 @@ export function subtract(
   let { absolute = false } = options;
 
   if (image instanceof Image) {
-    checkProcessable(image, 'subtract', {
+    checkProcessable(image, {
       bitDepth: [1, 8, 16],
       components: [1, 3],
       alpha: false,
     });
   }
 
-  validateForComparison('subtract', image, otherImage);
+  validateForComparison(image, otherImage);
 
   let newImage = image.clone();
   if (newImage instanceof Image) {

src/compute/histogram.ts

@@ -26,7 +26,9 @@ export function histogram(
   let { channel } = options;
   if (typeof channel !== 'number') {
     if (image.channels !== 1) {
-      throw new Error('channel option is mandatory for multi-channel images');
+      throw new TypeError(
+        'channel option is mandatory for multi-channel images',
+      );
     }
     channel = 0;
   }

src/correctColor/__tests__/correctColor.test.ts

@@ -200,7 +200,5 @@ test('should throw on different array length', () => {
 
   expect(() => {
     image.correctColor(measuredColors, referenceColors);
-  }).toThrow(
-    'correctColor: number of measured colors and reference colors differ',
-  );
+  }).toThrow('number of measured colors and reference colors must be the same');
 });

src/correctColor/correctColor.ts

@@ -22,13 +22,13 @@ export function correctColor(
   measuredColors: RgbColor[],
   referenceColors: RgbColor[],
 ): Image {
-  checkProcessable(image, 'correctColor', {
+  checkProcessable(image, {
     colorModel: ['RGB', 'RGBA'],
   });
 
   if (measuredColors.length !== referenceColors.length) {
-    throw new Error(
-      'correctColor: number of measured colors and reference colors differ',
+    throw new RangeError(
+      'number of measured colors and reference colors must be the same',
     );
   }