@revizly/sharp 0.35.0-revizly7 → 0.35.0-revizly8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@revizly/sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.35.0-revizly7",
+  "version": "0.35.0-revizly8",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://sharp.pixelplumbing.com",
   "contributors": [
@@ -89,12 +89,12 @@
     "Lachlan Newman <lachnewman007@gmail.com>",
     "Dennis Beatty <dennis@dcbeatty.com>",
     "Ingvar Stepanyan <me@rreverser.com>",
-    "Don Denton <don@happycollision.com>"
+    "Don Denton <don@happycollision.com>",
+    "Dmytro Tiapukhin <cool.gegeg@gmail.com>"
   ],
   "scripts": {
     "build": "node install/build.js",
-    "install": "node install/check.js || npm run build",
-    "clean": "rm -rf src/build/ .nyc_output/ coverage/ test/fixtures/output.*",
+    "clean": "rm -rf src/build/ test/fixtures/output.*",
     "test": "npm run lint && npm run test-unit",
     "lint": "npm run lint-cpp && npm run lint-js && npm run lint-types",
     "lint-cpp": "cpplint --quiet src/*.h src/*.cc",
@@ -150,24 +150,23 @@
     "@revizly/sharp-linux-x64": "0.35.0-revizly1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.4",
+    "@biomejs/biome": "^2.3.10",
     "@cpplint/cli": "^0.1.0",
-    "@emnapi/runtime": "^1.7.0",
+    "@emnapi/runtime": "^1.7.1",
     "@revizly/sharp-libvips-dev": "1.0.26",
     "@types/node": "*",
-    "emnapi": "^1.7.0",
-    "exif-reader": "^2.0.2",
+    "emnapi": "^1.7.1",
+    "exif-reader": "^2.0.3",
     "extract-zip": "^2.0.1",
     "icc": "^3.0.0",
-    "jsdoc-to-markdown": "^9.1.3",
     "node-addon-api": "^8.5.0",
-    "node-gyp": "^11.5.0",
+    "node-gyp": "^12.1.0",
     "tar-fs": "^3.1.1",
     "tsd": "^0.33.0"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node": ">=20.9.0"
   },
   "config": {
     "libvips": ">=8.18.0"

package/src/binding.gyp

@@ -5,6 +5,7 @@
   'variables': {
     'vips_version': '<!(node -p "require(\'../lib/libvips\').minimumLibvipsVersion")',
     'platform_and_arch': '<!(node -p "require(\'../lib/libvips\').buildPlatformArch()")',
+    'sharp_version': '<!(node -p "require(\'../package.json\').version")',
     'sharp_libvips_version': '<!(node -p "require(\'../package.json\').optionalDependencies[\'@revizly/sharp-libvips-<(platform_and_arch)\']")',
     'sharp_libvips_yarn_locator': '<!(node -p "require(\'../lib/libvips\').yarnLocator()")',
     'sharp_libvips_include_dir': '<!(node -p "require(\'../lib/libvips\').buildSharpLibvipsIncludeDir()")',
@@ -20,6 +21,7 @@
         'defines': [
           '_VIPS_PUBLIC=__declspec(dllexport)',
           '_ALLOW_KEYWORD_MACROS',
+          '_HAS_EXCEPTIONS=1',
           'G_DISABLE_ASSERT',
           'G_DISABLE_CAST_CHECKS',
           'G_DISABLE_CHECKS'
@@ -81,7 +83,7 @@
       }]
     ]
   }, {
-    'target_name': 'sharp-<(platform_and_arch)',
+    'target_name': 'sharp-<(platform_and_arch)-<(sharp_version)',
     'defines': [
       'G_DISABLE_ASSERT',
       'G_DISABLE_CAST_CHECKS',
@@ -147,7 +149,8 @@
           ['OS == "win"', {
             'defines': [
               '_ALLOW_KEYWORD_MACROS',
-              '_FILE_OFFSET_BITS=64'
+              '_FILE_OFFSET_BITS=64',
+              '_HAS_EXCEPTIONS=1'
             ],
             'link_settings': {
               'libraries': [
@@ -282,7 +285,7 @@
     'target_name': 'copy-dll',
     'type': 'none',
     'dependencies': [
-      'sharp-<(platform_and_arch)'
+      'sharp-<(platform_and_arch)-<(sharp_version)'
     ],
     'conditions': [
       ['OS == "win"', {

package/src/common.cc

@@ -289,6 +289,7 @@ namespace sharp {
       case ImageType::JXL: id = "jxl"; break;
       case ImageType::RAD: id = "rad"; break;
       case ImageType::DCRAW: id = "dcraw"; break;
+      case ImageType::UHDR: id = "uhdr"; break;
       case ImageType::VIPS: id = "vips"; break;
       case ImageType::RAW: id = "raw"; break;
       case ImageType::UNKNOWN: id = "unknown"; break;
@@ -339,6 +340,9 @@ namespace sharp {
     { "VipsForeignLoadRadBuffer", ImageType::RAD },
     { "VipsForeignLoadDcRawFile", ImageType::DCRAW },
     { "VipsForeignLoadDcRawBuffer", ImageType::DCRAW },
+    { "VipsForeignLoadUhdr", ImageType::UHDR },
+    { "VipsForeignLoadUhdrFile", ImageType::UHDR },
+    { "VipsForeignLoadUhdrBuffer", ImageType::UHDR },
     { "VipsForeignLoadVips", ImageType::VIPS },
     { "VipsForeignLoadVipsFile", ImageType::VIPS },
     { "VipsForeignLoadRaw", ImageType::RAW }
@@ -356,6 +360,9 @@ namespace sharp {
         imageType = it->second;
       }
     }
+    if (imageType == ImageType::UHDR) {
+      imageType = ImageType::JPEG;
+    }
     return imageType;
   }
 
@@ -375,6 +382,9 @@ namespace sharp {
         imageType = ImageType::MISSING;
       }
     }
+    if (imageType == ImageType::UHDR) {
+      imageType = ImageType::JPEG;
+    }
     return imageType;
   }
 
@@ -416,7 +426,7 @@ namespace sharp {
     }
     if (ImageTypeSupportsPage(imageType)) {
       option->set("n", descriptor->pages);
-      option->set("page", descriptor->page);
+      option->set("page", std::max(0, descriptor->page));
     }
     switch (imageType) {
       case ImageType::SVG:
@@ -446,6 +456,22 @@ namespace sharp {
     return option;
   }
 
+  /*
+    Should HEIF image be re-opened using the primary item?
+  */
+  static bool HeifPrimaryPageReopen(VImage image, InputDescriptor *descriptor) {
+    if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT && image.get_typeof("heif-primary") == G_TYPE_INT) {
+      if (image.get_int(VIPS_META_N_PAGES) > 1 && descriptor->pages == 1 && descriptor->page == -1) {
+        int const pagePrimary = image.get_int("heif-primary");
+        if (pagePrimary != 0) {
+          descriptor->page = pagePrimary;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
@@ -480,12 +506,15 @@ namespace sharp {
             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);
+            } else if (imageType == ImageType::HEIF && HeifPrimaryPageReopen(image, descriptor)) {
+              option = GetOptionsForImageType(imageType, descriptor);
+              image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input buffer has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input buffer contains unsupported image format");
+          throw std::runtime_error("Input buffer contains unsupported image format");
         }
       }
     } else {
@@ -556,10 +585,10 @@ namespace sharp {
         imageType = DetermineImageType(descriptor->file.data());
         if (imageType == ImageType::MISSING) {
           if (descriptor->file.find("<svg") != std::string::npos) {
-            throw vips::VError("Input file is missing, did you mean "
+            throw std::runtime_error("Input file is missing, did you mean "
               "sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");
           }
-          throw vips::VError("Input file is missing: " + descriptor->file);
+          throw std::runtime_error("Input file is missing: " + descriptor->file);
         }
         if (imageType != ImageType::UNKNOWN) {
           try {
@@ -567,12 +596,15 @@ namespace sharp {
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
+            } else if (imageType == ImageType::HEIF && HeifPrimaryPageReopen(image, descriptor)) {
+              option = GetOptionsForImageType(imageType, descriptor);
+              image = VImage::new_from_file(descriptor->file.data(), option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input file has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input file has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input file contains unsupported image format");
+          throw std::runtime_error("Input file contains unsupported image format");
         }
       }
     }
@@ -580,7 +612,7 @@ namespace sharp {
     // Limit input images to a given number of pixels, where pixels = width * height
     if (descriptor->limitInputPixels > 0 &&
       static_cast<uint64_t>(image.width()) * image.height() > descriptor->limitInputPixels) {
-      throw vips::VError("Input image exceeds pixel limit");
+      throw std::runtime_error("Input image exceeds pixel limit");
     }
     return std::make_tuple(image, imageType);
   }
@@ -756,19 +788,19 @@ namespace sharp {
       : image.height();
     if (imageType == ImageType::JPEG) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the JPEG format");
+        throw std::runtime_error("Processed image is too large for the JPEG format");
       }
     } else if (imageType == ImageType::WEBP) {
       if (image.width() > 16383 || height > 16383) {
-        throw vips::VError("Processed image is too large for the WebP format");
+        throw std::runtime_error("Processed image is too large for the WebP format");
       }
     } else if (imageType == ImageType::GIF) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the GIF format");
+        throw std::runtime_error("Processed image is too large for the GIF format");
       }
     } else if (imageType == ImageType::HEIF) {
       if (image.width() > 16384 || height > 16384) {
-        throw vips::VError("Processed image is too large for the HEIF format");
+        throw std::runtime_error("Processed image is too large for the HEIF format");
       }
     }
   }
@@ -1127,4 +1159,20 @@ namespace sharp {
     }
     return image;
   }
+
+  /*
+    Does this image have a gain map?
+  */
+  bool HasGainMap(VImage image) {
+    return image.get_typeof("gainmap-data") == VIPS_TYPE_BLOB;
+  }
+
+  /*
+    Removes gain map, if any.
+  */
+  VImage RemoveGainMap(VImage image) {
+    VImage copy = image.copy();
+    copy.remove("gainmap-data");
+    return copy;
+  }
 }  // namespace sharp

package/src/common.h

@@ -105,7 +105,7 @@ namespace sharp {
       rawPremultiplied(false),
       rawPageHeight(0),
       pages(1),
-      page(0),
+      page(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
@@ -173,6 +173,7 @@ namespace sharp {
     JXL,
     RAD,
     DCRAW,
+    UHDR,
     VIPS,
     RAW,
     UNKNOWN,
@@ -397,6 +398,16 @@ namespace sharp {
   */
   VImage StaySequential(VImage image, bool condition = true);
 
+  /*
+    Does this image have a gain map?
+  */
+  bool HasGainMap(VImage image);
+
+  /*
+    Removes gain map, if any.
+  */
+  VImage RemoveGainMap(VImage image);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_

package/src/metadata.cc

@@ -31,7 +31,7 @@ class MetadataWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
@@ -141,8 +141,60 @@ class MetadataWorker : public Napi::AsyncWorker {
         memcpy(baton->tifftagPhotoshop, tifftagPhotoshop, tifftagPhotoshopLength);
         baton->tifftagPhotoshopLength = tifftagPhotoshopLength;
       }
+      // Gain Map
+      if (image.get_typeof("gainmap-data") == VIPS_TYPE_BLOB) {
+        size_t gainMapLength;
+        void const *gainMap = image.get_blob("gainmap-data", &gainMapLength);
+        baton->gainMap = static_cast<char *>(g_malloc(gainMapLength));
+        memcpy(baton->gainMap, gainMap, gainMapLength);
+        baton->gainMapLength = gainMapLength;
+      }
       // PNG comments
       vips_image_map(image.get_image(), readPNGComment, &baton->comments);
+      // Media type
+      std::string mediaType;
+      switch (imageType) {
+        case sharp::ImageType::JPEG:
+        case sharp::ImageType::PNG:
+        case sharp::ImageType::WEBP:
+        case sharp::ImageType::JP2:
+        case sharp::ImageType::TIFF:
+        case sharp::ImageType::GIF:
+        case sharp::ImageType::FITS:
+        case sharp::ImageType::JXL:
+          baton->mediaType = "image/" + baton->format;
+          break;
+        case sharp::ImageType::SVG:
+          baton->mediaType = "image/svg+xml";
+          break;
+        case sharp::ImageType::HEIF:
+          if (baton->compression == "av1") {
+            baton->mediaType = "image/avif";
+          } else if (baton->compression == "hevc") {
+            baton->mediaType = "image/heic";
+          }
+          break;
+        case sharp::ImageType::PDF:
+          baton->mediaType = "application/pdf";
+          break;
+        case sharp::ImageType::OPENSLIDE:
+          baton->mediaType = "image/tiff";
+          break;
+        case sharp::ImageType::PPM:
+          baton->mediaType = "image/x-portable-pixmap";
+          break;
+        case sharp::ImageType::EXR:
+          baton->mediaType = "image/x-exr";
+          break;
+        case sharp::ImageType::RAD:
+          baton->mediaType = "image/vnd.radiance";
+          break;
+        case sharp::ImageType::UHDR:
+          baton->mediaType = "image/jpeg";
+          break;
+        default:
+          break;
+      }
     }
 
     // Clean up
@@ -164,6 +216,9 @@ class MetadataWorker : public Napi::AsyncWorker {
     if (baton->err.empty()) {
       Napi::Object info = Napi::Object::New(env);
       info.Set("format", baton->format);
+      if (!baton->mediaType.empty()) {
+        info.Set("mediaType", baton->mediaType);
+      }
       if (baton->input->bufferLength > 0) {
         info.Set("size", baton->input->bufferLength);
       }
@@ -182,10 +237,6 @@ class MetadataWorker : public Napi::AsyncWorker {
       info.Set("isPalette", baton->isPalette);
       if (baton->bitsPerSample > 0) {
         info.Set("bitsPerSample", baton->bitsPerSample);
-        if (baton->isPalette) {
-          // Deprecated, remove with libvips 8.17.0
-          info.Set("paletteBitDepth", baton->bitsPerSample);
-        }
       }
       if (baton->pages > 0) {
         info.Set("pages", baton->pages);
@@ -276,6 +327,12 @@ class MetadataWorker : public Napi::AsyncWorker {
           Napi::Buffer<char>::NewOrCopy(env, baton->tifftagPhotoshop,
             baton->tifftagPhotoshopLength, sharp::FreeCallback));
       }
+      if (baton->gainMapLength > 0) {
+        Napi::Object gainMap = Napi::Object::New(env);
+        info.Set("gainMap", gainMap);
+        gainMap.Set("image",
+          Napi::Buffer<char>::NewOrCopy(env, baton->gainMap, baton->gainMapLength, sharp::FreeCallback));
+      }
       if (baton->comments.size() > 0) {
         int i = 0;
         Napi::Array comments = Napi::Array::New(env, baton->comments.size());

package/src/metadata.h

@@ -19,6 +19,7 @@ struct MetadataBaton {
   sharp::InputDescriptor *input;
   // Output
   std::string format;
+  std::string mediaType;
   int width;
   int height;
   std::string space;
@@ -53,6 +54,8 @@ struct MetadataBaton {
   size_t xmpLength;
   char *tifftagPhotoshop;
   size_t tifftagPhotoshopLength;
+  char *gainMap;
+  size_t gainMapLength;
   MetadataComments comments;
   std::string err;
 
@@ -82,7 +85,9 @@ struct MetadataBaton {
     xmp(nullptr),
     xmpLength(0),
     tifftagPhotoshop(nullptr),
-    tifftagPhotoshopLength(0) {}
+    tifftagPhotoshopLength(0),
+    gainMap(nullptr),
+    gainMapLength(0) {}
 };
 
 Napi::Value metadata(const Napi::CallbackInfo& info);

package/src/operations.cc

@@ -14,7 +14,6 @@
 #include "./operations.h"
 
 using vips::VImage;
-using vips::VError;
 
 namespace sharp {
   /*
@@ -285,9 +284,9 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt) {
+  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt, int const margin) {
     if (image.width() < 3 && image.height() < 3) {
-      throw VError("Image to trim must be at least 3x3 pixels");
+      throw std::runtime_error("Image to trim must be at least 3x3 pixels");
     }
     if (background.size() == 0) {
       // Top-left pixel provides the default background colour if none is given
@@ -320,18 +319,36 @@ namespace sharp {
       if (widthA > 0 && heightA > 0) {
         if (width > 0 && height > 0) {
           // Combined bounding box (B)
-          int const leftB = std::min(left, leftA);
-          int const topB = std::min(top, topA);
-          int const widthB = std::max(left + width, leftA + widthA) - leftB;
-          int const heightB = std::max(top + height, topA + heightA) - topB;
+          int leftB = std::min(left, leftA);
+          int topB = std::min(top, topA);
+          int widthB = std::max(left + width, leftA + widthA) - leftB;
+          int heightB = std::max(top + height, topA + heightA) - topB;
+          if (margin > 0) {
+            leftB = std::max(0, leftB - margin);
+            topB = std::max(0, topB - margin);
+            widthB = std::min(image.width() - leftB, widthB + 2 * margin);
+            heightB = std::min(image.height() - topB, heightB + 2 * margin);
+          }
           return image.extract_area(leftB, topB, widthB, heightB);
         } else {
           // Use alpha only
+          if (margin > 0) {
+            leftA = std::max(0, leftA - margin);
+            topA = std::max(0, topA - margin);
+            widthA = std::min(image.width() - leftA, widthA + 2 * margin);
+            heightA = std::min(image.height() - topA, heightA + 2 * margin);
+          }
           return image.extract_area(leftA, topA, widthA, heightA);
         }
       }
     }
     if (width > 0 && height > 0) {
+      if (margin > 0) {
+        left = std::max(0, left - margin);
+        top = std::max(0, top - margin);
+        width = std::min(image.width() - left, width + 2 * margin);
+        height = std::min(image.height() - top, height + 2 * margin);
+      }
       return image.extract_area(left, top, width, height);
     }
     return image;
@@ -343,7 +360,7 @@ namespace sharp {
   VImage Linear(VImage image, std::vector<double> const a, std::vector<double> const b) {
     size_t const bands = static_cast<size_t>(image.bands());
     if (a.size() > bands) {
-      throw VError("Band expansion using linear is unsupported");
+      throw std::runtime_error("Band expansion using linear is unsupported");
     }
     bool const uchar = !Is16Bit(image.interpretation());
     if (image.has_alpha() && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {

package/src/operations.h

@@ -82,7 +82,7 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt);
+  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt, int const margin);
 
   /*
    * Linear adjustment (a * in + b)