sharp 0.24.0 → 0.25.2

package/src/pipeline.h

@@ -19,12 +19,12 @@
 #include <string>
 #include <vector>
 
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "./common.h"
 
-NAN_METHOD(pipeline);
+Napi::Value pipeline(const Napi::CallbackInfo& info);
 
 enum class Canvas {
   CROP,
@@ -150,7 +150,7 @@ struct PipelineBaton {
   double tiffXres;
   double tiffYres;
   int heifQuality;
-  int heifCompression;  // TODO(libvips 8.9.0): VipsForeignHeifCompression
+  VipsForeignHeifCompression heifCompression;
   bool heifLossless;
   std::string err;
   bool withMetadata;
@@ -258,7 +258,7 @@ struct PipelineBaton {
     tiffXres(1.0),
     tiffYres(1.0),
     heifQuality(80),
-    heifCompression(1),  // TODO(libvips 8.9.0): VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
+    heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_HEVC),
     heifLossless(false),
     withMetadata(false),
     withMetadataOrientation(-1),

package/src/sharp.cc

@@ -12,8 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
@@ -22,33 +21,24 @@
 #include "utilities.h"
 #include "stats.h"
 
-NAN_MODULE_INIT(init) {
+Napi::Object init(Napi::Env env, Napi::Object exports) {
   vips_init("sharp");
 
   g_log_set_handler("VIPS", static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING),
     static_cast<GLogFunc>(sharp::VipsWarningCallback), nullptr);
 
   // Methods available to JavaScript
-  Nan::Set(target, Nan::New("metadata").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(metadata)).ToLocalChecked());
-  Nan::Set(target, Nan::New("pipeline").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(pipeline)).ToLocalChecked());
-  Nan::Set(target, Nan::New("cache").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(cache)).ToLocalChecked());
-  Nan::Set(target, Nan::New("concurrency").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(concurrency)).ToLocalChecked());
-  Nan::Set(target, Nan::New("counters").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(counters)).ToLocalChecked());
-  Nan::Set(target, Nan::New("simd").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(simd)).ToLocalChecked());
-  Nan::Set(target, Nan::New("libvipsVersion").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(libvipsVersion)).ToLocalChecked());
-  Nan::Set(target, Nan::New("format").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(format)).ToLocalChecked());
-  Nan::Set(target, Nan::New("_maxColourDistance").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(_maxColourDistance)).ToLocalChecked());
-  Nan::Set(target, Nan::New("stats").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(stats)).ToLocalChecked());
+  exports.Set("metadata", Napi::Function::New(env, metadata));
+  exports.Set("pipeline", Napi::Function::New(env, pipeline));
+  exports.Set("cache", Napi::Function::New(env, cache));
+  exports.Set("concurrency", Napi::Function::New(env, concurrency));
+  exports.Set("counters", Napi::Function::New(env, counters));
+  exports.Set("simd", Napi::Function::New(env, simd));
+  exports.Set("libvipsVersion", Napi::Function::New(env, libvipsVersion));
+  exports.Set("format", Napi::Function::New(env, format));
+  exports.Set("_maxColourDistance", Napi::Function::New(env, _maxColourDistance));
+  exports.Set("stats", Napi::Function::New(env, stats));
+  return exports;
 }
 
-NAN_MODULE_WORKER_ENABLED(sharp, init)
+NODE_API_MODULE(sharp, init)

package/src/stats.cc

@@ -16,28 +16,16 @@
 #include <vector>
 #include <iostream>
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
 #include "stats.h"
 
-class StatsWorker : public Nan::AsyncWorker {
+class StatsWorker : public Napi::AsyncWorker {
  public:
-  StatsWorker(
-    Nan::Callback *callback, StatsBaton *baton, Nan::Callback *debuglog,
-    std::vector<v8::Local<v8::Object>> const buffersToPersist) :
-    Nan::AsyncWorker(callback, "sharp:StatsWorker"),
-    baton(baton), debuglog(debuglog),
-    buffersToPersist(buffersToPersist) {
-    // Protect Buffer objects from GC, keyed on index
-    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
-      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
-        SaveToPersistent(index, buffer);
-        return index + 1;
-      });
-  }
+  StatsWorker(Napi::Function callback, StatsBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
   ~StatsWorker() {}
 
   const int STAT_MIN_INDEX = 0;
@@ -54,13 +42,9 @@ class StatsWorker : public Nan::AsyncWorker {
   void Execute() {
     // Decrement queued task counter
     g_atomic_int_dec_and_test(&sharp::counterQueue);
-    using Nan::New;
-    using Nan::Set;
-    using sharp::MaximumImageAlpha;
 
     vips::VImage image;
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
-
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
     } catch (vips::VError const &err) {
@@ -71,20 +55,23 @@ class StatsWorker : public Nan::AsyncWorker {
         vips::VImage stats = image.stats();
         int const bands = image.bands();
         for (int b = 1; b <= bands; b++) {
-          ChannelStats cStats(static_cast<int>(stats.getpoint(STAT_MIN_INDEX, b).front()),
-                              static_cast<int>(stats.getpoint(STAT_MAX_INDEX, b).front()),
-                              stats.getpoint(STAT_SUM_INDEX, b).front(), stats.getpoint(STAT_SQ_SUM_INDEX, b).front(),
-                              stats.getpoint(STAT_MEAN_INDEX, b).front(), stats.getpoint(STAT_STDEV_INDEX, b).front(),
-                              static_cast<int>(stats.getpoint(STAT_MINX_INDEX, b).front()),
-                              static_cast<int>(stats.getpoint(STAT_MINY_INDEX, b).front()),
-                              static_cast<int>(stats.getpoint(STAT_MAXX_INDEX, b).front()),
-                              static_cast<int>(stats.getpoint(STAT_MAXY_INDEX, b).front()));
+          ChannelStats cStats(
+            static_cast<int>(stats.getpoint(STAT_MIN_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAX_INDEX, b).front()),
+            stats.getpoint(STAT_SUM_INDEX, b).front(),
+            stats.getpoint(STAT_SQ_SUM_INDEX, b).front(),
+            stats.getpoint(STAT_MEAN_INDEX, b).front(),
+            stats.getpoint(STAT_STDEV_INDEX, b).front(),
+            static_cast<int>(stats.getpoint(STAT_MINX_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MINY_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAXX_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAXY_INDEX, b).front()));
           baton->channelStats.push_back(cStats);
         }
         // Image is not opaque when alpha layer is present and contains a non-mamixa value
         if (sharp::HasAlpha(image)) {
           double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
-          if (minAlpha != MaximumImageAlpha(image.interpretation())) {
+          if (minAlpha != sharp::MaximumImageAlpha(image.interpretation())) {
             baton->isOpaque = false;
           }
         }
@@ -100,92 +87,78 @@ class StatsWorker : public Nan::AsyncWorker {
     vips_thread_shutdown();
   }
 
-  void HandleOKCallback() {
-    using Nan::New;
-    using Nan::Set;
-    Nan::HandleScope();
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
 
-    v8::Local<v8::Value> argv[2] = { Nan::Null(), Nan::Null() };
-    if (!baton->err.empty()) {
-      argv[0] = Nan::Error(baton->err.data());
-    } else {
+    // Handle warnings
+    std::string warning = sharp::VipsWarningPop();
+    while (!warning.empty()) {
+      debuglog.Call({ Napi::String::New(env, warning) });
+      warning = sharp::VipsWarningPop();
+    }
+
+    if (baton->err.empty()) {
       // Stats Object
-      v8::Local<v8::Object> info = New<v8::Object>();
-      v8::Local<v8::Array> channels = New<v8::Array>();
+      Napi::Object info = Napi::Object::New(env);
+      Napi::Array channels = Napi::Array::New(env);
 
       std::vector<ChannelStats>::iterator it;
       int i = 0;
       for (it = baton->channelStats.begin(); it < baton->channelStats.end(); it++, i++) {
-        v8::Local<v8::Object> channelStat = New<v8::Object>();
-        Set(channelStat, New("min").ToLocalChecked(), New<v8::Number>(it->min));
-        Set(channelStat, New("max").ToLocalChecked(), New<v8::Number>(it->max));
-        Set(channelStat, New("sum").ToLocalChecked(), New<v8::Number>(it->sum));
-        Set(channelStat, New("squaresSum").ToLocalChecked(), New<v8::Number>(it->squaresSum));
-        Set(channelStat, New("mean").ToLocalChecked(), New<v8::Number>(it->mean));
-        Set(channelStat, New("stdev").ToLocalChecked(), New<v8::Number>(it->stdev));
-        Set(channelStat, New("minX").ToLocalChecked(), New<v8::Number>(it->minX));
-        Set(channelStat, New("minY").ToLocalChecked(), New<v8::Number>(it->minY));
-        Set(channelStat, New("maxX").ToLocalChecked(), New<v8::Number>(it->maxX));
-        Set(channelStat, New("maxY").ToLocalChecked(), New<v8::Number>(it->maxY));
-        Set(channels, i, channelStat);
+        Napi::Object channelStat = Napi::Object::New(env);
+        channelStat.Set("min", it->min);
+        channelStat.Set("max", it->max);
+        channelStat.Set("sum", it->sum);
+        channelStat.Set("squaresSum", it->squaresSum);
+        channelStat.Set("mean", it->mean);
+        channelStat.Set("stdev", it->stdev);
+        channelStat.Set("minX", it->minX);
+        channelStat.Set("minY", it->minY);
+        channelStat.Set("maxX", it->maxX);
+        channelStat.Set("maxY", it->maxY);
+        channels.Set(i, channelStat);
       }
 
-      Set(info, New("channels").ToLocalChecked(), channels);
-      Set(info, New("isOpaque").ToLocalChecked(), New<v8::Boolean>(baton->isOpaque));
-      Set(info, New("entropy").ToLocalChecked(), New<v8::Number>(baton->entropy));
-      argv[1] = info;
+      info.Set("channels", channels);
+      info.Set("isOpaque", baton->isOpaque);
+      info.Set("entropy", baton->entropy);
+      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+    } else {
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
     }
 
-    // Dispose of Persistent wrapper around input Buffers so they can be garbage collected
-    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
-      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
-        GetFromPersistent(index);
-        return index + 1;
-      });
     delete baton->input;
     delete baton;
-
-    // Handle warnings
-    std::string warning = sharp::VipsWarningPop();
-    while (!warning.empty()) {
-      v8::Local<v8::Value> message[1] = { New(warning).ToLocalChecked() };
-      debuglog->Call(1, message, async_resource);
-      warning = sharp::VipsWarningPop();
-    }
-
-    // Return to JavaScript
-    callback->Call(2, argv, async_resource);
   }
 
  private:
   StatsBaton* baton;
-  Nan::Callback *debuglog;
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
+  Napi::FunctionReference debuglog;
 };
 
 /*
   stats(options, callback)
 */
-NAN_METHOD(stats) {
-  using sharp::AttrTo;
-
-  // Input Buffers must not undergo GC compaction during processing
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
-
+Napi::Value stats(const Napi::CallbackInfo& info) {
   // V8 objects are converted to non-V8 types held in the baton struct
   StatsBaton *baton = new StatsBaton;
-  v8::Local<v8::Object> options = info[0].As<v8::Object>();
+  Napi::Object options = info[0].As<Napi::Object>();
 
   // Input
-  baton->input = sharp::CreateInputDescriptor(sharp::AttrAs<v8::Object>(options, "input"), buffersToPersist);
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
 
   // Function to notify of libvips warnings
-  Nan::Callback *debuglog = new Nan::Callback(sharp::AttrAs<v8::Function>(options, "debuglog"));
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
 
   // Join queue for worker thread
-  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
-  Nan::AsyncQueueWorker(new StatsWorker(callback, baton, debuglog, buffersToPersist));
+  Napi::Function callback = info[1].As<Napi::Function>();
+  StatsWorker *worker = new StatsWorker(callback, baton, debuglog);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
 
   // Increment queued task counter
   g_atomic_int_inc(&sharp::counterQueue);
+
+  return info.Env().Undefined();
 }

package/src/stats.h

@@ -16,7 +16,7 @@
 #define SRC_STATS_H_
 
 #include <string>
-#include <nan.h>
+#include <napi.h>
 
 #include "./common.h"
 
@@ -33,12 +33,8 @@ struct ChannelStats {
   int maxX;
   int maxY;
 
-  ChannelStats():
-    min(0), max(0), sum(0), squaresSum(0), mean(0), stdev(0)
-    , minX(0), minY(0), maxX(0), maxY(0) {}
-
-    ChannelStats(int minVal, int maxVal, double sumVal, double squaresSumVal,
-                  double meanVal, double stdevVal, int minXVal, int minYVal, int maxXVal, int maxYVal):
+  ChannelStats(int minVal, int maxVal, double sumVal, double squaresSumVal,
+    double meanVal, double stdevVal, int minXVal, int minYVal, int maxXVal, int maxYVal):
     min(minVal), max(maxVal), sum(sumVal), squaresSum(squaresSumVal),
     mean(meanVal), stdev(stdevVal), minX(minXVal), minY(minYVal), maxX(maxXVal), maxY(maxYVal) {}
 };
@@ -61,6 +57,6 @@ struct StatsBaton {
     {}
 };
 
-NAN_METHOD(stats);
+Napi::Value stats(const Napi::CallbackInfo& info);
 
 #endif  // SRC_STATS_H_