@napi-rs/canvas 1.0.12 → 1.0.13

package/index.js

@@ -103,11 +103,26 @@ if (!('has' in GlobalFonts)) {
   })
 }
 
-const _toBlob = CanvasElement.prototype.toBlob
-const _convertToBlob = CanvasElement.prototype.convertToBlob
+// Re-evaluating this module (Jest resets its module registry per test
+// file; the .node binding and its prototypes stay loaded) must wrap the
+// native methods again, not the previous wrappers: their argument padding
+// would corrupt the argument count the native methods read.
+const NATIVE_METHODS = Symbol.for('@napi-rs/canvas:native-methods')
+function nativeMethods(proto) {
+  let stash = proto[NATIVE_METHODS]
+  if (stash === undefined) {
+    stash = {}
+    Object.defineProperty(proto, NATIVE_METHODS, { value: stash })
+  }
+  return stash
+}
+
+const canvasNative = nativeMethods(CanvasElement.prototype)
+const _toBlob = (canvasNative.toBlob ??= CanvasElement.prototype.toBlob)
+const _convertToBlob = (canvasNative.convertToBlob ??= CanvasElement.prototype.convertToBlob)
 // A native method of CanvasElement for the receiver check: with no arguments
 // it has no side effects.
-const canvasBrand = CanvasElement.prototype.getContext
+const canvasBrand = (canvasNative.getContext ??= CanvasElement.prototype.getContext)
 if ('Blob' in globalThis) {
   // toBlob(callback, type, quality), as Chrome: the receiver, the argument
   // count and the callback are checked first, then the native method converts
@@ -155,7 +170,8 @@ if ('Blob' in globalThis) {
   }
 }
 
-const _getTransform = CanvasRenderingContext2D.prototype.getTransform
+const ctxNative = nativeMethods(CanvasRenderingContext2D.prototype)
+const _getTransform = (ctxNative.getTransform ??= CanvasRenderingContext2D.prototype.getTransform)
 
 CanvasRenderingContext2D.prototype.getTransform = function getTransform() {
   const transform = _getTransform.apply(this, arguments)
@@ -206,7 +222,8 @@ function bindingTypeError(brand, self, method, iface, message) {
 // napi pads missing arguments with undefined, so the native method cannot
 // tell f(1) from f(1, undefined); an explicit undefined counts in Chrome.
 function requireArguments(proto, brand, iface, method, required) {
-  const native = proto[method]
+  const stash = nativeMethods(proto)
+  const native = (stash[method] ??= proto[method])
   const wrapper = {
     [method]() {
       if (arguments.length < required) {
@@ -256,7 +273,8 @@ for (const [Class, iface] of [
   [CanvasElement, 'HTMLCanvasElement'],
   [SVGCanvas, 'SVGCanvas'],
 ]) {
-  requireArguments(Class.prototype, Class.prototype.getContext, iface, 'getContext', 1)
+  const stash = nativeMethods(Class.prototype)
+  requireArguments(Class.prototype, (stash.getContext ??= Class.prototype.getContext), iface, 'getContext', 1)
 }
 
 const pathBrand = Path2D.prototype.getFillType
@@ -312,7 +330,7 @@ function argumentCount(count, last) {
 // These wrappers and drawImage's read only the arguments the call has: past
 // arguments.length, arguments[i] would read Object.prototype[i], which
 // Chrome never reads.
-const _fill = CanvasRenderingContext2D.prototype.fill
+const _fill = (ctxNative.fill ??= CanvasRenderingContext2D.prototype.fill)
 CanvasRenderingContext2D.prototype.fill = function fill() {
   const count = Math.min(arguments.length, 2)
   return _fill.call(
@@ -323,7 +341,7 @@ CanvasRenderingContext2D.prototype.fill = function fill() {
   )
 }
 
-const _clip = CanvasRenderingContext2D.prototype.clip
+const _clip = (ctxNative.clip ??= CanvasRenderingContext2D.prototype.clip)
 CanvasRenderingContext2D.prototype.clip = function clip() {
   const count = Math.min(arguments.length, 2)
   return _clip.call(
@@ -334,7 +352,7 @@ CanvasRenderingContext2D.prototype.clip = function clip() {
   )
 }
 
-const _stroke = CanvasRenderingContext2D.prototype.stroke
+const _stroke = (ctxNative.stroke ??= CanvasRenderingContext2D.prototype.stroke)
 CanvasRenderingContext2D.prototype.stroke = function stroke() {
   if (arguments.length === 0) {
     return _stroke.call(this, undefined, undefined)
@@ -343,7 +361,7 @@ CanvasRenderingContext2D.prototype.stroke = function stroke() {
   return _stroke.call(this, path, argumentCount(1, path))
 }
 
-const _isPointInPath = CanvasRenderingContext2D.prototype.isPointInPath
+const _isPointInPath = (ctxNative.isPointInPath ??= CanvasRenderingContext2D.prototype.isPointInPath)
 CanvasRenderingContext2D.prototype.isPointInPath = function isPointInPath() {
   if (arguments.length < 2) {
     argumentCountError(ctxBrand, this, 'isPointInPath', 'CanvasRenderingContext2D', 2, arguments.length)
@@ -362,7 +380,7 @@ CanvasRenderingContext2D.prototype.isPointInPath = function isPointInPath() {
 }
 Object.defineProperty(CanvasRenderingContext2D.prototype.isPointInPath, 'length', { value: 2 })
 
-const _isPointInStroke = CanvasRenderingContext2D.prototype.isPointInStroke
+const _isPointInStroke = (ctxNative.isPointInStroke ??= CanvasRenderingContext2D.prototype.isPointInStroke)
 CanvasRenderingContext2D.prototype.isPointInStroke = function isPointInStroke() {
   if (arguments.length < 2) {
     argumentCountError(ctxBrand, this, 'isPointInStroke', 'CanvasRenderingContext2D', 2, arguments.length)
@@ -498,7 +516,7 @@ function matrix2DFromInit(init, prefix, full) {
 // DOMMatrixInit is read above; the native method takes six numbers. It reads
 // a first argument that is not a number as a DOMMatrixInit, the form a raw
 // js-binding call may use, so ToNumber runs here for such an `a`.
-const _setTransform = CanvasRenderingContext2D.prototype.setTransform
+const _setTransform = (ctxNative.setTransform ??= CanvasRenderingContext2D.prototype.setTransform)
 // A cheap native method: on another receiver it throws 'Illegal invocation',
 // which Chrome checks before it converts any argument.
 const ctxReceiver = CanvasRenderingContext2D.prototype.isContextLost
@@ -526,8 +544,9 @@ CanvasRenderingContext2D.prototype.setTransform = function setTransform() {
 // transform (undefined or null is `{}`), a native method that takes only the
 // path adds it as it is; Chrome's Path2D has no such method, so it comes off
 // the prototype.
-const _addPath = Path2D.prototype.addPath
-const _addPathWithoutTransform = Path2D.prototype._addPathWithoutTransform
+const pathNative = nativeMethods(Path2D.prototype)
+const _addPath = (pathNative.addPath ??= Path2D.prototype.addPath)
+const _addPathWithoutTransform = (pathNative._addPathWithoutTransform ??= Path2D.prototype._addPathWithoutTransform)
 delete Path2D.prototype._addPathWithoutTransform
 const ADD_PATH = "Failed to execute 'addPath' on 'Path2D': "
 Path2D.prototype.addPath = function addPath() {
@@ -554,7 +573,7 @@ Object.defineProperty(Path2D.prototype.addPath, 'length', { value: 1 })
 // createImageData(): WebIDL picks the overload from the argument count, and an
 // explicit undefined counts: createImageData(imagedata, undefined) is the
 // (sw, sh) form.
-const _createImageData = CanvasRenderingContext2D.prototype.createImageData
+const _createImageData = (ctxNative.createImageData ??= CanvasRenderingContext2D.prototype.createImageData)
 
 CanvasRenderingContext2D.prototype.createImageData = function createImageData() {
   const count = arguments.length
@@ -574,7 +593,7 @@ Object.defineProperty(CanvasRenderingContext2D.prototype.createImageData, 'lengt
 // putImageData(imagedata, dx, dy) or (imagedata, dx, dy, dirtyX, dirtyY,
 // dirtyWidth, dirtyHeight): as in Chrome, it needs 3 arguments; the native
 // method picks the overload from the argument count (3 or 7).
-const _putImageData = CanvasRenderingContext2D.prototype.putImageData
+const _putImageData = (ctxNative.putImageData ??= CanvasRenderingContext2D.prototype.putImageData)
 
 CanvasRenderingContext2D.prototype.putImageData = function putImageData() {
   const count = arguments.length
@@ -601,7 +620,7 @@ Object.defineProperty(CanvasRenderingContext2D.prototype.putImageData, 'length',
 // required, and the image is converted before the repetition, a
 // [LegacyNullToEmptyString] DOMString (canvas_2d_recorder_context.idl), so
 // null is '' and undefined is 'undefined'.
-const _createPattern = CanvasRenderingContext2D.prototype.createPattern
+const _createPattern = (ctxNative.createPattern ??= CanvasRenderingContext2D.prototype.createPattern)
 
 CanvasRenderingContext2D.prototype.createPattern = function createPattern(image, repetition) {
   return _createPattern.call(this, image, repetition, ARGUMENT_COUNTS[Math.min(arguments.length, 4)])
@@ -610,14 +629,15 @@ CanvasRenderingContext2D.prototype.createPattern = function createPattern(image,
 // addColorStop(offset, color): both arguments are required. CanvasGradient
 // has no other native method to check the receiver first, so the native
 // method itself reads the real count from the marker after them.
-const _addColorStop = CanvasGradient.prototype.addColorStop
+const gradientNative = nativeMethods(CanvasGradient.prototype)
+const _addColorStop = (gradientNative.addColorStop ??= CanvasGradient.prototype.addColorStop)
 CanvasGradient.prototype.addColorStop = function addColorStop(offset, color) {
   return _addColorStop.call(this, offset, color, ARGUMENT_COUNTS[Math.min(arguments.length, 2)])
 }
 
 // Workaround for webpack bundling issue with drawImage
 // Store the original drawImage method
-const _drawImage = CanvasRenderingContext2D.prototype.drawImage
+const _drawImage = (ctxNative.drawImage ??= CanvasRenderingContext2D.prototype.drawImage)
 
 // Override drawImage to ensure proper type recognition in bundled environments.
 // As in Chrome, it needs 3 arguments; the native method picks the overload

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/canvas",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Canvas for Node.js with skia backend",
   "main": "index.js",
   "repository": {
@@ -161,16 +161,16 @@
     "@napi-rs/canvas": "workspace:"
   },
   "optionalDependencies": {
-    "@napi-rs/canvas-linux-x64-gnu": "1.0.12",
-    "@napi-rs/canvas-darwin-x64": "1.0.12",
-    "@napi-rs/canvas-win32-x64-msvc": "1.0.12",
-    "@napi-rs/canvas-win32-arm64-msvc": "1.0.12",
-    "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.12",
-    "@napi-rs/canvas-linux-x64-musl": "1.0.12",
-    "@napi-rs/canvas-linux-arm64-gnu": "1.0.12",
-    "@napi-rs/canvas-linux-arm64-musl": "1.0.12",
-    "@napi-rs/canvas-darwin-arm64": "1.0.12",
-    "@napi-rs/canvas-android-arm64": "1.0.12",
-    "@napi-rs/canvas-linux-riscv64-gnu": "1.0.12"
+    "@napi-rs/canvas-linux-x64-gnu": "1.0.13",
+    "@napi-rs/canvas-darwin-x64": "1.0.13",
+    "@napi-rs/canvas-win32-x64-msvc": "1.0.13",
+    "@napi-rs/canvas-win32-arm64-msvc": "1.0.13",
+    "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.13",
+    "@napi-rs/canvas-linux-x64-musl": "1.0.13",
+    "@napi-rs/canvas-linux-arm64-gnu": "1.0.13",
+    "@napi-rs/canvas-linux-arm64-musl": "1.0.13",
+    "@napi-rs/canvas-darwin-arm64": "1.0.13",
+    "@napi-rs/canvas-android-arm64": "1.0.13",
+    "@napi-rs/canvas-linux-riscv64-gnu": "1.0.13"
   }
 }