@revizly/sharp 0.35.0-revizly4 → 0.35.0-revizly41

package/dist/sharp.cjs

@@ -0,0 +1,125 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+// Inspects the runtime environment and exports the relevant sharp.node binary
+
+
+const { familySync, versionSync } = require("detect-libc");
+
+const libvips = require("./libvips.cjs");
+const pkg = require('../package.json');
+
+
+const { version } = pkg;
+
+const { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = libvips;
+const runtimePlatform = runtimePlatformArch();
+
+/* node:coverage disable */
+
+let sharp;
+const errors = [];
+try {
+  sharp = require(`../src/build/Release/sharp-${runtimePlatform}-${version}.node`);
+} catch (err) {
+  errors.push(err);
+}
+if (!sharp) {
+  try {
+    sharp = require(`../src/build/Release/sharp-wasm32-${version}.node`);
+  } catch (err) {
+    errors.push(err);
+  }
+}
+if (!sharp) {
+  try {
+    switch (runtimePlatform) {
+      case "linux-arm64":
+        sharp = require("@revizly/sharp-linux-arm64/sharp.node");
+        break;
+      case "linux-x64":
+        sharp = require("@revizly/sharp-linux-x64/sharp.node");
+        break;
+    }
+    if (sharp && runtimePlatform === "linux-x64" && !sharp._isUsingX64V2()) {
+      const err = new Error("Prebuilt binaries for Linux x64 require v2 microarchitecture");
+      err.code = "Unsupported CPU";
+      errors.push(err);
+      sharp = null;
+    }
+    if (sharp && process.versions.electron && runtimePlatform.startsWith("linux")) {
+      process.emitWarning(
+        "Binaries provided by Electron for use on Linux may be incompatible with sharp - see https://sharp.pixelplumbing.com/install#electron-and-linux",
+        { code: "SharpElectronLinux" }
+      );
+    }
+  } catch (err) {
+    errors.push(err);
+  }
+}
+
+if (!sharp) {
+  const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os) => runtimePlatform.startsWith(os));
+
+  const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
+  errors.forEach((err) => {
+    if (!err.code.endsWith("MODULE_NOT_FOUND")) {
+      help.push(`${err.code}: ${err.message}`);
+    }
+  });
+  const messages = errors.map((err) => err.message).join(" ");
+  help.push("Possible solutions:");
+  // Common error messages
+  if (isUnsupportedNodeRuntime()) {
+    const { found, expected } = isUnsupportedNodeRuntime();
+    help.push("- Please upgrade Node.js:", `    Found ${found}`, `    Requires ${expected}`);
+  } else if (prebuiltPlatforms.includes(runtimePlatform)) {
+    const [os, cpu] = runtimePlatform.split("-");
+    const libc = os.endsWith("musl") ? " --libc=musl" : "";
+    help.push(
+      "- Ensure optional dependencies can be installed:",
+      "    npm install --include=optional sharp",
+      "- Ensure your package manager supports multi-platform installation:",
+      "    See https://sharp.pixelplumbing.com/install#cross-platform",
+      "- Add platform-specific dependencies:",
+      `    npm install --os=${os.replace("musl", "")}${libc} --cpu=${cpu} sharp`,
+    );
+  } else {
+    help.push(
+      `- Manually install libvips >= ${minimumLibvipsVersion}`,
+      "    See https://sharp.pixelplumbing.com/install#building-from-source",
+    );
+  }
+  if (isLinux && /(symbol not found|CXXABI_)/i.test(messages)) {
+    try {
+      const { config } = require(`@revizly/sharp-libvips-${runtimePlatform}/package`);
+      const libcFound = `${familySync()} ${versionSync()}`;
+      const libcRequires = `${config.musl ? "musl" : "glibc"} ${config.musl || config.glibc}`;
+      help.push("- Update your OS:", `    Found ${libcFound}`, `    Requires ${libcRequires}`);
+    } catch (_errEngines) {}
+  }
+  if (isLinux && /\/snap\/core[0-9]{2}/.test(messages)) {
+    help.push("- Remove the Node.js Snap, which does not support native modules", "    snap remove node");
+  }
+  if (isMacOs && /Incompatible library version/.test(messages)) {
+    help.push("- Update Homebrew:", "    brew update && brew upgrade vips");
+  }
+  if (errors.some((err) => err.code === "ERR_DLOPEN_DISABLED")) {
+    help.push("- Run Node.js without using the --no-addons flag");
+  }
+  // Link to installation docs
+  if (isWindows && /The specified procedure could not be found/.test(messages)) {
+    help.push(
+      "- Using the canvas package on Windows?",
+      "    See https://sharp.pixelplumbing.com/install#canvas-and-windows",
+      "- Check for outdated versions of sharp in the dependency tree:",
+      "    npm ls sharp",
+    );
+  }
+  help.push("- Consult the installation documentation:", "    See https://sharp.pixelplumbing.com/install");
+  throw new Error(help.join("\n"));
+}
+
+module.exports = sharp;

package/dist/sharp.mjs

@@ -0,0 +1,125 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+// Inspects the runtime environment and exports the relevant sharp.node binary
+
+import { createRequire } from "node:module"
+import { familySync, versionSync } from "detect-libc";
+
+import libvips from "./libvips.mjs";
+import pkg from '../package.json' with { type: 'json' };
+
+const require = createRequire(import.meta.url);
+const { version } = pkg;
+
+const { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = libvips;
+const runtimePlatform = runtimePlatformArch();
+
+/* node:coverage disable */
+
+let sharp;
+const errors = [];
+try {
+  sharp = require(`../src/build/Release/sharp-${runtimePlatform}-${version}.node`);
+} catch (err) {
+  errors.push(err);
+}
+if (!sharp) {
+  try {
+    sharp = require(`../src/build/Release/sharp-wasm32-${version}.node`);
+  } catch (err) {
+    errors.push(err);
+  }
+}
+if (!sharp) {
+  try {
+    switch (runtimePlatform) {
+      case "linux-arm64":
+        sharp = require("@revizly/sharp-linux-arm64/sharp.node");
+        break;
+      case "linux-x64":
+        sharp = require("@revizly/sharp-linux-x64/sharp.node");
+        break;
+    }
+    if (sharp && runtimePlatform === "linux-x64" && !sharp._isUsingX64V2()) {
+      const err = new Error("Prebuilt binaries for Linux x64 require v2 microarchitecture");
+      err.code = "Unsupported CPU";
+      errors.push(err);
+      sharp = null;
+    }
+    if (sharp && process.versions.electron && runtimePlatform.startsWith("linux")) {
+      process.emitWarning(
+        "Binaries provided by Electron for use on Linux may be incompatible with sharp - see https://sharp.pixelplumbing.com/install#electron-and-linux",
+        { code: "SharpElectronLinux" }
+      );
+    }
+  } catch (err) {
+    errors.push(err);
+  }
+}
+
+if (!sharp) {
+  const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os) => runtimePlatform.startsWith(os));
+
+  const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
+  errors.forEach((err) => {
+    if (!err.code.endsWith("MODULE_NOT_FOUND")) {
+      help.push(`${err.code}: ${err.message}`);
+    }
+  });
+  const messages = errors.map((err) => err.message).join(" ");
+  help.push("Possible solutions:");
+  // Common error messages
+  if (isUnsupportedNodeRuntime()) {
+    const { found, expected } = isUnsupportedNodeRuntime();
+    help.push("- Please upgrade Node.js:", `    Found ${found}`, `    Requires ${expected}`);
+  } else if (prebuiltPlatforms.includes(runtimePlatform)) {
+    const [os, cpu] = runtimePlatform.split("-");
+    const libc = os.endsWith("musl") ? " --libc=musl" : "";
+    help.push(
+      "- Ensure optional dependencies can be installed:",
+      "    npm install --include=optional sharp",
+      "- Ensure your package manager supports multi-platform installation:",
+      "    See https://sharp.pixelplumbing.com/install#cross-platform",
+      "- Add platform-specific dependencies:",
+      `    npm install --os=${os.replace("musl", "")}${libc} --cpu=${cpu} sharp`,
+    );
+  } else {
+    help.push(
+      `- Manually install libvips >= ${minimumLibvipsVersion}`,
+      "    See https://sharp.pixelplumbing.com/install#building-from-source",
+    );
+  }
+  if (isLinux && /(symbol not found|CXXABI_)/i.test(messages)) {
+    try {
+      const { config } = require(`@revizly/sharp-libvips-${runtimePlatform}/package`);
+      const libcFound = `${familySync()} ${versionSync()}`;
+      const libcRequires = `${config.musl ? "musl" : "glibc"} ${config.musl || config.glibc}`;
+      help.push("- Update your OS:", `    Found ${libcFound}`, `    Requires ${libcRequires}`);
+    } catch (_errEngines) {}
+  }
+  if (isLinux && /\/snap\/core[0-9]{2}/.test(messages)) {
+    help.push("- Remove the Node.js Snap, which does not support native modules", "    snap remove node");
+  }
+  if (isMacOs && /Incompatible library version/.test(messages)) {
+    help.push("- Update Homebrew:", "    brew update && brew upgrade vips");
+  }
+  if (errors.some((err) => err.code === "ERR_DLOPEN_DISABLED")) {
+    help.push("- Run Node.js without using the --no-addons flag");
+  }
+  // Link to installation docs
+  if (isWindows && /The specified procedure could not be found/.test(messages)) {
+    help.push(
+      "- Using the canvas package on Windows?",
+      "    See https://sharp.pixelplumbing.com/install#canvas-and-windows",
+      "- Check for outdated versions of sharp in the dependency tree:",
+      "    npm ls sharp",
+    );
+  }
+  help.push("- Consult the installation documentation:", "    See https://sharp.pixelplumbing.com/install");
+  throw new Error(help.join("\n"));
+}
+
+export default sharp;

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

@@ -4,13 +4,17 @@
 */
 
 const events = require('node:events');
+
+const { availableParallelism } = require("node:os");
 const detectLibc = require('detect-libc');
 
-const is = require('./is');
-const { runtimePlatformArch } = require('./libvips');
-const sharp = require('./sharp');
+const is = require('./is.cjs');
+const libvips = require('./libvips.cjs');
+const sharp = require('./sharp.cjs');
+const pkg = require("../package.json");
+
 
-const runtimePlatform = runtimePlatformArch();
+const runtimePlatform = libvips.runtimePlatformArch();
 const libvipsVersion = sharp.libvipsVersion();
 
 /**
@@ -24,7 +28,7 @@ const format = sharp.format();
 format.heif.output.alias = ['avif', 'heic'];
 format.jpeg.output.alias = ['jpe', 'jpg'];
 format.tiff.output.alias = ['tif'];
-format.jp2k.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
+format.jp2.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
 
 /**
  * An Object containing the available interpolators and their proper values
@@ -73,7 +77,7 @@ if (!libvipsVersion.isGlobal) {
     } catch (_) {}
   }
 }
-versions.sharp = require('../package.json').version;
+versions.sharp = pkg.version;
 
 /* node:coverage ignore next 5 */
 if (versions.heif && format.heif) {
@@ -110,6 +114,12 @@ function cache (options) {
       return sharp.cache(0, 0, 0);
     }
   } else if (is.object(options)) {
+    for (const property of ['memory', 'files', 'items']) {
+      const value = options[property];
+      if (is.defined(value) && !(is.integer(value) && value >= 0)) {
+        throw is.invalidParameterError(property, 'a positive integer', value);
+      }
+    }
     return sharp.cache(options.memory, options.files, options.items);
   } else {
     return sharp.cache();
@@ -151,12 +161,12 @@ function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
 /* node:coverage ignore next 7 */
-if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+if (!process.env.MALLOC_ARENA_MAX && detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
 } else if (detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024) {
   // Reduce default concurrency when musl thread over-subscription detected
-  sharp.concurrency(require('node:os').availableParallelism());
+  sharp.concurrency(availableParallelism());
 }
 
 /**

package/dist/utility.mjs

@@ -0,0 +1,301 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+import events from 'node:events';
+import { createRequire } from "node:module";
+import { availableParallelism } from "node:os";
+import detectLibc from 'detect-libc';
+
+import is from './is.mjs';
+import libvips from './libvips.mjs';
+import sharp from './sharp.mjs';
+import pkg from "../package.json" with { type: "json" };
+
+const require = createRequire(import.meta.url);
+const runtimePlatform = libvips.runtimePlatformArch();
+const libvipsVersion = sharp.libvipsVersion();
+
+/**
+ * An Object containing nested boolean values representing the available input and output formats/methods.
+ * @member
+ * @example
+ * console.log(sharp.format);
+ * @returns {Object}
+ */
+const format = sharp.format();
+format.heif.output.alias = ['avif', 'heic'];
+format.jpeg.output.alias = ['jpe', 'jpg'];
+format.tiff.output.alias = ['tif'];
+format.jp2.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
+
+/**
+ * An Object containing the available interpolators and their proper values
+ * @readonly
+ * @enum {string}
+ */
+const interpolators = {
+  /** [Nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation). Suitable for image enlargement only. */
+  nearest: 'nearest',
+  /** [Bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation). Faster than bicubic but with less smooth results. */
+  bilinear: 'bilinear',
+  /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
+  bicubic: 'bicubic',
+  /** [LBB interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
+  locallyBoundedBicubic: 'lbb',
+  /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
+  nohalo: 'nohalo',
+  /** [VSQBS interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+
+/**
+ * An Object containing the version numbers of sharp, libvips
+ * and (when using prebuilt binaries) its dependencies.
+ *
+ * @member
+ * @example
+ * console.log(sharp.versions);
+ */
+let versions = {
+  vips: libvipsVersion.semver
+};
+/* node:coverage ignore next 15 */
+if (!libvipsVersion.isGlobal) {
+  if (!libvipsVersion.isWasm) {
+    try {
+      versions = require(`@revizly/sharp-${runtimePlatform}/versions`);
+    } catch (_) {
+      try {
+        versions = require(`@revizly/sharp-libvips-${runtimePlatform}/versions`);
+      } catch (_) {}
+    }
+  } else {
+    try {
+      versions = require('@revizly/sharp-wasm32/versions');
+    } catch (_) {}
+  }
+}
+versions.sharp = pkg.version;
+
+/* node:coverage ignore next 5 */
+if (versions.heif && format.heif) {
+  // Prebuilt binaries provide AV1
+  format.heif.input.fileSuffix = ['.avif'];
+  format.heif.output.alias = ['avif'];
+}
+
+/**
+ * Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
+ * Existing entries in the cache will be trimmed after any change in limits.
+ * This method always returns cache statistics,
+ * useful for determining how much working memory is required for a particular task.
+ *
+ * @example
+ * const stats = sharp.cache();
+ * @example
+ * sharp.cache( { items: 200 } );
+ * sharp.cache( { files: 0 } );
+ * sharp.cache(false);
+ *
+ * @param {Object|boolean} [options=true] - Object with the following attributes, or boolean where true uses default cache settings and false removes all caching
+ * @param {number} [options.memory=50] - is the maximum memory in MB to use for this cache
+ * @param {number} [options.files=20] - is the maximum number of files to hold open
+ * @param {number} [options.items=100] - is the maximum number of operations to cache
+ * @returns {Object}
+ */
+function cache (options) {
+  if (is.bool(options)) {
+    if (options) {
+      // Default cache settings of 50MB, 20 files, 100 items
+      return sharp.cache(50, 20, 100);
+    } else {
+      return sharp.cache(0, 0, 0);
+    }
+  } else if (is.object(options)) {
+    for (const property of ['memory', 'files', 'items']) {
+      const value = options[property];
+      if (is.defined(value) && !(is.integer(value) && value >= 0)) {
+        throw is.invalidParameterError(property, 'a positive integer', value);
+      }
+    }
+    return sharp.cache(options.memory, options.files, options.items);
+  } else {
+    return sharp.cache();
+  }
+}
+cache(true);
+
+/**
+ * Gets or, when a concurrency is provided, sets
+ * the maximum number of threads _libvips_ should use to process _each image_.
+ * These are from a thread pool managed by glib,
+ * which helps avoid the overhead of creating new threads.
+ *
+ * This method always returns the current concurrency.
+ *
+ * The default value is the number of CPU cores,
+ * except when using glibc-based Linux without jemalloc,
+ * where the default is `1` to help reduce memory fragmentation.
+ *
+ * A value of `0` will reset this to the number of CPU cores.
+ *
+ * Some image format libraries spawn additional threads,
+ * e.g. libaom manages its own 4 threads when encoding AVIF images,
+ * and these are independent of the value set here.
+ *
+ * :::note
+ * Further {@link /performance/ control over performance} is available.
+ * :::
+ *
+ * @example
+ * const threads = sharp.concurrency(); // 4
+ * sharp.concurrency(2); // 2
+ * sharp.concurrency(0); // 4
+ *
+ * @param {number} [concurrency]
+ * @returns {number} concurrency
+ */
+function concurrency (concurrency) {
+  return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
+}
+/* node:coverage ignore next 7 */
+if (!process.env.MALLOC_ARENA_MAX && detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+  // Reduce default concurrency to 1 when using glibc memory allocator
+  sharp.concurrency(1);
+} else if (detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024) {
+  // Reduce default concurrency when musl thread over-subscription detected
+  sharp.concurrency(availableParallelism());
+}
+
+/**
+ * An EventEmitter that emits a `change` event when a task is either:
+ * - queued, waiting for _libuv_ to provide a worker thread
+ * - complete
+ * @member
+ * @example
+ * sharp.queue.on('change', function(queueLength) {
+ *   console.log('Queue contains ' + queueLength + ' task(s)');
+ * });
+ */
+const queue = new events.EventEmitter();
+
+/**
+ * Provides access to internal task counters.
+ * - queue is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
+ * - process is the number of resize tasks currently being processed.
+ *
+ * @example
+ * const counters = sharp.counters(); // { queue: 2, process: 4 }
+ *
+ * @returns {Object}
+ */
+function counters () {
+  return sharp.counters();
+}
+
+/**
+ * Get and set use of SIMD vector unit instructions.
+ * Requires libvips to have been compiled with highway support.
+ *
+ * Improves the performance of `resize`, `blur` and `sharpen` operations
+ * by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
+ *
+ * @example
+ * const simd = sharp.simd();
+ * // simd is `true` if the runtime use of highway is currently enabled
+ * @example
+ * const simd = sharp.simd(false);
+ * // prevent libvips from using highway at runtime
+ *
+ * @param {boolean} [simd=true]
+ * @returns {boolean}
+ */
+function simd (simd) {
+  return sharp.simd(is.bool(simd) ? simd : null);
+}
+
+/**
+ * Block libvips operations at runtime.
+ *
+ * This is in addition to the `VIPS_BLOCK_UNTRUSTED` environment variable,
+ * which when set will block all "untrusted" operations.
+ *
+ * @since 0.32.4
+ *
+ * @example <caption>Block all TIFF input.</caption>
+ * sharp.block({
+ *   operation: ['VipsForeignLoadTiff']
+ * });
+ *
+ * @param {Object} options
+ * @param {Array<string>} options.operation - List of libvips low-level operation names to block.
+ */
+function block (options) {
+  if (is.object(options)) {
+    if (Array.isArray(options.operation) && options.operation.every(is.string)) {
+      sharp.block(options.operation, true);
+    } else {
+      throw is.invalidParameterError('operation', 'Array<string>', options.operation);
+    }
+  } else {
+    throw is.invalidParameterError('options', 'object', options);
+  }
+}
+
+/**
+ * Unblock libvips operations at runtime.
+ *
+ * This is useful for defining a list of allowed operations.
+ *
+ * @since 0.32.4
+ *
+ * @example <caption>Block all input except WebP from the filesystem.</caption>
+ * sharp.block({
+ *   operation: ['VipsForeignLoad']
+ * });
+ * sharp.unblock({
+ *   operation: ['VipsForeignLoadWebpFile']
+ * });
+ *
+ * @example <caption>Block all input except JPEG and PNG from a Buffer or Stream.</caption>
+ * sharp.block({
+ *   operation: ['VipsForeignLoad']
+ * });
+ * sharp.unblock({
+ *   operation: ['VipsForeignLoadJpegBuffer', 'VipsForeignLoadPngBuffer']
+ * });
+ *
+ * @param {Object} options
+ * @param {Array<string>} options.operation - List of libvips low-level operation names to unblock.
+ */
+function unblock (options) {
+  if (is.object(options)) {
+    if (Array.isArray(options.operation) && options.operation.every(is.string)) {
+      sharp.block(options.operation, false);
+    } else {
+      throw is.invalidParameterError('operation', 'Array<string>', options.operation);
+    }
+  } else {
+    throw is.invalidParameterError('options', 'object', options);
+  }
+}
+
+/**
+ * Decorate the Sharp class with utility-related functions.
+ * @module Sharp
+ * @private
+ */
+export default (Sharp) => {
+  Sharp.cache = cache;
+  Sharp.concurrency = concurrency;
+  Sharp.counters = counters;
+  Sharp.simd = simd;
+  Sharp.format = format;
+  Sharp.interpolators = interpolators;
+  Sharp.versions = versions;
+  Sharp.queue = queue;
+  Sharp.block = block;
+  Sharp.unblock = unblock;
+};

package/install/build.js

@@ -8,9 +8,9 @@ const {
   globalLibvipsVersion,
   log,
   spawnRebuild,
-} = require('../lib/libvips');
+} = require('../dist/libvips.cjs');
 
-log('Attempting to build from source via node-gyp');
+log('Building from source');
 log('See https://sharp.pixelplumbing.com/install#building-from-source');
 
 try {
@@ -29,7 +29,7 @@ try {
 }
 
 if (useGlobalLibvips(log)) {
-  log(`Detected globally-installed libvips v${globalLibvipsVersion()}`);
+  log(`Found globally-installed libvips v${globalLibvipsVersion()}`);
 }
 
 const status = spawnRebuild();