sharp 0.28.0 → 0.28.1

package/install/libvips.js

@@ -145,7 +145,9 @@ try {
           tmpFileStream
             .on('error', function (err) {
               // Clean up temporary file
-              fs.unlinkSync(tarPathTemp);
+              try {
+                fs.unlinkSync(tarPathTemp);
+              } catch (e) {}
               fail(err);
             })
             .on('close', function () {
@@ -157,7 +159,7 @@ try {
                 fs.copyFileSync(tarPathTemp, tarPathCache);
                 fs.unlinkSync(tarPathTemp);
               }
-              extractTarball(tarPathCache);
+              extractTarball(tarPathCache, platformAndArch);
             });
         }
       });

package/lib/channel.js

@@ -30,21 +30,39 @@ function removeAlpha () {
 }
 
 /**
- * Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+ * Ensure the output image has an alpha transparency channel.
+ * If missing, the added alpha channel will have the specified
+ * transparency level, defaulting to fully-opaque (1).
+ * This is a no-op if the image already has an alpha channel.
  *
  * @since 0.21.2
  *
  * @example
- * sharp('rgb.jpg')
+ * // rgba.png will be a 4 channel image with a fully-opaque alpha channel
+ * await sharp('rgb.jpg')
  *   .ensureAlpha()
- *   .toFile('rgba.png', function(err, info) {
- *     // rgba.png is a 4 channel image with a fully opaque alpha channel
- *   });
+ *   .toFile('rgba.png')
+ *
+ * @example
+ * // rgba is a 4 channel image with a fully-transparent alpha channel
+ * const rgba = await sharp(rgb)
+ *   .ensureAlpha(0)
+ *   .toBuffer();
  *
+ * @param {number} [alpha=1] - alpha transparency level (0=fully-transparent, 1=fully-opaque)
  * @returns {Sharp}
+ * @throws {Error} Invalid alpha transparency level
  */
-function ensureAlpha () {
-  this.options.ensureAlpha = true;
+function ensureAlpha (alpha) {
+  if (is.defined(alpha)) {
+    if (is.number(alpha) && is.inRange(alpha, 0, 1)) {
+      this.options.ensureAlpha = alpha;
+    } else {
+      throw is.invalidParameterError('alpha', 'number between 0 and 1', alpha);
+    }
+  } else {
+    this.options.ensureAlpha = 1;
+  }
   return this;
 }
 

package/lib/constructor.js

@@ -132,6 +132,7 @@ const debuglog = util.debuglog('sharp');
  * @param {number} [options.density=72] - number representing the DPI for vector images in the range 1 to 100000.
  * @param {number} [options.pages=1] - number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages.
  * @param {number} [options.page=0] - page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based.
+ * @param {number} [options.subifd=-1] - subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image.
  * @param {number} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
  * @param {boolean} [options.animated=false] - Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`).
  * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
@@ -221,7 +222,7 @@ const Sharp = function (input, options) {
     joinChannelIn: [],
     extractChannel: -1,
     removeAlpha: false,
-    ensureAlpha: false,
+    ensureAlpha: -1,
     colourspace: 'srgb',
     composite: [],
     // output
@@ -231,6 +232,7 @@ const Sharp = function (input, options) {
     withMetadata: false,
     withMetadataOrientation: -1,
     withMetadataIcc: '',
+    withMetadataStrs: {},
     resolveWithObject: false,
     // output format
     jpegQuality: 80,

package/lib/input.js

@@ -9,9 +9,9 @@ const sharp = require('../build/Release/sharp.node');
  * @private
  */
 function _inputOptionsFromObject (obj) {
-  const { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages } = obj;
-  return [raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages].some(is.defined)
-    ? { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages }
+  const { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages, subifd } = obj;
+  return [raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages, subifd].some(is.defined)
+    ? { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages, subifd }
     : undefined;
 }
 
@@ -131,6 +131,14 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
       }
     }
+    // Sub Image File Directory (TIFF)
+    if (is.defined(inputOptions.subifd)) {
+      if (is.integer(inputOptions.subifd) && is.inRange(inputOptions.subifd, -1, 100000)) {
+        inputDescriptor.subifd = inputOptions.subifd;
+      } else {
+        throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
+      }
+    }
     // Create new image
     if (is.defined(inputOptions.create)) {
       if (
@@ -255,6 +263,7 @@ function _isStreamInput () {
  * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
  * - `pagePrimary`: Number of the primary page in a HEIF image
  * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
+ * - `subifds`: Number of Sub Image File Directories in an OME-TIFF image
  * - `hasProfile`: Boolean indicating the presence of an embedded ICC profile
  * - `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
  * - `orientation`: Number value of the EXIF Orientation header, if present

package/lib/libvips.js

@@ -39,7 +39,7 @@ const cachePath = function () {
 
 const log = function (item) {
   if (item instanceof Error) {
-    console.error(`sharp: ${item.message}`);
+    console.error(`sharp: Installation error: ${item.message}`);
   } else {
     console.log(`sharp: ${item}`);
   }

package/lib/output.js

@@ -148,9 +148,22 @@ function toBuffer (options, callback) {
  *   .toFile('output-with-metadata.jpg')
  *   .then(info => { ... });
  *
+ * @example
+ * // Set "IFD0-Copyright" in output EXIF metadata
+ * await sharp(input)
+ *   .withMetadata({
+ *     exif: {
+ *       IFD0: {
+ *         Copyright: 'Wernham Hogg'
+ *       }
+ *     }
+ *   })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {number} [options.orientation] value between 1 and 8, used to update the EXIF `Orientation` tag.
  * @param {string} [options.icc] filesystem path to output ICC profile, defaults to sRGB.
+ * @param {Object<Object>} [options.exif={}] Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -171,6 +184,25 @@ function withMetadata (options) {
         throw is.invalidParameterError('icc', 'string filesystem path to ICC profile', options.icc);
       }
     }
+    if (is.defined(options.exif)) {
+      if (is.object(options.exif)) {
+        for (const [ifd, entries] of Object.entries(options.exif)) {
+          if (is.object(entries)) {
+            for (const [k, v] of Object.entries(entries)) {
+              if (is.string(v)) {
+                this.options.withMetadataStrs[`exif-${ifd.toLowerCase()}-${k}`] = v;
+              } else {
+                throw is.invalidParameterError(`exif.${ifd}.${k}`, 'string', v);
+              }
+            }
+          } else {
+            throw is.invalidParameterError(`exif.${ifd}`, 'object', entries);
+          }
+        }
+      } else {
+        throw is.invalidParameterError('exif', 'object', options.exif);
+      }
+    }
   }
   return this;
 }
@@ -383,6 +415,12 @@ function png (options) {
  *   .webp({ lossless: true })
  *   .toBuffer();
  *
+ * @example
+ * // Optimise the file size of an animated WebP
+ * const outputWebp = await sharp(inputWebp, { animated: true })
+ *   .webp({ reductionEffort: 6 })
+ *   .toBuffer();
+ *
  * @param {Object} [options] - output options
  * @param {number} [options.quality=80] - quality, integer 1-100
  * @param {number} [options.alphaQuality=100] - quality of alpha layer, integer 0-100

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, AVIF and TIFF images",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -120,7 +120,7 @@
     "color": "^3.1.3",
     "detect-libc": "^1.0.3",
     "node-addon-api": "^3.1.0",
-    "prebuild-install": "^6.0.1",
+    "prebuild-install": "^6.1.1",
     "semver": "^7.3.5",
     "simple-get": "^3.1.0",
     "tar-fs": "^2.1.1",

package/src/common.cc

@@ -36,6 +36,9 @@ namespace sharp {
   std::string AttrAsStr(Napi::Object obj, std::string attr) {
     return obj.Get(attr).As<Napi::String>();
   }
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr) {
+    return obj.Get(attr).As<Napi::String>();
+  }
   uint32_t AttrAsUint32(Napi::Object obj, std::string attr) {
     return obj.Get(attr).As<Napi::Number>().Uint32Value();
   }
@@ -104,6 +107,10 @@ namespace sharp {
     if (HasAttr(input, "level")) {
       descriptor->level = AttrAsUint32(input, "level");
     }
+    // subIFD (OME-TIFF)
+    if (HasAttr(input, "subifd")) {
+      descriptor->subifd = AttrAsInt32(input, "subifd");
+    }
     // Create new image
     if (HasAttr(input, "createChannels")) {
       descriptor->createChannels = AttrAsUint32(input, "createChannels");
@@ -319,6 +326,9 @@ namespace sharp {
             if (imageType == ImageType::OPENSLIDE) {
               option->set("level", descriptor->level);
             }
+            if (imageType == ImageType::TIFF) {
+              option->set("subifd", descriptor->subifd);
+            }
             image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -391,6 +401,9 @@ namespace sharp {
             if (imageType == ImageType::OPENSLIDE) {
               option->set("level", descriptor->level);
             }
+            if (imageType == ImageType::TIFF) {
+              option->set("subifd", descriptor->subifd);
+            }
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -799,10 +812,10 @@ namespace sharp {
   /*
     Ensures alpha channel, if missing.
   */
-  VImage EnsureAlpha(VImage image) {
+  VImage EnsureAlpha(VImage image, double const value) {
     if (!HasAlpha(image)) {
       std::vector<double> alpha;
-      alpha.push_back(sharp::MaximumImageAlpha(image.interpretation()));
+      alpha.push_back(value * sharp::MaximumImageAlpha(image.interpretation()));
       image = image.bandjoin_const(alpha);
     }
     return image;

package/src/common.h

@@ -60,6 +60,7 @@ namespace sharp {
     int pages;
     int page;
     int level;
+    int subifd;
     int createChannels;
     int createWidth;
     int createHeight;
@@ -82,6 +83,7 @@ namespace sharp {
       pages(1),
       page(0),
       level(0),
+      subifd(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
@@ -93,6 +95,7 @@ namespace sharp {
   // Convenience methods to access the attributes of a Napi::Object
   bool HasAttr(Napi::Object obj, std::string attr);
   std::string AttrAsStr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr);
   uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
   int32_t AttrAsInt32(Napi::Object obj, std::string attr);
   int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr);
@@ -296,7 +299,7 @@ namespace sharp {
   /*
     Ensures alpha channel, if missing.
   */
-  VImage EnsureAlpha(VImage image);
+  VImage EnsureAlpha(VImage image, double const value);
 
 }  // namespace sharp
 

package/src/metadata.cc

@@ -86,6 +86,9 @@ class MetadataWorker : public Napi::AsyncWorker {
           baton->levels.push_back(std::pair<int, int>(width, height));
         }
       }
+      if (image.get_typeof(VIPS_META_N_SUBIFDS) == G_TYPE_INT) {
+        baton->subifds = image.get_int(VIPS_META_N_SUBIFDS);
+      }
       baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
@@ -203,6 +206,9 @@ class MetadataWorker : public Napi::AsyncWorker {
         }
         info.Set("levels", levels);
       }
+      if (baton->subifds > 0) {
+        info.Set("subifds", baton->subifds);
+      }
       info.Set("hasProfile", baton->hasProfile);
       info.Set("hasAlpha", baton->hasAlpha);
       if (baton->orientation > 0) {

package/src/metadata.h

@@ -41,6 +41,7 @@ struct MetadataBaton {
   int pagePrimary;
   std::string compression;
   std::vector<std::pair<int, int>> levels;
+  int subifds;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -68,6 +69,7 @@ struct MetadataBaton {
     pageHeight(0),
     loop(-1),
     pagePrimary(-1),
+    subifds(0),
     hasProfile(false),
     hasAlpha(false),
     orientation(0),

package/src/pipeline.cc

@@ -346,7 +346,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0;
 
       if (shouldComposite && !sharp::HasAlpha(image)) {
-        image = sharp::EnsureAlpha(image);
+        image = sharp::EnsureAlpha(image, 1);
       }
 
       bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
@@ -594,7 +594,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Ensure image to composite is sRGB with premultiplied alpha
           compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
           if (!sharp::HasAlpha(compositeImage)) {
-            compositeImage = sharp::EnsureAlpha(compositeImage);
+            compositeImage = sharp::EnsureAlpha(compositeImage, 1);
           }
           if (!composite->premultiplied) compositeImage = compositeImage.premultiply();
           // Calculate position
@@ -691,8 +691,8 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Ensure alpha channel, if missing
-      if (baton->ensureAlpha) {
-        image = sharp::EnsureAlpha(image);
+      if (baton->ensureAlpha != -1) {
+        image = sharp::EnsureAlpha(image, baton->ensureAlpha);
       }
 
       // Convert image to sRGB, if not already
@@ -717,11 +717,17 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("input_profile", "srgb")
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
-
       // Override EXIF Orientation tag
       if (baton->withMetadata && baton->withMetadataOrientation != -1) {
         image = sharp::SetExifOrientation(image, baton->withMetadataOrientation);
       }
+      // Metadata key/value pairs, e.g. EXIF
+      if (!baton->withMetadataStrs.empty()) {
+        image = image.copy();
+        for (const auto& s : baton->withMetadataStrs) {
+          image.set(s.first.data(), s.second.data());
+        }
+      }
 
       // Number of channels used in output image
       baton->channels = image.bands();
@@ -1341,7 +1347,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->affineInterpolator = vips::VInterpolate::new_from_name(sharp::AttrAsStr(options, "affineInterpolator").data());
 
   baton->removeAlpha = sharp::AttrAsBool(options, "removeAlpha");
-  baton->ensureAlpha = sharp::AttrAsBool(options, "ensureAlpha");
+  baton->ensureAlpha = sharp::AttrAsDouble(options, "ensureAlpha");
   if (options.Has("boolean")) {
     baton->boolean = sharp::CreateInputDescriptor(options.Get("boolean").As<Napi::Object>());
     baton->booleanOp = sharp::GetBooleanOperation(sharp::AttrAsStr(options, "booleanOp"));
@@ -1379,6 +1385,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->withMetadata = sharp::AttrAsBool(options, "withMetadata");
   baton->withMetadataOrientation = sharp::AttrAsUint32(options, "withMetadataOrientation");
   baton->withMetadataIcc = sharp::AttrAsStr(options, "withMetadataIcc");
+  Napi::Object mdStrs = options.Get("withMetadataStrs").As<Napi::Object>();
+  Napi::Array mdStrKeys = mdStrs.GetPropertyNames();
+  for (unsigned int i = 0; i < mdStrKeys.Length(); i++) {
+    std::string k = sharp::AttrAsStr(mdStrKeys, i);
+    baton->withMetadataStrs.insert(std::make_pair(k, sharp::AttrAsStr(mdStrs, k)));
+  }
   // Format-specific
   baton->jpegQuality = sharp::AttrAsUint32(options, "jpegQuality");
   baton->jpegProgressive = sharp::AttrAsBool(options, "jpegProgressive");

package/src/pipeline.h

@@ -18,6 +18,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <unordered_map>
 
 #include <napi.h>
 #include <vips/vips8>
@@ -168,6 +169,7 @@ struct PipelineBaton {
   bool withMetadata;
   int withMetadataOrientation;
   std::string withMetadataIcc;
+  std::unordered_map<std::string, std::string> withMetadataStrs;
   std::unique_ptr<double[]> convKernel;
   int convKernelWidth;
   int convKernelHeight;
@@ -178,7 +180,7 @@ struct PipelineBaton {
   VipsOperationBoolean bandBoolOp;
   int extractChannel;
   bool removeAlpha;
-  bool ensureAlpha;
+  double ensureAlpha;
   VipsInterpretation colourspace;
   int pageHeight;
   std::vector<int> delay;
@@ -297,7 +299,7 @@ struct PipelineBaton {
     bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
     extractChannel(-1),
     removeAlpha(false),
-    ensureAlpha(false),
+    ensureAlpha(-1.0),
     colourspace(VIPS_INTERPRETATION_LAST),
     pageHeight(0),
     delay{-1},