@shqld/canvas 3.2.2-rc.1

package/lib/bindings.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const path = require('path')
+
+const PLATFORMS = {
+  'darwin-arm64': '@shqld/canvas-darwin-arm64',
+  'darwin-x64': '@shqld/canvas-darwin-x64',
+  'linux-arm64-gnu': '@shqld/canvas-linux-arm64-gnu',
+  'linux-arm64-musl': '@shqld/canvas-linux-arm64-musl',
+  'linux-x64-gnu': '@shqld/canvas-linux-x64-gnu',
+  'linux-x64-musl': '@shqld/canvas-linux-x64-musl',
+  'win32-x64': '@shqld/canvas-win32-x64'
+}
+
+function getPlatformKey () {
+  const platform = process.platform
+  const arch = process.arch
+  let key = `${platform}-${arch}`
+  if (platform === 'linux') {
+    key += isMuslLinux() ? '-musl' : '-gnu'
+  }
+  return key
+}
+
+function isMuslLinux () {
+  try {
+    const { execFileSync } = require('child_process')
+    const output = execFileSync('ldd', ['--version'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    })
+    return output.includes('musl')
+  } catch (e) {
+    // ldd --version exits non-zero on musl and prints to stderr
+    return e.stderr ? e.stderr.includes('musl') : false
+  }
+}
+
+function loadBinding () {
+  const key = getPlatformKey()
+  const packageName = PLATFORMS[key]
+
+  if (packageName) {
+    try {
+      // Windows: DLLs are next to canvas.node, add to search path
+      if (process.platform === 'win32') {
+        const pkgDir = path.dirname(require.resolve(`${packageName}/package.json`))
+        process.env.PATH = pkgDir + path.delimiter + process.env.PATH
+      }
+      return require(packageName)
+    } catch (_) {
+      // fall through to build-from-source fallback
+    }
+  }
+
+  // Fallback: locally built binary
+  try {
+    const localPath = path.resolve(__dirname, '..', 'build', 'Release')
+    if (process.platform === 'win32') {
+      process.env.PATH = localPath + path.delimiter + process.env.PATH
+    }
+    return require(path.join(localPath, 'canvas.node'))
+  } catch (_) {
+    const supported = Object.keys(PLATFORMS).join(', ')
+    throw new Error(
+      `No prebuilt canvas binary found for ${key}. ` +
+      `Supported platforms: ${supported}. ` +
+      'To build from source: npm rebuild canvas --build-from-source'
+    )
+  }
+}
+
+const bindings = loadBinding()
+
+module.exports = bindings
+
+Object.defineProperty(bindings.Canvas.prototype, Symbol.toStringTag, {
+  value: 'HTMLCanvasElement',
+  configurable: true
+})
+
+Object.defineProperty(bindings.Image.prototype, Symbol.toStringTag, {
+  value: 'HTMLImageElement',
+  configurable: true
+})
+
+bindings.ImageData.prototype.toString = function () {
+  return '[object ImageData]'
+}
+
+Object.defineProperty(bindings.ImageData.prototype, Symbol.toStringTag, {
+  value: 'ImageData',
+  configurable: true
+})
+
+bindings.CanvasGradient.prototype.toString = function () {
+  return '[object CanvasGradient]'
+}
+
+Object.defineProperty(bindings.CanvasGradient.prototype, Symbol.toStringTag, {
+  value: 'CanvasGradient',
+  configurable: true
+})
+
+Object.defineProperty(bindings.CanvasPattern.prototype, Symbol.toStringTag, {
+  value: 'CanvasPattern',
+  configurable: true
+})
+
+Object.defineProperty(bindings.CanvasRenderingContext2d.prototype, Symbol.toStringTag, {
+  value: 'CanvasRenderingContext2d',
+  configurable: true
+})

package/lib/canvas.js

@@ -0,0 +1,113 @@
+'use strict'
+
+/*!
+ * Canvas
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const bindings = require('./bindings')
+const Canvas = module.exports = bindings.Canvas
+const Context2d = require('./context2d')
+const PNGStream = require('./pngstream')
+const PDFStream = require('./pdfstream')
+const JPEGStream = require('./jpegstream')
+const FORMATS = ['image/png', 'image/jpeg']
+const util = require('util')
+
+// TODO || is for Node.js pre-v6.6.0
+Canvas.prototype[util.inspect.custom || 'inspect'] = function () {
+  return `[Canvas ${this.width}x${this.height}]`
+}
+
+Canvas.prototype.getContext = function (contextType, contextAttributes) {
+  if (contextType == '2d') {
+    const ctx = this._context2d || (this._context2d = new Context2d(this, contextAttributes))
+    this.context = ctx
+    ctx.canvas = this
+    return ctx
+  }
+}
+
+Canvas.prototype.pngStream =
+Canvas.prototype.createPNGStream = function (options) {
+  return new PNGStream(this, options)
+}
+
+Canvas.prototype.pdfStream =
+Canvas.prototype.createPDFStream = function (options) {
+  return new PDFStream(this, options)
+}
+
+Canvas.prototype.jpegStream =
+Canvas.prototype.createJPEGStream = function (options) {
+  return new JPEGStream(this, options)
+}
+
+Canvas.prototype.toDataURL = function (a1, a2, a3) {
+  // valid arg patterns (args -> [type, opts, fn]):
+  // [] -> ['image/png', null, null]
+  // [qual] -> ['image/png', null, null]
+  // [undefined] -> ['image/png', null, null]
+  // ['image/png'] -> ['image/png', null, null]
+  // ['image/png', qual] -> ['image/png', null, null]
+  // [fn] -> ['image/png', null, fn]
+  // [type, fn] -> [type, null, fn]
+  // [undefined, fn] -> ['image/png', null, fn]
+  // ['image/png', qual, fn] -> ['image/png', null, fn]
+  // ['image/jpeg', fn] -> ['image/jpeg', null, fn]
+  // ['image/jpeg', opts, fn] -> ['image/jpeg', opts, fn]
+  // ['image/jpeg', qual, fn] -> ['image/jpeg', {quality: qual}, fn]
+  // ['image/jpeg', undefined, fn] -> ['image/jpeg', null, fn]
+  // ['image/jpeg'] -> ['image/jpeg', null, fn]
+  // ['image/jpeg', opts] -> ['image/jpeg', opts, fn]
+  // ['image/jpeg', qual] -> ['image/jpeg', {quality: qual}, fn]
+
+  let type = 'image/png'
+  let opts = {}
+  let fn
+
+  if (typeof a1 === 'function') {
+    fn = a1
+  } else {
+    if (typeof a1 === 'string' && FORMATS.includes(a1.toLowerCase())) {
+      type = a1.toLowerCase()
+    }
+
+    if (typeof a2 === 'function') {
+      fn = a2
+    } else {
+      if (typeof a2 === 'object') {
+        opts = a2
+      } else if (typeof a2 === 'number') {
+        opts = { quality: Math.max(0, Math.min(1, a2)) }
+      }
+
+      if (typeof a3 === 'function') {
+        fn = a3
+      } else if (undefined !== a3) {
+        throw new TypeError(`${typeof a3} is not a function`)
+      }
+    }
+  }
+
+  if (this.width === 0 || this.height === 0) {
+    // Per spec, if the bitmap has no pixels, return this string:
+    const str = 'data:,'
+    if (fn) {
+      setTimeout(() => fn(null, str))
+      return
+    } else {
+      return str
+    }
+  }
+
+  if (fn) {
+    this.toBuffer((err, buf) => {
+      if (err) return fn(err)
+      fn(null, `data:${type};base64,${buf.toString('base64')}`)
+    }, type, opts)
+  } else {
+    return `data:${type};base64,${this.toBuffer(type, opts).toString('base64')}`
+  }
+}

package/lib/context2d.js

@@ -0,0 +1,11 @@
+'use strict'
+
+/*!
+ * Canvas - Context2d
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const bindings = require('./bindings')
+
+module.exports = bindings.CanvasRenderingContext2d

package/lib/image.js

@@ -0,0 +1,97 @@
+'use strict'
+
+/*!
+ * Canvas - Image
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+const bindings = require('./bindings')
+const Image = module.exports = bindings.Image
+const util = require('util')
+
+const { GetSource, SetSource } = bindings
+
+Object.defineProperty(Image.prototype, 'src', {
+  /**
+   * src setter. Valid values:
+   *  * `data:` URI
+   *  * Local file path
+   *  * HTTP or HTTPS URL
+   *  * Buffer containing image data (i.e. not a `data:` URI stored in a Buffer)
+   *
+   * @param {String|Buffer} val filename, buffer, data URI, URL
+   * @api public
+   */
+  set (val) {
+    if (typeof val === 'string') {
+      if (/^\s*data:/.test(val)) { // data: URI
+        const commaI = val.indexOf(',')
+        // 'base64' must come before the comma
+        const isBase64 = val.lastIndexOf('base64', commaI) !== -1
+        const content = val.slice(commaI + 1)
+        setSource(this, Buffer.from(content, isBase64 ? 'base64' : 'utf8'), val)
+      } else if (/^\s*https?:\/\//.test(val)) { // remote URL
+        const onerror = err => {
+          if (typeof this.onerror === 'function') {
+            this.onerror(err)
+          } else {
+            throw err
+          }
+        }
+
+        fetch(val, {
+          method: 'GET',
+          headers: { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36' }
+        })
+          .then(res => {
+            if (!res.ok) {
+              throw new Error(`Server responded with ${res.status}`)
+            }
+            return res.arrayBuffer()
+          })
+          .then(data => {
+            setSource(this, Buffer.from(data))
+          })
+          .catch(onerror)
+      } else { // local file path assumed
+        setSource(this, val)
+      }
+    } else if (Buffer.isBuffer(val)) {
+      setSource(this, val)
+    } else {
+      const err = new Error("Invalid image source")
+      if (typeof this.onerror === 'function') this.onerror(err)
+      else throw err
+    }
+  },
+
+  get () {
+    // TODO https://github.com/Automattic/node-canvas/issues/118
+    return getSource(this)
+  },
+
+  configurable: true
+})
+
+// TODO || is for Node.js pre-v6.6.0
+Image.prototype[util.inspect.custom || 'inspect'] = function () {
+  return '[Image' +
+    (this.complete ? ':' + this.width + 'x' + this.height : '') +
+    (this.src ? ' ' + this.src : '') +
+    (this.complete ? ' complete' : '') +
+    ']'
+}
+
+function getSource (img) {
+  return img._originalSource || GetSource.call(img)
+}
+
+function setSource (img, src, origSrc) {
+  SetSource.call(img, src)
+  img._originalSource = origSrc
+}

package/lib/jpegstream.js

@@ -0,0 +1,41 @@
+'use strict'
+
+/*!
+ * Canvas - JPEGStream
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const { Readable } = require('stream')
+function noop () {}
+
+class JPEGStream extends Readable {
+  constructor (canvas, options) {
+    super()
+
+    if (canvas.streamJPEGSync === undefined) {
+      throw new Error('node-canvas was built without JPEG support.')
+    }
+
+    this.options = options
+    this.canvas = canvas
+  }
+
+  _read () {
+    // For now we're not controlling the c++ code's data emission, so we only
+    // call canvas.streamJPEGSync once and let it emit data at will.
+    this._read = noop
+
+    this.canvas.streamJPEGSync(this.options, (err, chunk) => {
+      if (err) {
+        this.emit('error', err)
+      } else if (chunk) {
+        this.push(chunk)
+      } else {
+        this.push(null)
+      }
+    })
+  }
+};
+
+module.exports = JPEGStream

package/lib/pattern.js

@@ -0,0 +1,15 @@
+'use strict'
+
+/*!
+ * Canvas - CanvasPattern
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const bindings = require('./bindings')
+
+module.exports = bindings.CanvasPattern
+
+bindings.CanvasPattern.prototype.toString = function () {
+	return '[object CanvasPattern]'
+}

package/lib/pdfstream.js

@@ -0,0 +1,35 @@
+'use strict'
+
+/*!
+ * Canvas - PDFStream
+ */
+
+const { Readable } = require('stream')
+function noop () {}
+
+class PDFStream extends Readable {
+  constructor (canvas, options) {
+    super()
+
+    this.canvas = canvas
+    this.options = options
+  }
+
+  _read () {
+    // For now we're not controlling the c++ code's data emission, so we only
+    // call canvas.streamPDFSync once and let it emit data at will.
+    this._read = noop
+
+    this.canvas.streamPDFSync((err, chunk, len) => {
+      if (err) {
+        this.emit('error', err)
+      } else if (len) {
+        this.push(chunk)
+      } else {
+        this.push(null)
+      }
+    }, this.options)
+  }
+}
+
+module.exports = PDFStream

package/lib/pngstream.js

@@ -0,0 +1,42 @@
+'use strict'
+
+/*!
+ * Canvas - PNGStream
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const { Readable } = require('stream')
+function noop () {}
+
+class PNGStream extends Readable {
+  constructor (canvas, options) {
+    super()
+
+    if (options &&
+      options.palette instanceof Uint8ClampedArray &&
+      options.palette.length % 4 !== 0) {
+      throw new Error('Palette length must be a multiple of 4.')
+    }
+    this.canvas = canvas
+    this.options = options || {}
+  }
+
+  _read () {
+    // For now we're not controlling the c++ code's data emission, so we only
+    // call canvas.streamPNGSync once and let it emit data at will.
+    this._read = noop
+
+    this.canvas.streamPNGSync((err, chunk, len) => {
+      if (err) {
+        this.emit('error', err)
+      } else if (len) {
+        this.push(chunk)
+      } else {
+        this.push(null)
+      }
+    }, this.options)
+  }
+}
+
+module.exports = PNGStream

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@shqld/canvas",
+  "description": "Canvas graphics API backed by Cairo",
+  "version": "3.2.2-rc.1",
+  "author": "TJ Holowaychuk <tj@learnboost.com>",
+  "main": "index.js",
+  "browser": "browser.js",
+  "types": "index.d.ts",
+  "contributors": [
+    "Nathan Rajlich <nathan@tootallnate.net>",
+    "Rod Vagg <r@va.gg>",
+    "Juriy Zaytsev <kangax@gmail.com>"
+  ],
+  "keywords": [
+    "canvas",
+    "graphic",
+    "graphics",
+    "pixman",
+    "cairo",
+    "image",
+    "images",
+    "pdf"
+  ],
+  "homepage": "https://github.com/Automattic/node-canvas",
+  "repository": "git://github.com/Automattic/node-canvas.git",
+  "scripts": {
+    "prebenchmark": "node-gyp build",
+    "benchmark": "node benchmarks/run.js",
+    "lint": "standard examples/*.js test/server.js test/public/*.js benchmarks/run.js lib/context2d.js util/has_lib.js browser.js index.js",
+    "test": "mocha test/*.test.js",
+    "pretest-server": "node-gyp build",
+    "test-server": "node test/server.js",
+    "generate-wpt": "node ./test/wpt/generate.js",
+    "test-wpt": "mocha test/wpt/generated/*.js",
+    "install": "node scripts/install.js",
+    "tsd": "tsd"
+  },
+  "files": [
+    "binding.gyp",
+    "browser.js",
+    "index.d.ts",
+    "index.js",
+    "lib/",
+    "scripts/",
+    "src/",
+    "util/"
+  ],
+  "dependencies": {},
+  "optionalDependencies": {
+    "@shqld/canvas-darwin-arm64": "3.2.2-rc.1",
+    "@shqld/canvas-darwin-x64": "3.2.2-rc.1",
+    "@shqld/canvas-linux-arm64-gnu": "3.2.2-rc.1",
+    "@shqld/canvas-linux-x64-gnu": "3.2.2-rc.1",
+    "@shqld/canvas-win32-x64": "3.2.2-rc.1"
+  },
+  "devDependencies": {
+    "node-addon-api": "^7.0.0",
+    "@types/node": "^10.12.18",
+    "assert-rejects": "^1.0.0",
+    "express": "^4.16.3",
+    "js-yaml": "^4.1.0",
+    "mocha": "^5.2.0",
+    "pixelmatch": "^4.0.2",
+    "standard": "^12.0.1",
+    "tsd": "^0.29.0",
+    "typescript": "^4.2.2"
+  },
+  "engines": {
+    "node": "^18.12.0 || >= 20.9.0"
+  },
+  "binary": {
+    "napi_versions": [
+      7
+    ]
+  },
+  "license": "MIT"
+}

package/scripts/install.js

@@ -0,0 +1,19 @@
+'use strict'
+
+// If a prebuilt binary is available, skip node-gyp entirely.
+// Otherwise, fall back to building from source.
+
+try {
+  require('../lib/bindings')
+  process.exit(0)
+} catch (_) {
+  const { execSync } = require('child_process')
+  try {
+    execSync('node-gyp rebuild', { stdio: 'inherit', cwd: require('path').resolve(__dirname, '..') })
+  } catch (e) {
+    console.error('Failed to build canvas from source.')
+    console.error('Please install the required system dependencies:')
+    console.error('  https://github.com/Automattic/node-canvas#compiling')
+    process.exit(1)
+  }
+}

package/src/Backends.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "backend/Backend.h"
+#include <napi.h>
+
+class Backends : public Napi::ObjectWrap<Backends> {
+  public:
+    static void Initialize(Napi::Env env, Napi::Object exports);
+};