@visactor/vrender-kits 1.1.0-alpha.27 → 1.1.0-alpha.28

package/dist/index.es.js

@@ -13525,10 +13525,198 @@ const builtInSymbolStrMap = {
   roundLine: "M 1.2392 -0.258 L -1.3432 -0.258 C -1.4784 -0.258 -1.588 -0.1436 -1.588 -0.002 c 0 0.1416 0.1096 0.256 0.2448 0.256 l 2.5824 0 c 0.1352 0 0.2448 -0.1144 0.2448 -0.256 C 1.484 -0.1436 1.3744 -0.258 1.2392 -0.258 z"
 };
 
+function getAllMatches(string, regex) {
+  const matches = [];
+  let match = regex.exec(string);
+  for (; match;) {
+    const allmatches = [];
+    allmatches.startIndex = regex.lastIndex - match[0].length;
+    const len = match.length;
+    for (let index = 0; index < len; index++) allmatches.push(match[index]);
+    matches.push(allmatches), match = regex.exec(string);
+  }
+  return matches;
+}
+
+class XmlNode {
+  constructor(tagname) {
+    this.tagname = tagname, this.child = [], this[":@"] = {};
+  }
+  add(key, val) {
+    "__proto__" === key && (key = "#__proto__"), this.child.push({
+      [key]: val
+    });
+  }
+  addChild(node) {
+    "__proto__" === node.tagname && (node.tagname = "#__proto__"), node[":@"] && Object.keys(node[":@"]).length > 0 ? this.child.push({
+      [node.tagname]: node.child,
+      ":@": node[":@"]
+    }) : this.child.push({
+      [node.tagname]: node.child
+    });
+  }
+}
+function findClosingIndex(xmlData, str, i, errMsg) {
+  const closingIndex = xmlData.indexOf(str, i);
+  if (-1 === closingIndex) throw new Error(errMsg);
+  return closingIndex + str.length - 1;
+}
+function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
+  let attrBoundary,
+    tagExp = "";
+  for (let index = i; index < xmlData.length; index++) {
+    let ch = xmlData[index];
+    if (attrBoundary) ch === attrBoundary && (attrBoundary = "");else if ('"' === ch || "'" === ch) attrBoundary = ch;else if (ch === closingChar[0]) {
+      if (!closingChar[1]) return {
+        data: tagExp,
+        index: index
+      };
+      if (xmlData[index + 1] === closingChar[1]) return {
+        data: tagExp,
+        index: index
+      };
+    } else "\t" === ch && (ch = " ");
+    tagExp += ch;
+  }
+}
+function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
+  const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
+  if (!result) return;
+  let tagExp = result.data;
+  const closeIndex = result.index,
+    separatorIndex = tagExp.search(/\s/);
+  let tagName = tagExp,
+    attrExpPresent = !0;
+  -1 !== separatorIndex && (tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, ""), tagExp = tagExp.substr(separatorIndex + 1));
+  const rawTagName = tagName;
+  if (removeNSPrefix) {
+    const colonIndex = tagName.indexOf(":");
+    -1 !== colonIndex && (tagName = tagName.substr(colonIndex + 1), attrExpPresent = tagName !== result.data.substr(colonIndex + 1));
+  }
+  return {
+    tagName: tagName,
+    tagExp: tagExp,
+    closeIndex: closeIndex,
+    attrExpPresent: attrExpPresent,
+    rawTagName: rawTagName
+  };
+}
+const attrsRegx = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
+class OrderedObjParser {
+  constructor(options) {
+    this.currentNode = null, this.options = options, this.tagsNodeStack = [], this.docTypeEntities = {};
+  }
+  addChild(currentNode, childNode, jPath) {
+    const result = childNode.tagname;
+    "string" == typeof result ? (childNode.tagname = result, currentNode.addChild(childNode)) : currentNode.addChild(childNode);
+  }
+  buildAttributesMap(attrStr, jPath, tagName) {
+    const attrs = {};
+    if (!attrStr) return;
+    const matches = getAllMatches(attrStr, attrsRegx),
+      len = matches.length;
+    for (let i = 0; i < len; i++) {
+      const attrName = matches[i][1],
+        oldVal = matches[i][4],
+        aName = attrName;
+      attrName && (attrs[aName] = void 0 === oldVal || (isNaN(oldVal) ? oldVal : Number(oldVal)));
+    }
+    return attrs;
+  }
+  parseXml(xmlData) {
+    xmlData = xmlData.replace(/\r\n?/g, "\n");
+    const xmlObj = new XmlNode("!xml");
+    let currentNode = xmlObj,
+      textData = "",
+      jPath = "";
+    for (let i = 0; i < xmlData.length; i++) {
+      if ("<" === xmlData[i]) {
+        if ("/" === xmlData[i + 1]) {
+          const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed."),
+            propIndex = jPath.lastIndexOf(".");
+          jPath = jPath.substring(0, propIndex), currentNode = this.tagsNodeStack.pop(), currentNode && currentNode.child && textData && currentNode.child[currentNode.child.length - 1][":@"] && (currentNode.child[currentNode.child.length - 1][":@"].text = textData), textData = "", i = closeIndex;
+        } else if ("?" === xmlData[i + 1]) {
+          i = readTagExp(xmlData, i, !1, "?>").closeIndex + 1;
+        } else if ("!--" === xmlData.substr(i + 1, 3)) {
+          i = findClosingIndex(xmlData, "--\x3e", i + 4, "Comment is not closed.");
+        } else {
+          const result = readTagExp(xmlData, i, !1);
+          let tagName = result.tagName,
+            tagExp = result.tagExp;
+          const attrExpPresent = result.attrExpPresent,
+            closeIndex = result.closeIndex;
+          if (tagName !== xmlObj.tagname && (jPath += jPath ? "." + tagName : tagName), tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
+            "/" === tagName[tagName.length - 1] ? (tagName = tagName.substr(0, tagName.length - 1), jPath = jPath.substr(0, jPath.length - 1), tagExp = tagName) : tagExp = tagExp.substr(0, tagExp.length - 1);
+            const childNode = new XmlNode(tagName);
+            tagName !== tagExp && attrExpPresent && (childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName)), this.addChild(currentNode, childNode, jPath), jPath = jPath.substr(0, jPath.lastIndexOf("."));
+          } else {
+            const childNode = new XmlNode(tagName);
+            this.tagsNodeStack.push(currentNode), tagName !== tagExp && attrExpPresent && (childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName)), this.addChild(currentNode, childNode, jPath), currentNode = childNode;
+          }
+          textData = "", i = closeIndex;
+        }
+      } else textData += xmlData[i];
+    }
+    return xmlObj.child;
+  }
+}
+
+function prettify(node, options) {
+  return compress(node);
+}
+function compress(arr, jPath) {
+  const compressedObj = {};
+  for (let i = 0; i < arr.length; i++) {
+    const tagObj = arr[i],
+      property = propName(tagObj);
+    if (void 0 !== property && tagObj[property]) {
+      const val = compress(tagObj[property]);
+      isLeafTag(val);
+      tagObj[":@"] && assignAttributes(val, tagObj[":@"]), void 0 !== compressedObj[property] && compressedObj.hasOwnProperty(property) ? (Array.isArray(compressedObj[property]) || (compressedObj[property] = [compressedObj[property]]), compressedObj[property].push(val)) : compressedObj[property] = val;
+    }
+  }
+  return compressedObj;
+}
+function propName(obj) {
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (":@" !== key) return key;
+  }
+}
+function assignAttributes(obj, attrMap, jpath) {
+  if (attrMap) {
+    const keys = Object.keys(attrMap),
+      len = keys.length;
+    for (let i = 0; i < len; i++) {
+      const atrrName = keys[i];
+      obj[atrrName] = attrMap[atrrName];
+    }
+  }
+}
+function isLeafTag(obj) {
+  return 0 === Object.keys(obj).length;
+}
+
 function isSvg(str) {
   return str.startsWith("<svg") || str.startsWith("<?xml");
 }
 
+class XMLParser {
+  constructor(options) {
+    this.options = Object.assign({}, XMLParser.defaultOptions, options);
+  }
+  valid(xml) {
+    return xml.startsWith("<");
+  }
+  parse(xmlData) {
+    if (!this.valid) return !1;
+    const orderedResult = new OrderedObjParser(this.options).parseXml(xmlData);
+    return prettify(orderedResult, this.options);
+  }
+}
+XMLParser.defaultOptions = {};
+
 undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
   return new (P || (P = Promise))(function (resolve, reject) {
     function fulfilled(value) {
@@ -15344,10 +15532,7 @@ class Graphic extends Node {
     if (path = Graphic.userSymbolMap[symbolType], path) return path;
     const _symbolType = builtInSymbolStrMap[symbolType];
     if (!0 === isSvg(symbolType = _symbolType || symbolType)) {
-      const {
-          XMLParser: XMLParser
-        } = require("../common/xml/parser"),
-        parser = new XMLParser(),
+      const parser = new XMLParser(),
         {
           svg: svg
         } = parser.parse(symbolType);
@@ -21305,7 +21490,9 @@ const loadedArcModuleContexts = new WeakSet();
 function bindArcRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedArcModuleContexts, bind) || (bind(DefaultCanvasArcRender).toSelf().inSingletonScope(), bind(ArcRender).to(DefaultCanvasArcRender).inSingletonScope(), bind(GraphicRender).toService(ArcRender), bind(ArcRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, ArcRenderContribution));
+  isBindingContextLoaded(loadedArcModuleContexts, bind) || (bind(DefaultCanvasArcRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasArcRender(createContributionProvider(ArcRenderContribution, container))).inSingletonScope(), bind(ArcRender).toService(DefaultCanvasArcRender), bind(GraphicRender).toService(ArcRender), bind(ArcRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, ArcRenderContribution));
 }
 const arcModule = bindArcRenderModule;
 
@@ -21434,7 +21621,7 @@ const loadedArc3dModuleContexts = new WeakSet();
 function bindArc3dRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedArc3dModuleContexts, bind) || (bind(Arc3dRender).to(DefaultCanvasArc3DRender).inSingletonScope(), bind(GraphicRender).toService(Arc3dRender));
+  isBindingContextLoaded(loadedArc3dModuleContexts, bind) || (bind(DefaultCanvasArc3DRender).toDynamicValue(() => new DefaultCanvasArc3DRender()).inSingletonScope(), bind(Arc3dRender).toService(DefaultCanvasArc3DRender), bind(GraphicRender).toService(Arc3dRender));
 }
 const arc3dModule = bindArc3dRenderModule;
 
@@ -21588,39 +21775,6 @@ function drawSegments(path, segPath, percent, clipRangeByDimension, params) {
     }
   }
 }
-function drawIncrementalSegments(path, lastSeg, segments, params) {
-  const {
-      offsetX = 0,
-      offsetY = 0
-    } = params || {},
-    startP = lastSeg ? lastSeg.points[lastSeg.points.length - 1] : segments.points[0];
-  path.moveTo(startP.x + offsetX, startP.y + offsetY), segments.points.forEach(p => {
-    !1 !== p.defined ? path.lineTo(p.x + offsetX, p.y + offsetY) : path.moveTo(p.x + offsetX, p.y + offsetY);
-  });
-}
-function drawIncrementalAreaSegments(path, lastSeg, segments, params) {
-  const {
-      offsetX = 0,
-      offsetY = 0
-    } = params || {},
-    {
-      points: points
-    } = segments,
-    definedPointsList = [];
-  for (let i = 0; i < points.length; i++) !1 === points[i].defined && (i);
-  definedPointsList.push(points), definedPointsList.forEach((points, i) => {
-    var _a, _b, _c, _d;
-    const startP = lastSeg && 0 === i ? lastSeg.points[lastSeg.points.length - 1] : points[0];
-    path.moveTo(startP.x + offsetX, startP.y + offsetY), points.forEach(p => {
-      !1 !== p.defined ? path.lineTo(p.x + offsetX, p.y + offsetY) : path.moveTo(p.x + offsetX, p.y + offsetY);
-    });
-    for (let i = points.length - 1; i >= 0; i--) {
-      const p = points[i];
-      path.lineTo(null !== (_a = p.x1) && void 0 !== _a ? _a : p.x, null !== (_b = p.y1) && void 0 !== _b ? _b : p.y);
-    }
-    path.lineTo(null !== (_c = startP.x1) && void 0 !== _c ? _c : startP.x, null !== (_d = startP.y1) && void 0 !== _d ? _d : startP.y), path.closePath();
-  });
-}
 
 const defaultAreaTextureRenderContribution = new DefaultAreaTextureRenderContribution();
 const defaultAreaBackgroundRenderContribution = defaultBaseBackgroundRenderContribution;
@@ -21850,48 +22004,13 @@ class DefaultCanvasAreaRender extends BaseRender {
   }
 }
 
-class DefaultIncrementalCanvasAreaRender extends DefaultCanvasAreaRender {
-  constructor() {
-    super(...arguments), this.numberType = AREA_NUMBER_TYPE;
-  }
-  drawShape(area, context, x, y, drawContext, params, fillCb) {
-    if (area.incremental && drawContext.multiGraphicOptions) {
-      const {
-          startAtIdx: startAtIdx,
-          length: length
-        } = drawContext.multiGraphicOptions,
-        {
-          segments = []
-        } = area.attribute;
-      if (startAtIdx > segments.length) return;
-      const areaAttribute = getTheme(area).area,
-        {
-          fill = areaAttribute.fill,
-          fillOpacity = areaAttribute.fillOpacity,
-          opacity = areaAttribute.opacity,
-          visible = areaAttribute.visible
-        } = area.attribute,
-        fVisible = fillVisible(opacity, fillOpacity, fill),
-        doFill = runFill(fill);
-      if (!area.valid || !visible) return;
-      if (!doFill) return;
-      if (!fVisible && !fillCb) return;
-      for (let i = startAtIdx; i < startAtIdx + length; i++) this.drawIncreaseSegment(area, context, segments[i - 1], segments[i], area.attribute.segments[i], [areaAttribute, area.attribute], x, y);
-    } else super.drawShape(area, context, x, y, drawContext, params, fillCb);
-  }
-  drawIncreaseSegment(area, context, lastSeg, seg, attribute, defaultAttribute, offsetX, offsetY) {
-    seg && (context.beginPath(), drawIncrementalAreaSegments(context.camera ? context : context.nativeContext, lastSeg, seg, {
-      offsetX: offsetX,
-      offsetY: offsetY
-    }), context.setShadowBlendStyle && context.setShadowBlendStyle(area, attribute, defaultAttribute), context.setCommonStyle(area, attribute, offsetX, offsetY, defaultAttribute), context.fill());
-  }
-}
-
 const loadedAreaModuleContexts = new WeakSet();
 function bindAreaRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedAreaModuleContexts, bind) || (bind(DefaultCanvasAreaRender).toSelf().inSingletonScope(), bind(AreaRender).to(DefaultCanvasAreaRender).inSingletonScope(), bind(GraphicRender).toService(AreaRender), bind(AreaRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, AreaRenderContribution), bind(DefaultIncrementalCanvasAreaRender).toSelf().inSingletonScope());
+  isBindingContextLoaded(loadedAreaModuleContexts, bind) || (bind(DefaultCanvasAreaRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasAreaRender(createContributionProvider(AreaRenderContribution, container))).inSingletonScope(), bind(AreaRender).toService(DefaultCanvasAreaRender), bind(GraphicRender).toService(AreaRender), bind(AreaRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, AreaRenderContribution));
 }
 const areaModule = bindAreaRenderModule;
 
@@ -21936,7 +22055,9 @@ const loadedCircleModuleContexts = new WeakSet();
 function bindCircleRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedCircleModuleContexts, bind) || (bind(DefaultCanvasCircleRender).toSelf().inSingletonScope(), bind(CircleRender).to(DefaultCanvasCircleRender).inSingletonScope(), bind(GraphicRender).toService(CircleRender), bind(CircleRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, CircleRenderContribution));
+  isBindingContextLoaded(loadedCircleModuleContexts, bind) || (bind(DefaultCanvasCircleRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasCircleRender(createContributionProvider(CircleRenderContribution, container))).inSingletonScope(), bind(CircleRender).toService(DefaultCanvasCircleRender), bind(GraphicRender).toService(CircleRender), bind(CircleRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, CircleRenderContribution));
 }
 const circleModule = bindCircleRenderModule;
 
@@ -21971,7 +22092,7 @@ const loadedGlyphModuleContexts = new WeakSet();
 function bindGlyphRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedGlyphModuleContexts, bind) || (bind(GlyphRender).to(DefaultCanvasGlyphRender).inSingletonScope(), bind(GraphicRender).toService(GlyphRender));
+  isBindingContextLoaded(loadedGlyphModuleContexts, bind) || (bind(DefaultCanvasGlyphRender).toDynamicValue(() => new DefaultCanvasGlyphRender()).inSingletonScope(), bind(GlyphRender).toService(DefaultCanvasGlyphRender), bind(GraphicRender).toService(GlyphRender));
 }
 const glyphModule = bindGlyphRenderModule;
 
@@ -22145,7 +22266,9 @@ const loadedImageModuleContexts = new WeakSet();
 function bindImageRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedImageModuleContexts, bind) || (bind(ImageRender).to(DefaultCanvasImageRender).inSingletonScope(), bind(GraphicRender).toService(ImageRender), bind(ImageRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, ImageRenderContribution));
+  isBindingContextLoaded(loadedImageModuleContexts, bind) || (bind(ImageRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasImageRender(createContributionProvider(ImageRenderContribution, container))).inSingletonScope(), bind(GraphicRender).toService(ImageRender), bind(ImageRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, ImageRenderContribution));
 }
 const imageModule = bindImageRenderModule;
 
@@ -22288,56 +22411,11 @@ class DefaultCanvasLineRender extends BaseRender {
   }
 }
 
-class DefaultIncrementalCanvasLineRender extends DefaultCanvasLineRender {
-  constructor() {
-    super(...arguments), this.numberType = LINE_NUMBER_TYPE;
-  }
-  drawShape(line, context, x, y, drawContext, params, fillCb, strokeCb) {
-    if (line.incremental && drawContext.multiGraphicOptions) {
-      const {
-          startAtIdx: startAtIdx,
-          length: length
-        } = drawContext.multiGraphicOptions,
-        {
-          segments = []
-        } = line.attribute;
-      if (startAtIdx > segments.length) return;
-      const lineAttribute = getTheme(line).line,
-        {
-          fill = lineAttribute.fill,
-          stroke = lineAttribute.stroke,
-          opacity = lineAttribute.opacity,
-          fillOpacity = lineAttribute.fillOpacity,
-          strokeOpacity = lineAttribute.strokeOpacity,
-          lineWidth = lineAttribute.lineWidth,
-          visible = lineAttribute.visible
-        } = line.attribute,
-        fVisible = fillVisible(opacity, fillOpacity, fill),
-        sVisible = strokeVisible(opacity, strokeOpacity),
-        doFill = runFill(fill),
-        doStroke = runStroke(stroke, lineWidth);
-      if (!line.valid || !visible) return;
-      if (!doFill && !doStroke) return;
-      if (!(fVisible || sVisible || fillCb || strokeCb)) return;
-      const {
-        context: context
-      } = drawContext;
-      for (let i = startAtIdx; i < startAtIdx + length; i++) this.drawIncreaseSegment(line, context, segments[i - 1], segments[i], line.attribute.segments[i], [lineAttribute, line.attribute], x, y);
-    } else super.drawShape(line, context, x, y, drawContext, params, fillCb, strokeCb);
-  }
-  drawIncreaseSegment(line, context, lastSeg, seg, attribute, defaultAttribute, offsetX, offsetY) {
-    seg && (context.beginPath(), drawIncrementalSegments(context.nativeContext, lastSeg, seg, {
-      offsetX: offsetX,
-      offsetY: offsetY
-    }), context.setShadowBlendStyle && context.setShadowBlendStyle(line, attribute, defaultAttribute), context.setStrokeStyle(line, attribute, offsetX, offsetY, defaultAttribute), context.stroke());
-  }
-}
-
 const loadedLineModuleContexts = new WeakSet();
 function bindLineRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedLineModuleContexts, bind) || (bind(DefaultCanvasLineRender).toSelf().inSingletonScope(), bind(DefaultIncrementalCanvasLineRender).toSelf().inSingletonScope(), bind(LineRender).to(DefaultCanvasLineRender).inSingletonScope(), bind(GraphicRender).toService(LineRender));
+  isBindingContextLoaded(loadedLineModuleContexts, bind) || (bind(DefaultCanvasLineRender).toDynamicValue(() => new DefaultCanvasLineRender()).inSingletonScope(), bind(LineRender).toService(DefaultCanvasLineRender), bind(GraphicRender).toService(LineRender));
 }
 const lineModule = bindLineRenderModule;
 
@@ -22388,7 +22466,9 @@ const loadedPathModuleContexts = new WeakSet();
 function bindPathRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedPathModuleContexts, bind) || (bind(DefaultCanvasPathRender).toSelf().inSingletonScope(), bind(PathRender).to(DefaultCanvasPathRender).inSingletonScope(), bind(GraphicRender).toService(PathRender), bind(PathRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, PathRenderContribution));
+  isBindingContextLoaded(loadedPathModuleContexts, bind) || (bind(DefaultCanvasPathRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasPathRender(createContributionProvider(PathRenderContribution, container))).inSingletonScope(), bind(PathRender).toService(DefaultCanvasPathRender), bind(GraphicRender).toService(PathRender), bind(PathRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, PathRenderContribution));
 }
 const pathModule = bindPathRenderModule;
 
@@ -22488,7 +22568,9 @@ const loadedPolygonModuleContexts = new WeakSet();
 function bindPolygonRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedPolygonModuleContexts, bind) || (bind(PolygonRender).to(DefaultCanvasPolygonRender).inSingletonScope(), bind(GraphicRender).toService(PolygonRender), bind(PolygonRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, PolygonRenderContribution));
+  isBindingContextLoaded(loadedPolygonModuleContexts, bind) || (bind(PolygonRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasPolygonRender(createContributionProvider(PolygonRenderContribution, container))).inSingletonScope(), bind(GraphicRender).toService(PolygonRender), bind(PolygonRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, PolygonRenderContribution));
 }
 const polygonModule = bindPolygonRenderModule;
 
@@ -22599,7 +22681,7 @@ const loadedPyramid3dModuleContexts = new WeakSet();
 function bindPyramid3dRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedPyramid3dModuleContexts, bind) || (bind(Pyramid3dRender).to(DefaultCanvasPyramid3dRender).inSingletonScope(), bind(GraphicRender).toService(Pyramid3dRender));
+  isBindingContextLoaded(loadedPyramid3dModuleContexts, bind) || (bind(DefaultCanvasPyramid3dRender).toDynamicValue(() => new DefaultCanvasPyramid3dRender()).inSingletonScope(), bind(Pyramid3dRender).toService(DefaultCanvasPyramid3dRender), bind(GraphicRender).toService(Pyramid3dRender));
 }
 const pyramid3dModule = bindPyramid3dRenderModule;
 
@@ -22723,7 +22805,7 @@ const loadedRect3dModuleContexts = new WeakSet();
 function bindRect3dRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedRect3dModuleContexts, bind) || (bind(Rect3DRender).to(DefaultCanvasRect3dRender).inSingletonScope(), bind(GraphicRender).toService(Rect3DRender));
+  isBindingContextLoaded(loadedRect3dModuleContexts, bind) || (bind(DefaultCanvasRect3dRender).toDynamicValue(() => new DefaultCanvasRect3dRender()).inSingletonScope(), bind(Rect3DRender).toService(DefaultCanvasRect3dRender), bind(GraphicRender).toService(Rect3DRender));
 }
 const rect3dModule = bindRect3dRenderModule;
 
@@ -22852,13 +22934,13 @@ const loadedRichtextModuleContexts = new WeakSet();
 function bindRichtextRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedRichtextModuleContexts, bind) || (bind(RichTextRender).to(DefaultCanvasRichTextRender).inSingletonScope(), bind(GraphicRender).toService(RichTextRender));
+  isBindingContextLoaded(loadedRichtextModuleContexts, bind) || (bind(DefaultCanvasRichTextRender).toDynamicValue(() => new DefaultCanvasRichTextRender()).inSingletonScope(), bind(RichTextRender).toService(DefaultCanvasRichTextRender), bind(GraphicRender).toService(RichTextRender));
 }
 const richtextModule = bindRichtextRenderModule;
 
 class DefaultCanvasStarRender extends BaseRender {
-  constructor(starRenderContribitions) {
-    super(), this.starRenderContribitions = starRenderContribitions, this.numberType = STAR_NUMBER_TYPE, this.builtinContributions = [defaultStarBackgroundRenderContribution, defaultStarTextureRenderContribution], this.init(starRenderContribitions);
+  constructor(graphicRenderContributions) {
+    super(), this.graphicRenderContributions = graphicRenderContributions, this.numberType = STAR_NUMBER_TYPE, this.builtinContributions = [defaultStarBackgroundRenderContribution, defaultStarTextureRenderContribution], this.init(graphicRenderContributions);
   }
   drawShape(star, context, x, y, drawContext, params, fillCb, strokeCb) {
     const starAttribute = getTheme(star, null == params ? void 0 : params.theme).star,
@@ -22899,7 +22981,7 @@ function bindStarRenderModule({
 }) {
   isBindingContextLoaded(loadedStarModuleContexts, bind) || (bind(DefaultCanvasStarRender).toDynamicValue(({
     container: container
-  }) => new DefaultCanvasStarRender(createContributionProvider(StarRenderContribution, container))).inSingletonScope(), bind(StarRender).toService(DefaultCanvasStarRender), bind(GraphicRender).toService(StarRender));
+  }) => new DefaultCanvasStarRender(createContributionProvider(StarRenderContribution, container))).inSingletonScope(), bind(StarRender).toService(DefaultCanvasStarRender), bind(GraphicRender).toService(StarRender), bindContributionProvider(bind, StarRenderContribution));
 }
 const starModule = bindStarRenderModule;
 
@@ -22973,7 +23055,9 @@ const loadedSymbolModuleContexts = new WeakSet();
 function bindSymbolRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedSymbolModuleContexts, bind) || (bind(DefaultCanvasSymbolRender).toSelf().inSingletonScope(), bind(SymbolRender).to(DefaultCanvasSymbolRender).inSingletonScope(), bind(GraphicRender).toService(SymbolRender), bind(SymbolRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, SymbolRenderContribution));
+  isBindingContextLoaded(loadedSymbolModuleContexts, bind) || (bind(DefaultCanvasSymbolRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasSymbolRender(createContributionProvider(SymbolRenderContribution, container))).inSingletonScope(), bind(SymbolRender).toService(DefaultCanvasSymbolRender), bind(GraphicRender).toService(SymbolRender), bind(SymbolRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, SymbolRenderContribution));
 }
 const symbolModule = bindSymbolRenderModule;
 
@@ -23116,7 +23200,9 @@ const loadedTextModuleContexts = new WeakSet();
 function bindTextRenderModule({
   bind: bind
 }) {
-  isBindingContextLoaded(loadedTextModuleContexts, bind) || (bind(TextRender).to(DefaultCanvasTextRender).inSingletonScope(), bind(GraphicRender).toService(TextRender), bind(TextRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, TextRenderContribution));
+  isBindingContextLoaded(loadedTextModuleContexts, bind) || (bind(TextRender).toDynamicValue(({
+    container: container
+  }) => new DefaultCanvasTextRender(createContributionProvider(TextRenderContribution, container))).inSingletonScope(), bind(GraphicRender).toService(TextRender), bind(TextRenderContribution).toService(DefaultBaseInteractiveRenderContribution), bindContributionProvider(bind, TextRenderContribution));
 }
 const textModule = bindTextRenderModule;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vrender-kits",
-  "version": "1.1.0-alpha.27",
+  "version": "1.1.0-alpha.28",
   "description": "",
   "sideEffects": false,
   "main": "cjs/index-node.js",
@@ -44,7 +44,7 @@
   ],
   "dependencies": {
     "@visactor/vutils": "~1.0.12",
-    "@visactor/vrender-core": "1.1.0-alpha.27",
+    "@visactor/vrender-core": "1.1.0-alpha.28",
     "@resvg/resvg-js": "2.4.1",
     "roughjs": "4.6.6",
     "gifuct-js": "2.1.2",