@nativescript/canvas 2.0.0-alpha.0 → 2.0.0-alpha.10

package/Canvas2D/CanvasRenderingContext2D/{index.android.js → index.js}

@@ -1,4 +1,3 @@
-import { CanvasRenderingContext2DBase } from './common';
 import { CanvasGradient } from '../CanvasGradient';
 import { Path2D } from '../Path2D';
 import { ImageData } from '../ImageData';
@@ -9,9 +8,9 @@ import { CanvasPattern } from '../CanvasPattern';
 import { Canvas } from '../../Canvas';
 import { Helpers } from '../../helpers';
 let ctor;
-export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
+export class CanvasRenderingContext2D {
     constructor(context, contextOptions) {
-        super();
+        this._type = 'none';
         this._methodCache = new Map();
         /*const width = context.getDrawingBufferWidth(); // can use  getMeasuredWidth / getMeasuredHeight
         const height = context.getDrawingBufferHeight();
@@ -26,6 +25,9 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         const ctxPtr = BigInt(context.toString());
         this.context = ctor(ctxPtr);
     }
+    get type() {
+        return this._type;
+    }
     get native() {
         return this.context;
     }
@@ -33,161 +35,130 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         return this._canvas;
     }
     get shadowColor() {
-        this.log('shadowColor');
         return this.context.shadowColor;
     }
     set shadowColor(color) {
-        this.log('shadowColor value:', color);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.shadowColor = color;
         }
     }
     get font() {
-        this.log('get font');
         return this.context.font;
     }
     set font(value) {
-        this.log('set font value:', value);
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.font = value;
         }
     }
     get direction() {
-        this.log('direction');
         return this.context.direction;
     }
     set direction(value) {
-        this.log('direction value:', value);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.direction = value;
         }
     }
     get globalAlpha() {
-        this.log('globalAlpha');
         return this.context.globalAlpha;
     }
     set globalAlpha(alpha) {
-        this.log('globalAlpha value:', alpha);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.globalAlpha = alpha;
         }
     }
     get imageSmoothingEnabled() {
-        this.log('imageSmoothingEnabled');
         return this.context.imageSmoothingEnabled;
     }
     set imageSmoothingEnabled(enabled) {
-        this.log('imageSmoothingEnabled value:', enabled);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.imageSmoothingEnabled = enabled;
         }
     }
     get imageSmoothingQuality() {
-        this.log('imageSmoothingQuality');
         return this.context.imageSmoothingQuality;
     }
     set imageSmoothingQuality(quality) {
-        this.log('imageSmoothingQuality value:', quality);
         this._ensureLayoutBeforeDraw();
         this.context.imageSmoothingQuality = quality;
     }
     get lineDashOffset() {
-        this.log('lineDashOffset');
         return this.context.lineDashOffset;
     }
     set lineDashOffset(offset) {
-        this.log('lineDashOffset value:', offset);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.lineDashOffset = offset;
         }
     }
     get lineJoin() {
-        this.log('lineJoin');
         return this.context.lineJoin;
     }
     set lineJoin(join) {
-        this.log('lineJoin value:', join);
         this._ensureLayoutBeforeDraw();
         this.context.lineJoin = join;
     }
     get lineCap() {
-        this.log('lineCap');
         return this.context.lineCap;
     }
     set lineCap(cap) {
-        this.log('lineCap value:', cap);
         this._ensureLayoutBeforeDraw();
         this.context.lineCap = cap;
     }
     get miterLimit() {
-        this.log('miterLimit value:');
         return this.context.miterLimit;
     }
     set miterLimit(limit) {
-        this.log('miterLimit value:', limit);
         this._ensureLayoutBeforeDraw();
         this.context.miterLimit = limit;
     }
     get shadowBlur() {
-        this.log('shadowBlur');
         return this.context.shadowBlur;
     }
     set shadowBlur(blur) {
-        this.log('shadowBlur value:', blur);
         this._ensureLayoutBeforeDraw();
         this.context.shadowBlur = blur;
     }
     get shadowOffsetX() {
-        this.log('shadowOffsetX');
         return this.context.shadowOffsetX;
     }
     set shadowOffsetX(x) {
-        this.log('shadowOffsetX value:', x);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.shadowOffsetX = x;
         }
     }
     get shadowOffsetY() {
-        this.log('shadowOffsetY');
         return this.context.shadowOffsetY;
     }
     set shadowOffsetY(y) {
-        this.log('shadowOffsetY value:', y);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.shadowOffsetY = y;
         }
     }
     get textAlign() {
-        this.log('textAlign');
         return this.context.textAlign;
     }
     set textAlign(alignment) {
-        this.log('textAlign value:', alignment);
         this._ensureLayoutBeforeDraw();
         this.context.setTextAlign = alignment;
     }
     get globalCompositeOperation() {
-        this.log('globalCompositeOperation');
         return this.context.globalCompositeOperation;
     }
     set globalCompositeOperation(composite) {
-        this.log('globalCompositeOperation value:', composite);
         this._ensureLayoutBeforeDraw();
         this.context.globalCompositeOperation = composite;
     }
     get fillStyle() {
-        this.log('fillStyle');
         return this.context.fillStyle;
     }
     set fillStyle(color) {
-        this.log('fillStyle:', color);
         if (color === undefined || color === null) {
             return;
         }
@@ -200,19 +171,16 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     get filter() {
-        this.log('get filter');
         return this.context.filter;
     }
     set filter(value) {
-        this.log('set filter', value);
+        this._ensureLayoutBeforeDraw();
         this.context.filter = value;
     }
     get strokeStyle() {
-        this.log('strokeStyle');
         return this.context.strokeStyle;
     }
     set strokeStyle(color) {
-        this.log('strokeStyle:', color);
         if (color === undefined || color === null) {
             return;
         }
@@ -225,11 +193,9 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     get lineWidth() {
-        this.log('lineWidth');
         return this.context.lineWidth;
     }
     set lineWidth(width) {
-        this.log('lineWidth value:', width);
         this._ensureLayoutBeforeDraw();
         this.context.lineWidth = width;
     }
@@ -242,44 +208,38 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
         return cached;
     }
-    __toDataURL() {
+    __toDataURL(type = 'image/jpg', quality = 92) {
         const __toDataURL = this._getMethod('__toDataURL');
-        return __toDataURL(arguments[0], arguments[1]);
+        return __toDataURL(type, quality);
     }
     addHitRegion(region) { }
     arc(x, y, radius, startAngle, endAngle, anticlockwise = false) {
-        this.log('arc value:', x, y, radius, startAngle, endAngle, anticlockwise);
         this._ensureLayoutBeforeDraw();
         const arc = this._getMethod('arc');
         arc(x, y, radius, startAngle, endAngle, anticlockwise);
     }
     arcTo(x1, y1, x2, y2, radius) {
-        this.log('arcTo value:', x1, y1, x2, y2, radius);
         this._ensureLayoutBeforeDraw();
         const arcTo = this._getMethod('arcTo');
         arcTo(x1, y1, x2, y2, radius);
     }
     beginPath() {
-        this.log('beginPath');
         this._ensureLayoutBeforeDraw();
         const beginPath = this._getMethod('beginPath');
         beginPath();
     }
     bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
-        this.log('bezierCurveTo value:', cp1x, cp1y, cp2x, cp2y, x, y);
         this._ensureLayoutBeforeDraw();
         const bezierCurveTo = this._getMethod('bezierCurveTo');
         bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
     }
     clearHitRegions() { }
     clearRect(x, y, width, height) {
-        this.log('clearRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         const clearRect = this._getMethod('clearRect');
         clearRect(x, y, width, height);
     }
     clip(...args) {
-        this.log('clip value:', ...args);
         this._ensureLayoutBeforeDraw();
         const clip = this._getMethod('clip');
         if (typeof args[0] === 'string') {
@@ -296,13 +256,11 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     closePath() {
-        this.log('closePath');
         this._ensureLayoutBeforeDraw();
         const closePath = this._getMethod('closePath');
         closePath();
     }
     createImageData(width, height) {
-        this.log('createImageData value:', arguments);
         if (width instanceof ImageData) {
             return new ImageData(width.width, width.height);
         }
@@ -311,14 +269,12 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     createLinearGradient(x0, y0, x1, y1) {
-        this.log('createLinearGradient value:', x0, y0, x1, y1);
         this._ensureLayoutBeforeDraw();
         const createLinearGradient = this._getMethod('createLinearGradient');
         return CanvasGradient.fromNative(createLinearGradient(x0, y0, x1, y1));
     }
     createPattern(image, repetition) {
         var _a;
-        this.log('createPattern value:', image, repetition);
         this._ensureLayoutBeforeDraw();
         if (repetition === undefined || typeof repetition !== 'string') {
             const e = new Error('The string did not match the expected pattern.');
@@ -331,13 +287,32 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
             img = image.native;
         }
         else if (image instanceof ImageSource) {
-            img = image.android;
+            const ptr = this._getMethod('__getPointer');
+            const createPattern = this._getMethod('__createPatternWithNative');
+            if (global.isAndroid) {
+                img = image.android;
+                const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), img, repetition);
+                return new CanvasPattern(createPattern(pattern));
+            }
+            if (global.isIOS) {
+                img = image.ios;
+                const pattern = NSCCanvasRenderingContext2D.createPattern(long(ptr), img, repetition);
+                return new CanvasPattern(createPattern(pattern));
+            }
+            return null;
         }
-        else if (image instanceof android.graphics.Bitmap) {
+        else if (global.isAndroid && image instanceof android.graphics.Bitmap) {
             const ptr = this._getMethod('__getPointer');
             const createPattern = this._getMethod('__createPatternWithNative');
-            const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), image, repetition);
-            return new CanvasPattern(createPattern(pattern));
+            if (global.isAndroid) {
+                const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), image, repetition);
+                return new CanvasPattern(createPattern(pattern));
+            }
+            if (global.isIOS) {
+                const pattern = NSCCanvasRenderingContext2D.createPattern(long(ptr), image, repetition);
+                return new CanvasPattern(createPattern(pattern));
+            }
+            return null;
         }
         else if (image instanceof ImageAsset) {
             img = image.native;
@@ -346,14 +321,27 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
             img = image.native;
         }
         else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
-            if (image._image instanceof android.graphics.Bitmap) {
+            if (global.isAndroid && image._image instanceof android.graphics.Bitmap) {
+                //todo ios
                 img = image._image;
             }
             else if (image._asset instanceof ImageAsset) {
                 img = image._asset.native;
             }
             else if (typeof image.src === 'string') {
-                img = ImageSource.fromFileSync(image.src).android;
+                const ptr = this._getMethod('__getPointer');
+                const createPattern = this._getMethod('__createPatternWithNative');
+                if (global.isAndroid) {
+                    img = ImageSource.fromFileSync(image.src).android;
+                    const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), img, repetition);
+                    return new CanvasPattern(createPattern(pattern));
+                }
+                if (global.isiOS) {
+                    img = ImageSource.fromFileSync(image.src).android;
+                    const pattern = NSCCanvasRenderingContext2D.createPattern(long(ptr), img, repetition);
+                    return new CanvasPattern(createPattern(pattern));
+                }
+                return null;
             }
         }
         else if (image && typeof image.tagName === 'string' && image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
@@ -368,17 +356,62 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         return new CanvasPattern(createPattern(img, repetition));
     }
     createRadialGradient(x0, y0, r0, x1, y1, r1) {
-        this.log('createRadialGradient value:', x0, y0, r0, x1, y1, r1);
         this._ensureLayoutBeforeDraw();
         const createRadialGradient = this._getMethod('createRadialGradient');
         return CanvasGradient.fromNative(createRadialGradient(x0, y0, r0, x1, y1, r1));
     }
+    drawPaint(color) {
+        this._ensureLayoutBeforeDraw();
+        const drawPaint = this._getMethod('drawPaint');
+        drawPaint(color);
+    }
+    drawPoint(x, y) {
+        this._ensureLayoutBeforeDraw();
+        const drawPoint = this._getMethod('drawPoint');
+        drawPoint(x, y);
+    }
+    drawPoints(mode, points) {
+        this._ensureLayoutBeforeDraw();
+        const drawPoints = this._getMethod('drawPoints');
+        drawPoints(mode, points);
+    }
     drawFocusIfNeeded(...args) { }
     drawImage(...args) {
         var _a;
-        this.log('drawImage value:', ...args);
         this._ensureLayoutBeforeDraw();
         const drawImage = this._getMethod('drawImage');
+        const drawNativeImage = (args, image) => {
+            const ptr = this._getMethod('__getPointer');
+            const makeDirty = this._getMethod('__makeDirty');
+            let dirty = false;
+            if (args.length === 3) {
+                if (global.isAndroid) {
+                    dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2]);
+                }
+                if (global.isIOS) {
+                    dirty = NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2]);
+                }
+            }
+            else if (args.length === 5) {
+                if (global.isAndroid) {
+                    dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2], args[3], args[4]);
+                }
+                if (global.isIOS) {
+                    dirty = NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2], args[3], args[4]);
+                }
+            }
+            else if (args.length === 9) {
+                if (global.Android) {
+                    dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+                }
+                if (global.isIOS) {
+                    dirty = NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+                }
+            }
+            if (dirty) {
+                makeDirty();
+            }
+        };
         let image = args[0];
         if ((image === null || image === void 0 ? void 0 : image._type) === '2d' || ((_a = image === null || image === void 0 ? void 0 : image._type) === null || _a === void 0 ? void 0 : _a.indexOf('webgl')) > -1) {
             image = image.native;
@@ -387,26 +420,55 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
             image = image.native;
         }
         else if (image instanceof ImageSource) {
-            image = image.android;
+            if (global.isAndroid) {
+                drawNativeImage(args, image.android);
+            }
+            if (global.isIOS) {
+                drawNativeImage(args, image.ios);
+            }
+            return;
         }
-        else if (image instanceof android.graphics.Bitmap) {
-            image = image;
+        else if (global.isAndroid && image instanceof android.graphics.Bitmap) {
+            drawNativeImage(args, image);
+            return;
+        }
+        else if (global.isIOS && image instanceof UIImage) {
+            drawNativeImage(args, image);
+            return;
         }
         else if (image instanceof Canvas) {
             image = image.native;
         }
         else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
             if (image._imageSource instanceof ImageSource) {
-                image = image._imageSource.android;
+                if (global.isAndroid) {
+                    drawNativeImage(args, image._imageSource.android);
+                }
+                if (global.isIOS) {
+                    drawNativeImage(args, image._imageSource.ios);
+                }
+                return;
+            }
+            else if (global.isAndroid && image._image instanceof android.graphics.Bitmap) {
+                drawNativeImage(args, image._image);
+                return;
             }
-            else if (image._image instanceof android.graphics.Bitmap) {
-                image = image._image;
+            else if (global.isIOS && image._image instanceof UIImage) {
+                drawNativeImage(args, image._image);
+                return;
             }
             else if (image._asset instanceof ImageAsset) {
                 image = image._asset.native;
             }
             else if (typeof image.src === 'string') {
                 image = ImageSource.fromFileSync(image.src).android;
+                if (global.isAndroid) {
+                    drawNativeImage(args, image.android);
+                }
+                if (global.isIOS) {
+                    drawNativeImage(args, image.ios);
+                }
+                return;
             }
         }
         else if (image && typeof image.tagName === 'string' && image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
@@ -426,13 +488,11 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise = false) {
-        this.log('ellipse value:', x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
         this._ensureLayoutBeforeDraw();
         const ellipse = this._getMethod('ellipse');
         ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
     }
     fill(...args) {
-        this.log('fill value:', ...args);
         this._ensureLayoutBeforeDraw();
         const fill = this._getMethod('fill');
         if (typeof args[0] === 'string') {
@@ -449,13 +509,11 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     fillRect(x, y, width, height) {
-        this.log('fillRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         const fillRect = this._getMethod('fillRect');
         fillRect(x, y, width, height);
     }
     fillText(text, x, y, maxWidth) {
-        this.log('fillText value:', text, x, y, maxWidth);
         this._ensureLayoutBeforeDraw();
         const fillText = this._getMethod('fillText');
         if (typeof maxWidth === 'number') {
@@ -466,19 +524,16 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     getImageData(sx, sy, sw, sh) {
-        this.log('getImageData value:', sx, sy, sw, sh);
         this._ensureLayoutBeforeDraw();
         const getImageData = this._getMethod('getImageData');
         return ImageData.fromNative(getImageData(sx, sy, sw, sh));
     }
     getLineDash() {
-        this.log('getLineDash');
         this._ensureLayoutBeforeDraw();
         const getLineDash = this._getMethod('getLineDash');
         return getLineDash();
     }
     isPointInPath(...args) {
-        this.log('isPointInPath value:', ...args);
         this._ensureLayoutBeforeDraw();
         const isPointInPath = this._getMethod('isPointInPath');
         if (args.length === 2) {
@@ -493,7 +548,6 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         return false;
     }
     isPointInStroke(...args) {
-        this.log('isPointInStroke value:', ...args);
         this._ensureLayoutBeforeDraw();
         const isPointInStroke = this._getMethod('isPointInStroke');
         if (args.length === 2) {
@@ -505,25 +559,21 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         return false;
     }
     lineTo(x, y) {
-        this.log('lineTo value:', x, y);
         this._ensureLayoutBeforeDraw();
         const lineTo = this._getMethod('lineTo');
         lineTo(x, y);
     }
     measureText(text) {
-        this.log('measureText value:', text);
         this._ensureLayoutBeforeDraw();
         const measureText = this._getMethod('measureText');
         return new TextMetrics(measureText(text));
     }
     moveTo(x, y) {
-        this.log('moveTo value:', x, y);
         this._ensureLayoutBeforeDraw();
         const moveTo = this._getMethod('moveTo');
         moveTo(x, y);
     }
     putImageData(...args) {
-        this.log('putImageData value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (!args) {
             return;
@@ -538,63 +588,58 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     quadraticCurveTo(cpx, cpy, x, y) {
-        this.log('quadraticCurveTo value:', cpx, cpy, x, y);
         this._ensureLayoutBeforeDraw();
         const quadraticCurveTo = this._getMethod('quadraticCurveTo');
         quadraticCurveTo(cpx, cpy, x, y);
     }
     rect(x, y, width, height) {
-        this.log('rect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         const rect = this._getMethod('rect');
         rect(x, y, width, height);
     }
+    roundRect(x, y, width, height, radii) {
+        this._ensureLayoutBeforeDraw();
+        const roundRect = this._getMethod('roundRect');
+        roundRect(x, y, width, height, radii);
+    }
     removeHitRegion(id) { }
     resetTransform() {
-        this.log('resetTransform value:');
         this._ensureLayoutBeforeDraw();
         const resetTransform = this._getMethod('resetTransform');
         resetTransform();
     }
     restore() {
-        this.log('restore');
         this._ensureLayoutBeforeDraw();
         const restore = this._getMethod('restore');
         restore();
     }
     rotate(angle) {
-        this.log('rotate value:', angle);
         this._ensureLayoutBeforeDraw();
         const rotate = this._getMethod('rotate');
         rotate(angle);
     }
     save() {
-        this.log('save');
         this._ensureLayoutBeforeDraw();
         const save = this._getMethod('save');
         save();
     }
     scale(x, y) {
-        this.log('scale value:', x, y);
         this._ensureLayoutBeforeDraw();
         const scale = this._getMethod('scale');
         scale(x, y);
     }
     scrollPathIntoView(path) { }
     setLineDash(segments) {
-        this.log('setLineDash value:', segments);
         this._ensureLayoutBeforeDraw();
         const setLineDash = this._getMethod('setLineDash');
         setLineDash(segments);
     }
     setTransform(a, b, c, d, e, f) {
-        this.log('setTransform value:', a, b, c, d, e, f);
         this._ensureLayoutBeforeDraw();
         const setTransform = this._getMethod('setTransform');
         setTransform(a, b, c, d, e, f);
     }
     stroke(path) {
-        this.log('stroke value:', path);
         this._ensureLayoutBeforeDraw();
         const stroke = this._getMethod('stroke');
         if (path) {
@@ -605,13 +650,11 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     strokeRect(x, y, width, height) {
-        this.log('strokeRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         const strokeRect = this._getMethod('strokeRect');
         strokeRect(x, y, width, height);
     }
     strokeText(text, x, y, maxWidth) {
-        this.log('strokeText value:', text, x, y, maxWidth);
         this._ensureLayoutBeforeDraw();
         const strokeText = this._getMethod('strokeText');
         if (typeof maxWidth === 'number') {
@@ -622,28 +665,20 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     transform(a, b, c, d, e, f) {
-        this.log('transform value:', a, b, c, d, e, f);
         this._ensureLayoutBeforeDraw();
         const transform = this._getMethod('transform');
         transform(a, b, c, d, e, f);
     }
     translate(x, y) {
-        this.log('translate value:', x, y);
         this._ensureLayoutBeforeDraw();
         const translate = this._getMethod('translate');
         translate(x, y);
     }
     _ensureLayoutBeforeDraw() {
-        if (this.canvas) {
+        if (this.canvas !== undefined) {
             this.canvas._layoutNative();
         }
     }
-    log(message, ...args) {
-        if (!CanvasRenderingContext2D.isDebug) {
-            return;
-        }
-        console.log(message, args);
-    }
 }
 CanvasRenderingContext2D.isDebug = false;
 (() => {
@@ -651,4 +686,4 @@ CanvasRenderingContext2D.isDebug = false;
     //ctor = global.CanvasJSIModule.create2DContext;
     ctor = global.CanvasJSIModule.create2DContextWithPointer;
 })();
-//# sourceMappingURL=index.android.js.map
+//# sourceMappingURL=index.js.map