@ohos-ports/vi-canvas-mock 1.0.0-beta.0

package/lib/classes/DOMMatrix.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function sumMultipleOfMatricesCells(matrix1Array, matrix2Array, {
+  i,
+  j
+}) {
+  let sum = 0;
+  for (let k = 0; k < 4; k++) {
+    const matrix1Index = j - 1 + k * 4;
+    const matrix2Index = (i - 1) * 4 + k;
+    sum += matrix1Array[matrix1Index] * matrix2Array[matrix2Index];
+  }
+  return sum;
+}
+function multiplyMatrices(leftMatrix, rightMatrix) {
+  const leftMatrixArray = leftMatrix.toFloat64Array();
+  const rightMatrixArray = rightMatrix.toFloat64Array();
+  for (let i = 1; i <= 4; i++) {
+    for (let j = 1; j <= 4; j++) {
+      leftMatrix[`m${i}${j}`] = sumMultipleOfMatricesCells(leftMatrixArray, rightMatrixArray, {
+        i,
+        j
+      });
+    }
+  }
+}
+class DOMMatrix {
+  constructor(transform) {
+    _defineProperty(this, "_is2D", true);
+    _defineProperty(this, "m11", 1.0);
+    _defineProperty(this, "m12", 0.0);
+    _defineProperty(this, "m13", 0.0);
+    _defineProperty(this, "m14", 0.0);
+    _defineProperty(this, "m21", 0.0);
+    _defineProperty(this, "m22", 1.0);
+    _defineProperty(this, "m23", 0.0);
+    _defineProperty(this, "m24", 0.0);
+    _defineProperty(this, "m31", 0.0);
+    _defineProperty(this, "m32", 0.0);
+    _defineProperty(this, "m33", 1.0);
+    _defineProperty(this, "m34", 0.0);
+    _defineProperty(this, "m41", 0.0);
+    _defineProperty(this, "m42", 0.0);
+    _defineProperty(this, "m43", 0.0);
+    _defineProperty(this, "m44", 1.0);
+    if (transform && transform.length === 6) {
+      this.m11 = transform[0];
+      this.m12 = transform[1];
+      this.m21 = transform[2];
+      this.m22 = transform[3];
+      this.m41 = transform[4];
+      this.m42 = transform[5];
+      this._is2D = true;
+      return this;
+    }
+    if (transform && transform.length === 16) {
+      this.m11 = transform[0];
+      this.m12 = transform[1];
+      this.m13 = transform[2];
+      this.m14 = transform[3];
+      this.m21 = transform[4];
+      this.m22 = transform[5];
+      this.m23 = transform[6];
+      this.m24 = transform[7];
+      this.m31 = transform[8];
+      this.m32 = transform[9];
+      this.m33 = transform[10];
+      this.m34 = transform[11];
+      this.m41 = transform[12];
+      this.m42 = transform[13];
+      this.m43 = transform[14];
+      this.m44 = transform[15];
+      this._is2D = false;
+      return this;
+    }
+    if (transform) {
+      throw new TypeError("Failed to construct 'DOMMatrix': The sequence must contain 6 elements for a 2D matrix or 16 elements for a 3D matrix.");
+    }
+    this._is2D = false;
+  }
+  get isIdentity() {
+    if (this._is2D) {
+      return this.m11 == 1.0 && this.m12 == 0.0 && this.m21 == 0.0 && this.m22 == 1.0 && this.m41 == 0.0 && this.m42 == 0.0;
+    } else {
+      return this.m11 = 1.0 && this.m12 === 0.0 && this.m13 === 0.0 && this.m14 === 0.0 && this.m21 === 0.0 && this.m22 === 1.0 && this.m23 === 0.0 && this.m24 === 0.0 && this.m31 === 0.0 && this.m32 === 0.0 && this.m33 === 1.0 && this.m34 === 0.0 && this.m41 === 0.0 && this.m42 === 0.0 && this.m43 === 0.0 && this.m44 === 1.0;
+    }
+  }
+  get a() {
+    return this.m11;
+  }
+  set a(value) {
+    this.m11 = value;
+  }
+  get b() {
+    return this.m12;
+  }
+  set b(value) {
+    this.m12 = value;
+  }
+  get c() {
+    return this.m21;
+  }
+  set c(value) {
+    this.m21 = value;
+  }
+  get d() {
+    return this.m22;
+  }
+  set d(value) {
+    this.m22 = value;
+  }
+  get e() {
+    return this.m41;
+  }
+  set e(value) {
+    this.m41 = value;
+  }
+  get f() {
+    return this.m42;
+  }
+  set f(value) {
+    this.m42 = value;
+  }
+  get is2D() {
+    return this._is2D;
+  }
+  toFloat32Array() {
+    return new Float32Array([this.m11, this.m12, this.m13, this.m14, this.m21, this.m22, this.m23, this.m24, this.m31, this.m32, this.m33, this.m34, this.m41, this.m42, this.m43, this.m44]);
+  }
+  toFloat64Array() {
+    return new Float64Array([this.m11, this.m12, this.m13, this.m14, this.m21, this.m22, this.m23, this.m24, this.m31, this.m32, this.m33, this.m34, this.m41, this.m42, this.m43, this.m44]);
+  }
+  translateSelf(x, y, z) {
+    const tx = Number(x),
+      ty = Number(y),
+      tz = isNaN(Number(z)) ? 0 : Number(z);
+    const translationMatrix = new DOMMatrix();
+    translationMatrix.m41 = tx;
+    translationMatrix.m42 = ty;
+    translationMatrix.m43 = tz;
+    multiplyMatrices(this, translationMatrix);
+    if (tz) {
+      this._is2D = false;
+    }
+    return this;
+  }
+  translate(x, y, z) {
+    let translatedMatrix;
+    if (this.is2D) {
+      translatedMatrix = new DOMMatrix([this.a, this.b, this.c, this.d, this.e, this.f]);
+    } else {
+      translatedMatrix = new DOMMatrix(this.toFloat32Array());
+    }
+    return translatedMatrix.translateSelf(x, y, z);
+  }
+  scaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ) {
+    const sx = Number(scaleX),
+      sy = isNaN(Number(scaleY)) ? sx : Number(scaleY),
+      sz = isNaN(Number(scaleZ)) ? 1 : Number(scaleZ);
+    const ox = isNaN(Number(originX)) ? 0 : Number(originX),
+      oy = isNaN(Number(originY)) ? 0 : Number(originY),
+      oz = isNaN(Number(originZ)) ? 0 : Number(originZ);
+    this.translateSelf(ox, oy, oz);
+    const scaleMatrix = new DOMMatrix();
+    scaleMatrix.m11 = sx;
+    scaleMatrix.m22 = sy;
+    scaleMatrix.m33 = sz;
+    multiplyMatrices(this, scaleMatrix);
+    this.translateSelf(-ox, -oy, -oz);
+    if (Math.abs(sz) !== 1) {
+      this._is2D = false;
+    }
+    return this;
+  }
+  scale(scaleX, scaleY, scaleZ, originX, originY, originZ) {
+    let scaledMatrix;
+    if (this.is2D) {
+      scaledMatrix = new DOMMatrix([this.a, this.b, this.c, this.d, this.e, this.f]);
+    } else {
+      scaledMatrix = new DOMMatrix(this.toFloat32Array());
+    }
+    return scaledMatrix.scaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ);
+  }
+}
+exports.default = DOMMatrix;

package/lib/classes/ImageBitmap.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class ImageBitmap {
+  constructor(width, height) {
+    _defineProperty(this, "width", 0);
+    _defineProperty(this, "height", 0);
+    _defineProperty(this, "_closed", false);
+    this.width = width;
+    this.height = height;
+    this.close = vi.fn(this.close.bind(this));
+  }
+  close() {
+    this.width = 0;
+    this.height = 0;
+    this._closed = true;
+  }
+}
+exports.default = ImageBitmap;

package/lib/classes/ImageData.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class ImageData {
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  get data() {
+    return this._data;
+  }
+  constructor(arr, w, h) {
+    _defineProperty(this, "_width", 0);
+    _defineProperty(this, "_height", 0);
+    _defineProperty(this, "_data", null);
+    if (arguments.length === 2) {
+      if (arr instanceof Uint8ClampedArray) {
+        if (arr.length === 0) throw new RangeError('Source length must be a positive multiple of 4.');
+        if (arr.length % 4 !== 0) throw new RangeError('Source length must be a positive multiple of 4.');
+        if (!Number.isFinite(w)) throw new RangeError('The width is zero or not a number.');
+        if (w === 0) throw new RangeError('The width is zero or not a number.');
+        this._width = w;
+        this._height = arr.length / 4 / w;
+        this._data = arr;
+      } else {
+        const width = arr;
+        const height = w;
+        if (!Number.isFinite(height)) throw new RangeError('The height is zero or not a number.');
+        if (height === 0) throw new RangeError('The height is zero or not a number.');
+        if (!Number.isFinite(width)) throw new RangeError('The width is zero or not a number.');
+        if (width === 0) throw new RangeError('The width is zero or not a number.');
+        this._width = width;
+        this._height = height;
+        this._data = new Uint8ClampedArray(width * height * 4);
+      }
+    } else if (arguments.length === 3) {
+      if (!(arr instanceof Uint8ClampedArray)) throw new TypeError('First argument must be a Uint8ClampedArray when using 3 arguments.');
+      if (arr.length === 0) throw new RangeError('Source length must be a positive multiple of 4.');
+      if (arr.length % 4 !== 0) throw new RangeError('Source length must be a positive multiple of 4.');
+      if (!Number.isFinite(h)) throw new RangeError('The height is zero or not a number.');
+      if (h === 0) throw new RangeError('The height is zero or not a number.');
+      if (!Number.isFinite(w)) throw new RangeError('The width is zero or not a number.');
+      if (w === 0) throw new RangeError('The width is zero or not a number.');
+      if (arr.length !== w * h * 4) throw new RangeError("Source doesn'n contain the exact number of pixels needed.");
+      this._width = w;
+      this._height = h;
+      this._data = arr;
+    } else {
+      throw new TypeError('Wrong number of arguments provided.');
+    }
+  }
+}
+exports.default = ImageData;

package/lib/classes/Path2D.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _CanvasRenderingContext2D = _interopRequireDefault(require("./CanvasRenderingContext2D"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+// Path2D.prototype
+const Path2DFunc = ['addPath'];
+const borrowedFromCanvas = ['closePath', 'moveTo', 'lineTo', 'bezierCurveTo', 'quadraticCurveTo', 'arc', 'arcTo', 'ellipse', 'rect'];
+class Path2D {
+  constructor() {
+    _defineProperty(this, "_path", []);
+    _defineProperty(this, "_events", []);
+    _defineProperty(this, "_stackIndex", 0);
+    _defineProperty(this, "_transformStack", [[1, 0, 0, 1, 0, 0]]);
+    borrowedFromCanvas.forEach(key => {
+      this[key] = vi.fn(_CanvasRenderingContext2D.default.prototype[key].bind(this));
+    });
+    Path2DFunc.forEach(key => {
+      this[key] = vi.fn(this[key].bind(this));
+    });
+  }
+  addPath(path) {
+    if (arguments.length < 1) throw new TypeError("Failed to execute 'addPath' on 'Path2D': 1 argument required, but only 0 present.");
+    if (!(path instanceof Path2D)) throw new TypeError("Failed to execute 'addPath' on 'Path2D': parameter 1 is not of type 'Path2D'.");
+    for (let i = 0; i < path._path.length; i++) this._path.push(path._path[i]);
+  }
+}
+exports.default = Path2D;

package/lib/classes/TextMetrics.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class TextMetrics {
+  constructor(text) {
+    _defineProperty(this, "width", 0);
+    _defineProperty(this, "actualBoundingBoxLeft", 0);
+    _defineProperty(this, "actualBoundingBoxRight", 0);
+    _defineProperty(this, "fontBoundingBoxAscent", 0);
+    _defineProperty(this, "fontBoundingBoxDescent", 0);
+    _defineProperty(this, "actualBoundingBoxAscent", 0);
+    _defineProperty(this, "actualBoundingBoxDescent", 0);
+    _defineProperty(this, "emHeightAscent", 0);
+    _defineProperty(this, "emHeightDescent", 0);
+    _defineProperty(this, "hangingBaseline", 0);
+    _defineProperty(this, "alphabeticBaseline", 0);
+    _defineProperty(this, "ideographicBaseline", 0);
+    this.width = text.length;
+  }
+}
+exports.default = TextMetrics;

package/lib/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setupVitestCanvasMock = setupVitestCanvasMock;
+exports.ver = void 0;
+var _window = _interopRequireDefault(require("./window"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Created by hustcc 17/12/25.
+ * Contract: i@hust.cc
+ * Adapted to Vitest by schirrel at  March 1 2023
+ * Contract: me@schirrel.dev
+ */
+
+// mock global window
+// TODO: Force coverage to ignore this branch
+if (typeof window !== 'undefined') {
+  (0, _window.default)(global.window);
+}
+const ver = "1.0.0";
+exports.ver = ver;
+function setupVitestCanvasMock(window) {
+  (0, _window.default)(window || global.window);
+}

package/lib/mock/createCanvasEvent.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createCanvasEvent;
+/**
+ * This function returns a CanvasRenderingContext2DEvent. Whenever an operation would modify the canvas
+ * context, this function should be used to generate an "event" that represents that sort of modification.
+ * This will be used to mock for snapshots.
+ *
+ * @example
+ * interface CanvasRenderingContext2DEvent {
+ *   type: string;
+ *   transform: [number, number, number, number, number, number]; // the resulting current transform
+ *   props: {
+ *     // if the event is a property was set, `event.props.value` would be set
+ *     [propName: string]: any;
+ *   };
+ * }
+ */
+function createCanvasEvent(type, transform, props) {
+  return {
+    type,
+    transform,
+    props
+  };
+}

package/lib/mock/createImageBitmap.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ImageBitmap = _interopRequireDefault(require("../classes/ImageBitmap"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = vi.fn(function createImageBitmap(img, sx, sy, sWidth, sHeight, options) {
+  var length = arguments.length;
+  return new Promise((resolve, reject) => {
+    if (length === 0) return reject(new TypeError("Failed to execute 'createImageBitmap' on 'Window': 1 argument required, but only 0 present."));
+    if (length === 3 || length === 4) return reject(new TypeError("Failed to execute 'createImageBitmap' on 'Window': Valid arities are: [1, 2, 5, 6], but " + length + ' arguments provided.'));
+    let validImage = false;
+    if (img instanceof HTMLImageElement) validImage = true;
+    if (img instanceof HTMLVideoElement) validImage = true;
+    if (img instanceof HTMLCanvasElement) validImage = true;
+    // checking constructor name is the only reliable way to verify the object's constructing class is "blob-like"
+    if (img instanceof Blob || img && img.constructor && img.constructor.name === 'Blob') validImage = true;
+    if (img instanceof _ImageBitmap.default) validImage = true;
+    if (img instanceof ImageData) validImage = true;
+    if (!validImage) return reject(new TypeError("Failed to execute 'createImageBitmap' on 'Window': The provided value is not of type '(HTMLImageElement or SVGImageElement or HTMLVideoElement or HTMLCanvasElement or Blob or ImageData or ImageBitmap or OffscreenCanvas)'"));
+    if (length >= 2) {
+      let index = 6;
+      if (length === 2) {
+        index = 2;
+        options = sx;
+      }
+      if (length === 5) options = null;
+      if (options !== null && options !== void 0) {
+        if (typeof options !== 'object') throw new TypeError("Failed to execute 'createImageBitmap' on 'Window': parameter " + index + " ('options') is not an object.");
+      }
+    }
+    if (length >= 5) {
+      sWidth = Number(sWidth);
+      sHeight = Number(sHeight);
+      if (sWidth === 0 || !Number.isFinite(sWidth)) return reject(new RangeError('The crop rect width is 0.'));
+      if (sHeight === 0 || !Number.isFinite(sHeight)) return reject(new RangeError('The crop rect height is 0.'));
+      sWidth = Math.abs(sWidth);
+      sHeight = Math.abs(sHeight);
+    } else {
+      sWidth = img.width || 1;
+      sHeight = img.height || 1;
+    }
+    return resolve(new _ImageBitmap.default(sWidth, sHeight));
+  });
+});
+exports.default = _default;

package/lib/mock/prototype.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mockPrototype;
+function mockPrototype() {
+  /**
+   * This weakmap is designed to contain all of the generated canvas contexts. It's keys are the
+   * jsdom canvases obtained by using the `this` keyword inside the `#getContext('2d')` function
+   * call. It's values are the generated `CanvasRenderingContext2D` objects.
+   */
+  const generatedContexts = new WeakMap();
+  /**
+   * Overrides getContext. Every test run will create a new function that overrides the current
+   * value of getContext. It attempts to preserve the original getContext function by storing it on
+   * the callback as a property.
+   */
+  const getContext2D = vi.fn(function getContext2d(type) {
+    if (type === '2d') {
+      /**
+       * Contexts must be idempotent. Once they are generated, they should be returned when
+       * getContext() is called on the same canvas object multiple times.
+       */
+      if (generatedContexts.has(this)) return generatedContexts.get(this);
+      const ctx = new CanvasRenderingContext2D(this);
+      generatedContexts.set(this, ctx);
+      return ctx;
+    }
+    try {
+      if (!this.dataset.internalRequireTest) require('canvas');
+    } catch (_unused) {
+      return null;
+    }
+    return getContext2D.internal.call(this, type);
+  });
+  if (!vi.isMockFunction(HTMLCanvasElement.prototype.getContext)) {
+    getContext2D.internal = HTMLCanvasElement.prototype.getContext;
+  } else {
+    getContext2D.internal = HTMLCanvasElement.prototype.getContext.internal;
+  }
+  HTMLCanvasElement.prototype.getContext = getContext2D;
+
+  /**
+   * This function technically throws SecurityError at runtime, but it cannot be mocked, because
+   * we don't know if the canvas is tainted. These kinds of errors will be silent.
+   */
+  const toBlobOverride = vi.fn(function toBlobOverride(callback, mimetype) {
+    if (arguments.length < 1) throw new TypeError("Failed to execute 'toBlob' on 'HTMLCanvasElement': 1 argument required, but only 0 present.");
+    if (typeof callback !== 'function') throw new TypeError("Failed to execute 'toBlob' on 'HTMLCanvasElement': The callback provided as parameter 1 is not a function.");
+
+    /**
+     * Mime type must be image/jpeg or image/webp exactly for the browser to accept it, otherwise
+     * it's image/png.
+     */
+    switch (mimetype) {
+      case 'image/webp':
+        break;
+      case 'image/jpeg':
+        break;
+      default:
+        mimetype = 'image/png';
+    }
+
+    /**
+     * This section creates a blob of size width * height * 4. This is not actually valid, because
+     * jpeg size is variable, and so is png. TODO: Is there a better way to do this?
+     */
+    const length = this.width * this.height * 4;
+    const data = new Uint8Array(length);
+    const blob = new window.Blob([data], {
+      type: mimetype
+    });
+    setTimeout(() => callback(blob), 0);
+  });
+  if (!vi.isMockFunction(HTMLCanvasElement.prototype.toBlob)) {
+    toBlobOverride.internal = HTMLCanvasElement.prototype.toBlob;
+  } else {
+    toBlobOverride.internal = HTMLCanvasElement.prototype.toBlob.internal;
+  }
+  HTMLCanvasElement.prototype.toBlob = toBlobOverride;
+
+  /**
+   * This section creates a dataurl with a validated mime type. This is not actually valid, because
+   * jpeg size is variable, and so is png. TODO: Is there a better way to do this?
+   */
+  const toDataURLOverride = vi.fn(function toDataURLOverride(type, encoderOptions) {
+    switch (type) {
+      case 'image/jpeg':
+        break;
+      case 'image/webp':
+        break;
+      default:
+        type = 'image/png';
+    }
+
+    /**
+     * This is the smallest valid data url I could generate.
+     */
+    return 'data:' + type + ';base64,00';
+  });
+  if (!vi.isMockFunction(HTMLCanvasElement.prototype.toDataURL)) {
+    toDataURLOverride.internal = HTMLCanvasElement.prototype.toDataURL;
+  } else {
+    toDataURLOverride.internal = HTMLCanvasElement.prototype.toDataURL.internal;
+  }
+  HTMLCanvasElement.prototype.toDataURL = toDataURLOverride;
+}

package/lib/window.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Path2D = _interopRequireDefault(require("./classes/Path2D"));
+var _CanvasGradient = _interopRequireDefault(require("./classes/CanvasGradient"));
+var _CanvasPattern = _interopRequireDefault(require("./classes/CanvasPattern"));
+var _CanvasRenderingContext2D = _interopRequireDefault(require("./classes/CanvasRenderingContext2D"));
+var _DOMMatrix = _interopRequireDefault(require("./classes/DOMMatrix"));
+var _ImageData = _interopRequireDefault(require("./classes/ImageData"));
+var _TextMetrics = _interopRequireDefault(require("./classes/TextMetrics"));
+var _ImageBitmap = _interopRequireDefault(require("./classes/ImageBitmap"));
+var _prototype = _interopRequireDefault(require("./mock/prototype"));
+var _createImageBitmap = _interopRequireDefault(require("./mock/createImageBitmap"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Created by hustcc 17/12/25.
+ * Contract: i@hust.cc
+ * Adapted to Vitest by schirrel at  March 1 2023
+ * Contract: me@schirrel.dev
+ */
+var _default = win => {
+  const d = win.document;
+  const f = win.document.createElement;
+
+  // jsdom@11.6.2 console.error in Function getContext();
+  // https://github.com/jsdom/jsdom/blob/4c7698f760fc64f20b2a0ddff450eddbdd193176/lib/jsdom/living/nodes/HTMLCanvasElement-impl.js#L55-L58
+  // console.error will make ci error.
+  // try {
+  //   // get the context 2d.
+  //   const ctx = d.createElement('canvas').getContext('2d');
+  //
+  //   // if canvas and context2d all exist, means mock is not needed.
+  //   if (ctx) {
+  //     console.warn('Context 2d of canvas is exist! No need to mock');
+  //     return win;
+  //   }
+  // } catch (_) {
+  //   // catch the throw `Error: Not implemented: HTMLCanvasElement.prototype.getContext`
+  //   // https://github.com/jsdom/jsdom/blob/4c7698f760fc64f20b2a0ddff450eddbdd193176/lib/jsdom/living/nodes/HTMLCanvasElement-impl.js
+  //   // when throw error, means mock is needed.
+  //   // code continue
+  // }
+  // if ctx not exist, mock it.
+  // just mock canvas creator.
+  /*
+  win.document.createElement = param => param.toString().toLowerCase() === 'canvas'
+    ? createCanvas('canvas')
+    : f.call(d, param);
+  */
+  // if not exist, then mock it.
+  if (!win.Path2D) win.Path2D = _Path2D.default;
+  if (!win.CanvasGradient) win.CanvasGradient = _CanvasGradient.default;
+  if (!win.CanvasPattern) win.CanvasPattern = _CanvasPattern.default;
+  if (!win.CanvasRenderingContext2D) win.CanvasRenderingContext2D = _CanvasRenderingContext2D.default;
+  if (!win.DOMMatrix) win.DOMMatrix = _DOMMatrix.default;
+  if (!win.ImageData) win.ImageData = _ImageData.default;
+  if (!win.TextMetrics) win.TextMetrics = _TextMetrics.default;
+  if (!win.ImageBitmap) win.ImageBitmap = _ImageBitmap.default;
+  if (!win.createImageBitmap) win.createImageBitmap = _createImageBitmap.default;
+  (0, _prototype.default)();
+  return win;
+};
+exports.default = _default;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@ohos-ports/vi-canvas-mock",
+  "version": "1.0.0-beta.0",
+  "description": "Mock a canvas in your vitest tests.",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "scripts": {},
+  "dependencies": {
+    "cssfontparser": "^1.2.1",
+    "moo-color": "^1.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/vi-canvas-mock/1.0.0"
+  },
+  "keywords": [
+    "mock",
+    "vitest",
+    "vitest-mock",
+    "canvas",
+    "test",
+    "unit"
+  ],
+  "files": [
+    "CHANGELOG.md",
+    "lib/",
+    "types/"
+  ],
+  "author": "schirrel",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "homepage": "https://github.com/schirrel/vi-canvas-mock#readme"
+}