@ohos-ports/sharp 0.34.5-beta.8 → 0.35.5-beta.1

package/{lib/operation.js → dist/operation.cjs}

@@ -3,7 +3,7 @@
   SPDX-License-Identifier: Apache-2.0
 */
 
-const is = require('./is');
+const is = require('./is.cjs');
 
 /**
  * How accurate an operation should be.
@@ -78,6 +78,10 @@ function rotate (angle, options) {
  * Auto-orient based on the EXIF `Orientation` tag, then remove the tag.
  * Mirroring is supported and may infer the use of a flip operation.
  *
+ * Only the EXIF `Orientation` tag is considered; orientation carried in other
+ * places, such as an XMP `tiff:Orientation` element, is left untouched and
+ * remains the responsibility of the consumer.
+ *
  * Previous or subsequent use of `rotate(angle)` and either `flip()` or `flop()`
  * will logically occur after auto-orientation, regardless of call order.
  *
@@ -178,7 +182,13 @@ function flop (flop) {
  * @throws {Error} Invalid parameters
  */
 function affine (matrix, options) {
-  const flatMatrix = [].concat(...matrix);
+  const isValidShape = Array.isArray(matrix) && (
+    // 1x4 array of numbers
+    (matrix.length === 4 && matrix.every(is.number)) ||
+    // 2x2 array of arrays of numbers
+    (matrix.length === 2 && matrix.every((row) => Array.isArray(row) && row.length === 2))
+  );
+  const flatMatrix = isValidShape ? matrix.flat() : [];
   if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
     this.options.affineMatrix = flatMatrix;
   } else {
@@ -259,45 +269,18 @@ function affine (matrix, options) {
  *   })
  *   .toBuffer();
  *
- * @param {Object|number} [options] - if present, is an Object with attributes
+ * @param {Object} [options] - if present, is an Object with attributes
  * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`, between 0.000001 and 10
  * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas, between 0 and 1000000
  * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas, between 0 and 1000000
  * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged", between 0 and 1000000
  * @param {number} [options.y2=10.0] - maximum amount of brightening, between 0 and 1000000
  * @param {number} [options.y3=20.0] - maximum amount of darkening, between 0 and 1000000
- * @param {number} [flat] - (deprecated) see `options.m1`.
- * @param {number} [jagged] - (deprecated) see `options.m2`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function sharpen (options, flat, jagged) {
-  if (!is.defined(options)) {
-    // No arguments: default to mild sharpen
-    this.options.sharpenSigma = -1;
-  } else if (is.bool(options)) {
-    // Deprecated boolean argument: apply mild sharpen?
-    this.options.sharpenSigma = options ? -1 : 0;
-  } else if (is.number(options) && is.inRange(options, 0.01, 10000)) {
-    // Deprecated numeric argument: specific sigma
-    this.options.sharpenSigma = options;
-    // Deprecated control over flat areas
-    if (is.defined(flat)) {
-      if (is.number(flat) && is.inRange(flat, 0, 10000)) {
-        this.options.sharpenM1 = flat;
-      } else {
-        throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
-      }
-    }
-    // Deprecated control over jagged areas
-    if (is.defined(jagged)) {
-      if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
-        this.options.sharpenM2 = jagged;
-      } else {
-        throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
-      }
-    }
-  } else if (is.plainObject(options)) {
+function sharpen (options) {
+  if (is.plainObject(options)) {
     if (is.number(options.sigma) && is.inRange(options.sigma, 0.000001, 10)) {
       this.options.sharpenSigma = options.sigma;
     } else {
@@ -339,7 +322,7 @@ function sharpen (options, flat, jagged) {
       }
     }
   } else {
-    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', options);
+    this.options.sharpenSigma = -1;
   }
   return this;
 }
@@ -451,10 +434,10 @@ function blur (options) {
 function dilate (width) {
   if (!is.defined(width)) {
     this.options.dilateWidth = 1;
-  } else if (is.integer(width) && width > 0) {
+  } else if (is.integer(width) && is.inRange(width, 1, 65536)) {
     this.options.dilateWidth = width;
   } else {
-    throw is.invalidParameterError('dilate', 'positive integer', dilate);
+    throw is.invalidParameterError('width', 'integer between 1 and 65536', width);
   }
   return this;
 }
@@ -474,10 +457,10 @@ function dilate (width) {
 function erode (width) {
   if (!is.defined(width)) {
     this.options.erodeWidth = 1;
-  } else if (is.integer(width) && width > 0) {
+  } else if (is.integer(width) && is.inRange(width, 1, 65536)) {
     this.options.erodeWidth = width;
   } else {
-    throw is.invalidParameterError('erode', 'positive integer', erode);
+    throw is.invalidParameterError('width', 'integer between 1 and 65536', width);
   }
   return this;
 }
@@ -510,8 +493,6 @@ function flatten (options) {
  *
  * Existing alpha channel values for non-white pixels remain unchanged.
  *
- * This feature is experimental and the API may change.
- *
  * @since 0.32.1
  *
  * @example
@@ -675,23 +656,23 @@ function normalize (options) {
  *   .toBuffer();
  *
  * @param {Object} options
- * @param {number} options.width - Integral width of the search window, in pixels.
- * @param {number} options.height - Integral height of the search window, in pixels.
+ * @param {number} options.width - Integral width of the search window, in pixels, between 1 and 65536.
+ * @param {number} options.height - Integral height of the search window, in pixels, between 1 and 65536.
  * @param {number} [options.maxSlope=3] - Integral level of brightening, between 0 and 100, where 0 disables contrast limiting.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function clahe (options) {
   if (is.plainObject(options)) {
-    if (is.integer(options.width) && options.width > 0) {
+    if (is.integer(options.width) && is.inRange(options.width, 1, 65536)) {
       this.options.claheWidth = options.width;
     } else {
-      throw is.invalidParameterError('width', 'integer greater than zero', options.width);
+      throw is.invalidParameterError('width', 'integer between 1 and 65536', options.width);
     }
-    if (is.integer(options.height) && options.height > 0) {
+    if (is.integer(options.height) && is.inRange(options.height, 1, 65536)) {
       this.options.claheHeight = options.height;
     } else {
-      throw is.invalidParameterError('height', 'integer greater than zero', options.height);
+      throw is.invalidParameterError('height', 'integer between 1 and 65536', options.height);
     }
     if (is.defined(options.maxSlope)) {
       if (is.integer(options.maxSlope) && is.inRange(options.maxSlope, 0, 100)) {
@@ -735,7 +716,8 @@ function convolve (kernel) {
   if (!is.object(kernel) || !Array.isArray(kernel.kernel) ||
       !is.integer(kernel.width) || !is.integer(kernel.height) ||
       !is.inRange(kernel.width, 3, 1001) || !is.inRange(kernel.height, 3, 1001) ||
-      kernel.height * kernel.width !== kernel.kernel.length
+      kernel.height * kernel.width !== kernel.kernel.length ||
+      !kernel.kernel.every(is.number)
   ) {
     // must pass in a kernel
     throw new Error('Invalid convolution kernel');
@@ -842,7 +824,7 @@ function linear (a, b) {
     this.options.linearA = [];
   } else if (is.number(a)) {
     this.options.linearA = [a];
-  } else if (Array.isArray(a) && a.length && a.every(is.number)) {
+  } else if (Array.isArray(a) && is.inRange(a.length, 1, 1000000) && a.every(is.number)) {
     this.options.linearA = a;
   } else {
     throw is.invalidParameterError('a', 'number or array of numbers', a);
@@ -851,7 +833,7 @@ function linear (a, b) {
     this.options.linearB = [];
   } else if (is.number(b)) {
     this.options.linearB = [b];
-  } else if (Array.isArray(b) && b.length && b.every(is.number)) {
+  } else if (Array.isArray(b) && is.inRange(b.length, 1, 1000000) && b.every(is.number)) {
     this.options.linearB = b;
   } else {
     throw is.invalidParameterError('b', 'number or array of numbers', b);
@@ -888,12 +870,16 @@ function recomb (inputMatrix) {
   if (!Array.isArray(inputMatrix)) {
     throw is.invalidParameterError('inputMatrix', 'array', inputMatrix);
   }
-  if (inputMatrix.length !== 3 && inputMatrix.length !== 4) {
-    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', inputMatrix.length);
+  const dimensions = inputMatrix.length;
+  if (dimensions !== 3 && dimensions !== 4) {
+    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', dimensions);
+  }
+  if (!inputMatrix.every((row) => Array.isArray(row) && row.length === dimensions)) {
+    throw is.invalidParameterError('inputMatrix', `array of ${dimensions} arrays of length ${dimensions}`, inputMatrix);
   }
-  const recombMatrix = inputMatrix.flat().map(Number);
-  if (recombMatrix.length !== 9 && recombMatrix.length !== 16) {
-    throw is.invalidParameterError('inputMatrix', 'cardinality of 9 or 16', recombMatrix.length);
+  const recombMatrix = inputMatrix.flat();
+  if (!recombMatrix.every(is.number)) {
+    throw is.invalidParameterError('inputMatrix', 'array of numbers', recombMatrix);
   }
   this.options.recombMatrix = recombMatrix;
   return this;