@shqld/canvas 2.11.2-rc.1

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,14 @@
+'use strict'
+
+/*!
+ * Canvas - Context2d
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const bindings = require('./bindings')
+const parseFont = require('./parse-font')
+const { DOMMatrix } = require('./DOMMatrix')
+
+bindings.CanvasRenderingContext2dInit(DOMMatrix, parseFont)
+module.exports = bindings.CanvasRenderingContext2d

package/lib/image.js

@@ -0,0 +1,96 @@
+'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')
+
+// Lazily loaded simple-get
+let get
+
+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
+          }
+        }
+
+        if (!get) get = require('simple-get')
+
+        get.concat({
+          url: val,
+          headers: { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36' }
+        }, (err, res, data) => {
+          if (err) return onerror(err)
+
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            return onerror(new Error(`Server responded with ${res.statusCode}`))
+          }
+
+          setSource(this, data)
+        })
+      } else { // local file path assumed
+        setSource(this, val)
+      }
+    } else if (Buffer.isBuffer(val)) {
+      setSource(this, val)
+    }
+  },
+
+  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/parse-font.js

@@ -0,0 +1,101 @@
+'use strict'
+
+/**
+ * Font RegExp helpers.
+ */
+
+const weights = 'bold|bolder|lighter|[1-9]00'
+const styles = 'italic|oblique'
+const variants = 'small-caps'
+const stretches = 'ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded'
+const units = 'px|pt|pc|in|cm|mm|%|em|ex|ch|rem|q'
+const string = '\'([^\']+)\'|"([^"]+)"|[\\w\\s-]+'
+
+// [ [ <‘font-style’> || <font-variant-css21> || <‘font-weight’> || <‘font-stretch’> ]?
+//    <‘font-size’> [ / <‘line-height’> ]? <‘font-family’> ]
+// https://drafts.csswg.org/css-fonts-3/#font-prop
+const weightRe = new RegExp(`(${weights}) +`, 'i')
+const styleRe = new RegExp(`(${styles}) +`, 'i')
+const variantRe = new RegExp(`(${variants}) +`, 'i')
+const stretchRe = new RegExp(`(${stretches}) +`, 'i')
+const sizeFamilyRe = new RegExp(
+  `([\\d\\.]+)(${units}) *((?:${string})( *, *(?:${string}))*)`)
+
+/**
+ * Cache font parsing.
+ */
+
+const cache = {}
+
+const defaultHeight = 16 // pt, common browser default
+
+/**
+ * Parse font `str`.
+ *
+ * @param {String} str
+ * @return {Object} Parsed font. `size` is in device units. `unit` is the unit
+ *   appearing in the input string.
+ * @api private
+ */
+
+module.exports = str => {
+  // Cached
+  if (cache[str]) return cache[str]
+
+  // Try for required properties first.
+  const sizeFamily = sizeFamilyRe.exec(str)
+  if (!sizeFamily) return // invalid
+
+  // Default values and required properties
+  const font = {
+    weight: 'normal',
+    style: 'normal',
+    stretch: 'normal',
+    variant: 'normal',
+    size: parseFloat(sizeFamily[1]),
+    unit: sizeFamily[2],
+    family: sizeFamily[3].replace(/["']/g, '').replace(/ *, */g, ',')
+  }
+
+  // Optional, unordered properties.
+  let weight, style, variant, stretch
+  // Stop search at `sizeFamily.index`
+  const substr = str.substring(0, sizeFamily.index)
+  if ((weight = weightRe.exec(substr))) font.weight = weight[1]
+  if ((style = styleRe.exec(substr))) font.style = style[1]
+  if ((variant = variantRe.exec(substr))) font.variant = variant[1]
+  if ((stretch = stretchRe.exec(substr))) font.stretch = stretch[1]
+
+  // Convert to device units. (`font.unit` is the original unit)
+  // TODO: ch, ex
+  switch (font.unit) {
+    case 'pt':
+      font.size /= 0.75
+      break
+    case 'pc':
+      font.size *= 16
+      break
+    case 'in':
+      font.size *= 96
+      break
+    case 'cm':
+      font.size *= 96.0 / 2.54
+      break
+    case 'mm':
+      font.size *= 96.0 / 25.4
+      break
+    case '%':
+      // TODO disabled because existing unit tests assume 100
+      // font.size *= defaultHeight / 100 / 0.75
+      break
+    case 'em':
+    case 'rem':
+      font.size *= defaultHeight / 0.75
+      break
+    case 'q':
+      font.size *= 96 / 25.4 / 4
+      break
+  }
+
+  return (cache[str] = font)
+}

package/lib/pattern.js

@@ -0,0 +1,17 @@
+'use strict'
+
+/*!
+ * Canvas - CanvasPattern
+ * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+ * MIT Licensed
+ */
+
+const bindings = require('./bindings')
+const { DOMMatrix } = require('./DOMMatrix')
+
+bindings.CanvasPatternInit(DOMMatrix)
+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,71 @@
+{
+  "name": "@shqld/canvas",
+  "description": "Canvas graphics API backed by Cairo",
+  "version": "2.11.2-rc.1",
+  "author": "TJ Holowaychuk <tj@learnboost.com>",
+  "main": "index.js",
+  "browser": "browser.js",
+  "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",
+    "dtslint": "dtslint types"
+  },
+  "files": [
+    "binding.gyp",
+    "lib/",
+    "scripts/",
+    "src/",
+    "util/",
+    "types/index.d.ts"
+  ],
+  "types": "types/index.d.ts",
+  "dependencies": {
+    "nan": "^2.17.0"
+  },
+  "optionalDependencies": {
+    "@shqld/canvas-darwin-arm64": "2.11.2-rc.1",
+    "@shqld/canvas-darwin-x64": "2.11.2-rc.1",
+    "@shqld/canvas-linux-arm64-gnu": "2.11.2-rc.1",
+    "@shqld/canvas-linux-x64-gnu": "2.11.2-rc.1",
+    "@shqld/canvas-win32-x64": "2.11.2-rc.1"
+  },
+  "devDependencies": {
+    "@types/node": "^10.12.18",
+    "assert-rejects": "^1.0.0",
+    "dtslint": "^4.0.7",
+    "express": "^4.16.3",
+    "js-yaml": "^4.1.0",
+    "mocha": "^5.2.0",
+    "pixelmatch": "^4.0.2",
+    "standard": "^12.0.1",
+    "typescript": "^4.2.2"
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "license": "MIT"
+}

package/scripts/install.js

@@ -0,0 +1,24 @@
+'use strict'
+
+// If a prebuilt binary is available and functional, skip node-gyp.
+// Otherwise, fall back to building from source.
+
+try {
+  const bindings = require('../lib/bindings')
+  const canvas = new bindings.Canvas(1, 1)
+  canvas.getContext('2d')
+  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.cc

@@ -0,0 +1,18 @@
+#include "Backends.h"
+
+#include "backend/ImageBackend.h"
+#include "backend/PdfBackend.h"
+#include "backend/SvgBackend.h"
+
+using namespace v8;
+
+void Backends::Initialize(Local<Object> target) {
+  Nan::HandleScope scope;
+
+  Local<Object> obj = Nan::New<Object>();
+  ImageBackend::Initialize(obj);
+  PdfBackend::Initialize(obj);
+  SvgBackend::Initialize(obj);
+
+  Nan::Set(target, Nan::New<String>("Backends").ToLocalChecked(), obj).Check();
+}

package/src/Backends.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "backend/Backend.h"
+#include <nan.h>
+#include <v8.h>
+
+class Backends : public Nan::ObjectWrap {
+  public:
+    static void Initialize(v8::Local<v8::Object> target);
+};