@visactor/vrender 0.12.3 → 0.13.0-alpha.6

package/dist/index.js

@@ -4373,16 +4373,23 @@
           this.measureTextMethod = 'native';
       }
       bindContribution(params) {
+          const promiseArr = [];
           this.contributions.getContributions().forEach(contribution => {
-              contribution.configure(this, params);
+              const data = contribution.configure(this, params);
+              if (data && data.then) {
+                  promiseArr.push(data);
+              }
           });
+          if (promiseArr.length) {
+              return Promise.all(promiseArr);
+          }
       }
       setEnv(env, params) {
           if (!(params && params.force === true) && this._env === env) {
               return;
           }
           this.deactiveCurrentEnv();
-          this.activeEnv(env, params);
+          return this.activeEnv(env, params);
       }
       deactiveCurrentEnv() {
           this.envContribution && this.envContribution.release();
@@ -4390,7 +4397,13 @@
       activeEnv(env, params) {
           const lastEnv = this._env;
           this._env = env;
-          this.bindContribution(params);
+          const data = this.bindContribution(params);
+          if (data && data.then) {
+              return data.then(() => {
+                  this.envParams = params;
+                  this.hooks.onSetEnv.call(lastEnv, env, this);
+              });
+          }
           this.envParams = params;
           this.hooks.onSetEnv.call(lastEnv, env, this);
       }
@@ -26457,7 +26470,7 @@
       __metadata("design:paramtypes", [Object, Number])
   ], exports.BrowserContext2d);
 
-  const DefaultConfig$5 = {
+  const DefaultConfig$6 = {
       WIDTH: 500,
       HEIGHT: 500,
       DPR: 1
@@ -26527,7 +26540,7 @@
           this.resize(this.width, this.height);
       }
       constructor(params) {
-          const { nativeCanvas, width = DefaultConfig$5.WIDTH, height = DefaultConfig$5.HEIGHT, dpr = DefaultConfig$5.DPR, container, x, y, canvasControled = true } = params;
+          const { nativeCanvas, width = DefaultConfig$6.WIDTH, height = DefaultConfig$6.HEIGHT, dpr = DefaultConfig$6.DPR, container, x, y, canvasControled = true } = params;
           const offsetX = 0;
           const offsetY = 0;
           this._x = x ?? offsetX;
@@ -27445,7 +27458,7 @@
       container.rebind(PickerService).toService(exports.DefaultMathPickerService);
   }
 
-  function makeUpCanvas$2(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
+  function makeUpCanvas$3(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
       const dpr = tt.getSystemInfoSync().pixelRatio;
       canvasIdLists.forEach((id, i) => {
           const ctx = tt.createCanvasContext(id);
@@ -27493,7 +27506,7 @@
       configure(service, params) {
           if (service.env === this.type) {
               service.setActiveEnvContribution(this);
-              makeUpCanvas$2(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList);
+              makeUpCanvas$3(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList);
               loadFeishuContributions();
           }
       }
@@ -27563,7 +27576,7 @@
       __metadata("design:paramtypes", [])
   ], FeishuEnvContribution);
 
-  function makeUpCanvas$1(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList, taro, dpr) {
+  function makeUpCanvas$2(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList, taro, dpr) {
       canvasIdLists.forEach((id, i) => {
           const ctx = taro.createCanvasContext(id);
           ctx.canvas = {
@@ -27635,7 +27648,7 @@
       configure(service, params) {
           if (service.env === this.type) {
               service.setActiveEnvContribution(this);
-              makeUpCanvas$1(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList, params.taro, params.pixelRatio);
+              makeUpCanvas$2(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList, params.taro, params.pixelRatio);
               this.taro = params.taro;
               this.pixelRatio = params.pixelRatio;
               loadTaroContributions();
@@ -27716,7 +27729,7 @@
       __metadata("design:paramtypes", [])
   ], TaroEnvContribution);
 
-  function makeUpCanvas(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
+  function makeUpCanvas$1(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
       SystemInfo.pixelRatio;
       canvasIdLists.forEach((id, i) => {
           const _canvas = lynx.createCanvas(id);
@@ -27764,7 +27777,7 @@
       configure(service, params) {
           if (service.env === this.type) {
               service.setActiveEnvContribution(this);
-              makeUpCanvas(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList);
+              makeUpCanvas$1(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList);
               loadFeishuContributions();
           }
       }
@@ -27947,6 +27960,122 @@
       injectable()
   ], NodeEnvContribution);
 
+  async function makeUpCanvas(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
+      const dpr = wx.getSystemInfoSync().pixelRatio;
+      for (let i = 0; i < canvasIdLists.length; i++) {
+          const id = canvasIdLists[i];
+          await new Promise(resolve => {
+              wx.createSelectorQuery()
+                  .select(`#${id}`)
+                  .fields({ node: true, size: true })
+                  .exec((res) => {
+                  const canvas = res[0].node;
+                  const width = res[0].width;
+                  const height = res[0].height;
+                  canvas.width = width * dpr;
+                  canvas.height = height * dpr;
+                  canvasMap.set(id, canvas);
+                  if (i >= freeCanvasIdx) {
+                      freeCanvasList.push(canvas);
+                  }
+                  resolve(null);
+              });
+          });
+      }
+  }
+  let WxEnvContribution = class WxEnvContribution extends exports.BaseEnvContribution {
+      type = 'wx';
+      supportEvent = true;
+      canvasMap = new Map();
+      freeCanvasList = [];
+      canvasIdx = 0;
+      constructor() {
+          super();
+          this.supportsTouchEvents = true;
+          try {
+              this.supportsPointerEvents = !!globalThis.PointerEvent;
+              this.supportsMouseEvents = !!globalThis.MouseEvent;
+          }
+          catch (err) {
+              this.supportsPointerEvents = false;
+              this.supportsMouseEvents = false;
+          }
+          this.applyStyles = true;
+      }
+      configure(service, params) {
+          if (service.env === this.type) {
+              service.setActiveEnvContribution(this);
+              return makeUpCanvas(params.domref, params.canvasIdLists, this.canvasMap, params.freeCanvasIdx, this.freeCanvasList).then(() => {
+                  loadFeishuContributions();
+              });
+          }
+      }
+      loadImage(url) {
+          return Promise.resolve({
+              data: url,
+              loadState: 'success'
+          });
+      }
+      loadSvg(url) {
+          return Promise.reject();
+      }
+      createCanvas(params) {
+          const result = this.freeCanvasList[this.canvasIdx] || this.freeCanvasList[this.freeCanvasList.length - 1];
+          this.canvasIdx++;
+          return result;
+      }
+      createOffscreenCanvas(params) {
+          return;
+      }
+      releaseCanvas(canvas) {
+          return;
+      }
+      getDevicePixelRatio() {
+          return wx.getSystemInfoSync().pixelRatio;
+      }
+      getRequestAnimationFrame() {
+          return function (callback) {
+              return setTimeout(callback, 1000 / 60, true);
+          };
+      }
+      getCancelAnimationFrame() {
+          return (h) => {
+              clearTimeout(h);
+          };
+      }
+      addEventListener(type, listener, options) {
+          return null;
+      }
+      removeEventListener(type, listener, options) {
+          return null;
+      }
+      dispatchEvent(event) {
+          return null;
+      }
+      getElementById(str) {
+          return this.canvasMap.get(str);
+      }
+      getRootElement() {
+          return null;
+      }
+      getDocument() {
+          return null;
+      }
+      release(...params) {
+          return;
+      }
+      mapToCanvasPoint(event) {
+          if (event?.type?.startsWith('mouse')) {
+              return event;
+          }
+          return null;
+      }
+  };
+  WxEnvContribution = __decorate([
+      injectable(),
+      __metadata("design:paramtypes", [])
+  ], WxEnvContribution);
+
   var envModules = new ContainerModule(bind => {
       bind(BrowserEnvContribution).toSelf().inSingletonScope();
       bind(EnvContribution).toService(BrowserEnvContribution);
@@ -27956,6 +28085,8 @@
       bind(EnvContribution).toService(TaroEnvContribution);
       bind(LynxEnvContribution).toSelf().inSingletonScope();
       bind(EnvContribution).toService(LynxEnvContribution);
+      bind(WxEnvContribution).toSelf().inSingletonScope();
+      bind(EnvContribution).toService(WxEnvContribution);
       bind(NodeEnvContribution).toSelf().inSingletonScope();
       bind(EnvContribution).toService(NodeEnvContribution);
       bindContributionProvider(bind, EnvContribution);
@@ -28202,7 +28333,7 @@
       injectable()
   ], FeishuContext2d);
 
-  const DefaultConfig$4 = {
+  const DefaultConfig$5 = {
       WIDTH: 500,
       HEIGHT: 500,
       DPR: 1
@@ -28270,7 +28401,7 @@
           this._dpr = dpr;
       }
       constructor(params) {
-          const { nativeCanvas, width = DefaultConfig$4.WIDTH, height = DefaultConfig$4.HEIGHT, dpr = DefaultConfig$4.DPR } = params;
+          const { nativeCanvas, width = DefaultConfig$5.WIDTH, height = DefaultConfig$5.HEIGHT, dpr = DefaultConfig$5.DPR } = params;
           const { x, y } = nativeCanvas.getBoundingClientRect ? nativeCanvas.getBoundingClientRect() : { x: 0, y: 0 };
           this._x = x;
           this._y = y;
@@ -28323,7 +28454,7 @@
       __metadata("design:paramtypes", [Object])
   ], FeishuCanvas);
 
-  let MiniAppEventManager$2 = class MiniAppEventManager {
+  let MiniAppEventManager$3 = class MiniAppEventManager {
       addEventListener(type, func) {
           if (!type || !func) {
               return;
@@ -28354,7 +28485,7 @@
       global;
       static env = 'feishu';
       type = 'feishu';
-      eventManager = new MiniAppEventManager$2();
+      eventManager = new MiniAppEventManager$3();
       canvas;
       get container() {
           return null;
@@ -28595,7 +28726,7 @@
       injectable()
   ], TaroContext2d);
 
-  const DefaultConfig$3 = {
+  const DefaultConfig$4 = {
       WIDTH: 500,
       HEIGHT: 500,
       DPR: 1
@@ -28662,7 +28793,7 @@
           this._dpr = dpr;
       }
       constructor(params) {
-          const { nativeCanvas, width = DefaultConfig$3.WIDTH, height = DefaultConfig$3.HEIGHT, dpr = DefaultConfig$3.DPR } = params;
+          const { nativeCanvas, width = DefaultConfig$4.WIDTH, height = DefaultConfig$4.HEIGHT, dpr = DefaultConfig$4.DPR } = params;
           const { x, y } = nativeCanvas.getBoundingClientRect ? nativeCanvas.getBoundingClientRect() : { x: 0, y: 0 };
           this._x = x;
           this._y = y;
@@ -28715,7 +28846,7 @@
       __metadata("design:paramtypes", [Object])
   ], TaroCanvas);
 
-  let MiniAppEventManager$1 = class MiniAppEventManager {
+  let MiniAppEventManager$2 = class MiniAppEventManager {
       addEventListener(type, func) {
           if (!type || !func) {
               return;
@@ -28746,7 +28877,7 @@
       global;
       static env = 'taro';
       type = 'taro';
-      eventManager = new MiniAppEventManager$1();
+      eventManager = new MiniAppEventManager$2();
       canvas;
       get container() {
           return null;
@@ -28973,7 +29104,7 @@
       injectable()
   ], LynxContext2d);
 
-  const DefaultConfig$2 = {
+  const DefaultConfig$3 = {
       WIDTH: 500,
       HEIGHT: 500,
       DPR: 1
@@ -29041,7 +29172,7 @@
           this._dpr = dpr;
       }
       constructor(params) {
-          const { nativeCanvas, width = DefaultConfig$2.WIDTH, height = DefaultConfig$2.HEIGHT, dpr = DefaultConfig$2.DPR } = params;
+          const { nativeCanvas, width = DefaultConfig$3.WIDTH, height = DefaultConfig$3.HEIGHT, dpr = DefaultConfig$3.DPR } = params;
           const { x, y } = nativeCanvas.getBoundingClientRect ? nativeCanvas.getBoundingClientRect() : { x: 0, y: 0 };
           this._x = x;
           this._y = y;
@@ -29094,7 +29225,7 @@
       __metadata("design:paramtypes", [Object])
   ], LynxCanvas);
 
-  class MiniAppEventManager {
+  let MiniAppEventManager$1 = class MiniAppEventManager {
       addEventListener(type, func) {
           if (!type || !func) {
               return;
@@ -29120,12 +29251,12 @@
           this.cache = {};
       }
       cache = {};
-  }
+  };
   let LynxWindowHandlerContribution = class LynxWindowHandlerContribution extends exports.BaseWindowHandlerContribution {
       global;
       static env = 'lynx';
       type = 'lynx';
-      eventManager = new MiniAppEventManager();
+      eventManager = new MiniAppEventManager$1();
       canvas;
       get container() {
           return null;
@@ -29311,7 +29442,7 @@
       __metadata("design:paramtypes", [Object, Number])
   ], NodeContext2d);
 
-  const DefaultConfig$1 = {
+  const DefaultConfig$2 = {
       WIDTH: 500,
       HEIGHT: 500,
       DPR: 1
@@ -29379,7 +29510,7 @@
           return;
       }
       constructor(params) {
-          const { nativeCanvas, width = DefaultConfig$1.WIDTH, height = DefaultConfig$1.HEIGHT, canvasControled = true, dpr = DefaultConfig$1.DPR } = params;
+          const { nativeCanvas, width = DefaultConfig$2.WIDTH, height = DefaultConfig$2.HEIGHT, canvasControled = true, dpr = DefaultConfig$2.DPR } = params;
           this._visiable = params.visiable !== false;
           this.controled = canvasControled;
           this._pixelWidth = width * dpr;
@@ -29550,6 +29681,330 @@
       __metadata("design:paramtypes", [Object])
   ], NodeWindowHandlerContribution);
 
+  let WxContext2d = class WxContext2d extends exports.BrowserContext2d {
+      static env = 'wx';
+      draw() {
+          return;
+      }
+  };
+  WxContext2d = __decorate([
+      injectable()
+  ], WxContext2d);
+
+  const DefaultConfig$1 = {
+      WIDTH: 500,
+      HEIGHT: 500,
+      DPR: 1
+  };
+  let WxCanvas = class WxCanvas {
+      static env = 'wx';
+      _displayWidth;
+      _displayHeight;
+      _id;
+      _pixelWidth;
+      _pixelHeight;
+      _x;
+      _y;
+      _dpr;
+      _container;
+      _nativeCanvas;
+      _context;
+      _visiable;
+      get id() {
+          return this._id;
+      }
+      get x() {
+          return this._x;
+      }
+      get y() {
+          return this._y;
+      }
+      get nativeCanvas() {
+          return this._nativeCanvas;
+      }
+      get width() {
+          return this._pixelWidth;
+      }
+      set width(width) {
+          this._pixelWidth = width;
+          this._displayWidth = width / (this._dpr || 1);
+      }
+      get height() {
+          return this._pixelHeight;
+      }
+      set height(height) {
+          this._pixelHeight = height;
+          this._displayHeight = height / (this._dpr || 1);
+      }
+      get displayWidth() {
+          return this._displayWidth;
+      }
+      get displayHeight() {
+          return this._displayHeight;
+      }
+      getContext(str) {
+          return this._context;
+      }
+      get visiable() {
+          return this._visiable;
+      }
+      set visiable(visiable) {
+          this._visiable = visiable;
+          visiable ? this.show() : this.hide();
+      }
+      get dpr() {
+          return this._dpr;
+      }
+      set dpr(dpr) {
+          this._dpr = dpr;
+      }
+      constructor(params) {
+          const { nativeCanvas, width = DefaultConfig$1.WIDTH, height = DefaultConfig$1.HEIGHT, dpr = DefaultConfig$1.DPR } = params;
+          const { x, y } = nativeCanvas.getBoundingClientRect ? nativeCanvas.getBoundingClientRect() : { x: 0, y: 0 };
+          this._x = x;
+          this._y = y;
+          this._pixelWidth = width * dpr;
+          this._pixelHeight = height * dpr;
+          this._visiable = params.visiable !== false;
+          this._displayWidth = width;
+          this._displayHeight = height;
+          this._dpr = dpr;
+          this._nativeCanvas = nativeCanvas;
+          this._context = new WxContext2d(this, this._dpr);
+          this._id = nativeCanvas.id;
+      }
+      getNativeCanvas() {
+          return this._nativeCanvas;
+      }
+      resetStyle(params) {
+          return;
+      }
+      applyPosition() {
+          return;
+      }
+      hide() {
+          return;
+      }
+      show() {
+          return;
+      }
+      resize(width, height) {
+          return;
+      }
+      toDataURL(mimeType, quality) {
+          return '';
+      }
+      readPixels(x, y, w, h) {
+          throw new Error('暂未实现');
+      }
+      convertToBlob(options) {
+          throw new Error('暂未实现');
+      }
+      transferToImageBitmap() {
+          throw new Error('暂未实现');
+      }
+      release(...params) {
+          return;
+      }
+  };
+  WxCanvas = __decorate([
+      injectable(),
+      __metadata("design:paramtypes", [Object])
+  ], WxCanvas);
+
+  class MiniAppEventManager {
+      addEventListener(type, func) {
+          if (!type || !func) {
+              return;
+          }
+          this.cache[type] = this.cache[type] || {
+              listener: []
+          };
+          this.cache[type].listener.push(func);
+      }
+      removeEventListener(type, func) {
+          if (!type || !func) {
+              return;
+          }
+          if (!this.cache[type]) {
+              return;
+          }
+          const index = this.cache[type].listener.findIndex((f) => f === func);
+          if (index >= 0) {
+              this.cache[type].listener.splice(index, 1);
+          }
+      }
+      cleanEvent() {
+          this.cache = {};
+      }
+      cache = {};
+  }
+  let WxWindowHandlerContribution = class WxWindowHandlerContribution extends exports.BaseWindowHandlerContribution {
+      global;
+      static env = 'wx';
+      type = 'wx';
+      eventManager = new MiniAppEventManager();
+      canvas;
+      get container() {
+          return null;
+      }
+      constructor(global) {
+          super();
+          this.global = global;
+      }
+      getTitle() {
+          return this.canvas.id.toString();
+      }
+      getWH() {
+          return {
+              width: this.canvas.width / (this.canvas.dpr || 1),
+              height: this.canvas.height / (this.canvas.dpr || 1)
+          };
+      }
+      getXY() {
+          return { x: 0, y: 0 };
+      }
+      createWindow(params) {
+          if (!params.canvas) {
+              this.createWindowByConfig(params);
+          }
+          else {
+              this.createWindowByCanvas(params);
+          }
+      }
+      createWindowByConfig(params) {
+          const nativeCanvas = this.global.createCanvas({
+              width: params.width,
+              height: params.height
+          });
+          const options = {
+              width: params.width,
+              height: params.height,
+              dpr: params.dpr,
+              nativeCanvas,
+              id: Generator.GenAutoIncrementId().toString(),
+              canvasControled: false
+          };
+          this.canvas = new WxCanvas(options);
+      }
+      createWindowByCanvas(params) {
+          let canvas;
+          if (typeof params.canvas === 'string') {
+              canvas = this.global.getElementById(params.canvas);
+              if (!canvas) {
+                  throw new Error('canvasId 参数不正确，请确认canvas存在并插入dom');
+              }
+          }
+          else {
+              canvas = params.canvas;
+          }
+          let width = params.width;
+          let height = params.height;
+          if (width == null || height == null || !params.canvasControled) {
+              const data = canvas.getBoundingClientRect();
+              width = data.width;
+              height = data.height;
+          }
+          let dpr = params.dpr;
+          if (dpr == null) {
+              dpr = canvas.width / width;
+          }
+          this.canvas = new WxCanvas({
+              width: width,
+              height: height,
+              dpr: dpr,
+              nativeCanvas: canvas,
+              canvasControled: params.canvasControled
+          });
+      }
+      releaseWindow() {
+          return;
+      }
+      resizeWindow(width, height) {
+          return;
+      }
+      setDpr(dpr) {
+          this.canvas.dpr = dpr;
+      }
+      getContext() {
+          return this.canvas.getContext();
+      }
+      getNativeHandler() {
+          return this.canvas;
+      }
+      getDpr() {
+          return this.canvas.dpr;
+      }
+      addEventListener(type, listener) {
+          this.eventManager.addEventListener(type, listener);
+      }
+      removeEventListener(type, listener) {
+          this.eventManager.removeEventListener(type, listener);
+      }
+      dispatchEvent(event) {
+          const { type } = event;
+          if (!this.eventManager.cache[type]) {
+              return false;
+          }
+          if (event.changedTouches && event.changedTouches[0]) {
+              event.offsetX = event.changedTouches[0].x;
+              event.changedTouches[0].offsetX = event.changedTouches[0].x ?? event.changedTouches[0].pageX;
+              event.changedTouches[0].clientX = event.changedTouches[0].x ?? event.changedTouches[0].pageX;
+              event.offsetY = event.changedTouches[0].y;
+              event.changedTouches[0].offsetY = event.changedTouches[0].y ?? event.changedTouches[0].pageY;
+              event.changedTouches[0].clientY = event.changedTouches[0].y ?? event.changedTouches[0].pageY;
+          }
+          event.preventDefault = () => {
+              return;
+          };
+          event.stopPropagation = () => {
+              return;
+          };
+          if (this.eventManager.cache[type].listener) {
+              this.eventManager.cache[type].listener.forEach((f) => {
+                  f(event);
+              });
+          }
+          return true;
+      }
+      getStyle() {
+          return {};
+      }
+      setStyle(style) {
+          return;
+      }
+      getBoundingClientRect() {
+          const wh = this.getWH();
+          return {
+              x: 0,
+              y: 0,
+              width: wh.width,
+              height: wh.height,
+              left: 0,
+              top: 0,
+              right: 0,
+              bottom: 0
+          };
+      }
+      clearViewBox(vb, color) {
+          const context = this.getContext();
+          const dpr = this.getDpr();
+          context.nativeContext.save();
+          context.nativeContext.setTransform(dpr, 0, 0, dpr, 0, 0);
+          context.clearRect(vb.x1, vb.y1, vb.x2 - vb.x1, vb.y2 - vb.y1);
+          if (color) {
+              context.fillStyle = color;
+              context.fillRect(vb.x1, vb.y1, vb.x2 - vb.x1, vb.y2 - vb.y1);
+          }
+          context.nativeContext.restore();
+      }
+  };
+  WxWindowHandlerContribution = __decorate([
+      injectable(),
+      __param(0, inject(Global)),
+      __metadata("design:paramtypes", [Object])
+  ], WxWindowHandlerContribution);
+
   var windowModules = new ContainerModule(bind => {
       bind(BrowserWindowHandlerContribution).toSelf();
       bind(WindowHandlerContribution)
@@ -29567,6 +30022,10 @@
       bind(WindowHandlerContribution)
           .toDynamicValue(ctx => ctx.container.get(LynxWindowHandlerContribution))
           .whenTargetNamed(LynxWindowHandlerContribution.env);
+      bind(WxWindowHandlerContribution).toSelf();
+      bind(WindowHandlerContribution)
+          .toDynamicValue(ctx => ctx.container.get(WxWindowHandlerContribution))
+          .whenTargetNamed(WxWindowHandlerContribution.env);
       bind(NodeWindowHandlerContribution).toSelf();
       bind(WindowHandlerContribution)
           .toDynamicValue(ctx => ctx.container.get(NodeWindowHandlerContribution))
@@ -32877,6 +33336,19 @@
           .whenTargetNamed(LynxContext2d.env);
   });
 
+  var wxModule = new ContainerModule(bind => {
+      bind(CanvasFactory)
+          .toDynamicValue(() => {
+          return (params) => new WxCanvas(params);
+      })
+          .whenTargetNamed(WxCanvas.env);
+      bind(Context2dFactory)
+          .toDynamicValue(() => {
+          return (params, dpr) => new WxContext2d(params, dpr);
+      })
+          .whenTargetNamed(WxContext2d.env);
+  });
+
   var nodeModule = new ContainerModule(bind => {
       bind(CanvasFactory)
           .toDynamicValue(() => {
@@ -32895,6 +33367,7 @@
       container.load(feishuModule);
       container.load(taroModule);
       container.load(lynxModule);
+      container.load(wxModule);
       container.load(nodeModule);
   }
 
@@ -33770,7 +34243,7 @@
       'rect'
   ];
 
-  const version = "0.12.3";
+  const version = "0.13.0-alpha.6";
 
   exports.ACustomAnimate = ACustomAnimate;
   exports.ARC3D_NUMBER_TYPE = ARC3D_NUMBER_TYPE;