@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/g6/esm/runtime/element.js

@@ -0,0 +1,582 @@
+import "../../../g/dist/index.esm.js";
+import "../constants/change.js";
+import { AnimationType as E } from "../constants/events/animation.js";
+import "../constants/events/canvas.js";
+import "../constants/events/combo.js";
+import "../constants/events/common.js";
+import "../constants/events/container.js";
+import "../constants/events/edge.js";
+import { GraphEvent as p } from "../constants/events/graph.js";
+import "../constants/events/history.js";
+import "../constants/events/node.js";
+import { COMBO_KEY as I } from "../constants/graphlib.js";
+import "../constants/registry.js";
+import { ELEMENT_TYPES as U } from "../constants/element.js";
+import { getExtension as W } from "../registry/get.js";
+import { hasCachedStyle as z, cacheStyle as X } from "../utils/cache.js";
+import { reduceDataChanges as Y } from "../utils/change.js";
+import { isCollapsed as G } from "../utils/collapsibility.js";
+import { isOverridable as x } from "../utils/data.js";
+import { updateStyle as M, markToBeDestroyed as $ } from "../utils/element.js";
+import { emit as K } from "../utils/event/index.js";
+import { idOf as u } from "../utils/id.js";
+import { parsePalette as N, assignColorByPalette as V } from "../utils/palette.js";
+import { positionOf as _ } from "../utils/position.js";
+import { print as q } from "../utils/print.js";
+import { computeElementCallbackStyle as L } from "../utils/style.js";
+import { themeOf as H } from "../utils/theme.js";
+import { subtract as J } from "../utils/vector.js";
+import { setVisibility as F } from "../utils/visibility.js";
+import { Group as Q } from "../../../g-lite/dist/index.esm.js";
+import { GraphLifeCycleEvent as S, AnimateEvent as y, ElementLifeCycleEvent as A } from "../utils/event/events.js";
+import Z from "../../../util/esm/lodash/group-by.js";
+var D = function(T, t, e, s) {
+  function a(n) {
+    return n instanceof e ? n : new e(function(i) {
+      i(n);
+    });
+  }
+  return new (e || (e = Promise))(function(n, i) {
+    function o(d) {
+      try {
+        l(s.next(d));
+      } catch (c) {
+        i(c);
+      }
+    }
+    function r(d) {
+      try {
+        l(s.throw(d));
+      } catch (c) {
+        i(c);
+      }
+    }
+    function l(d) {
+      d.done ? n(d.value) : a(d.value).then(o, r);
+    }
+    l((s = s.apply(T, t || [])).next());
+  });
+};
+class Nt {
+  constructor(t) {
+    this.elementMap = {}, this.shapeTypeMap = {}, this.paletteStyle = {}, this.defaultStyle = {}, this.stateStyle = {}, this.visibilityCache = /* @__PURE__ */ new WeakMap(), this.context = t;
+  }
+  init() {
+    this.initContainer();
+  }
+  initContainer() {
+    if (!this.container || this.container.destroyed) {
+      const { canvas: t } = this.context;
+      this.container = t.appendChild(new Q({ className: "elements" }));
+    }
+  }
+  emit(t, e) {
+    e.silence || K(this.context.graph, t);
+  }
+  forEachElementData(t) {
+    U.forEach((e) => {
+      const s = this.context.model.getElementsDataByType(e);
+      t(e, s);
+    });
+  }
+  getElementType(t, e) {
+    var s;
+    const { options: a, graph: n } = this.context, i = x(e) && ((s = a[t]) === null || s === void 0 ? void 0 : s.type) || e.type;
+    return i ? typeof i == "string" ? i : i.call(n, e) : t === "edge" ? "line" : "circle";
+  }
+  getTheme(t) {
+    return H(this.context.options)[t] || {};
+  }
+  getThemeStyle(t) {
+    return this.getTheme(t).style || {};
+  }
+  getThemeStateStyle(t, e) {
+    const { state: s = {} } = this.getTheme(t);
+    return Object.assign({}, ...e.map((a) => s[a] || {}));
+  }
+  computePaletteStyle() {
+    const { options: t } = this.context;
+    this.paletteStyle = {}, this.forEachElementData((e, s) => {
+      var a, n;
+      const i = Object.assign({}, N((a = this.getTheme(e)) === null || a === void 0 ? void 0 : a.palette), N((n = t[e]) === null || n === void 0 ? void 0 : n.palette));
+      i != null && i.field && Object.assign(this.paletteStyle, V(s, i));
+    });
+  }
+  getPaletteStyle(t, e) {
+    const s = this.paletteStyle[e];
+    return s ? t === "edge" ? { stroke: s } : { fill: s } : {};
+  }
+  /**
+   * <zh/> 计算单个元素的默认样式
+   *
+   * <en/> compute default style of single element
+   */
+  computeElementDefaultStyle(t, e) {
+    var s;
+    const { options: a } = this.context, n = ((s = a[t]) === null || s === void 0 ? void 0 : s.style) || {};
+    "transform" in n && Array.isArray(n.transform) && (n.transform = [...n.transform]), this.defaultStyle[u(e.datum)] = L(n, e);
+  }
+  computeElementsDefaultStyle(t) {
+    const { graph: e } = this.context;
+    this.forEachElementData((s, a) => {
+      const n = a.length;
+      for (let i = 0; i < n; i++) {
+        const o = a[i];
+        (t === void 0 || t.includes(u(o))) && this.computeElementDefaultStyle(s, { datum: o, graph: e });
+      }
+    });
+  }
+  getDefaultStyle(t) {
+    return this.defaultStyle[t] || {};
+  }
+  getElementState(t) {
+    try {
+      const { model: e } = this.context;
+      return e.getElementState(t);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * <zh/> 获取单个元素的单个状态的样式
+   *
+   * <en/> get single state style of single element
+   */
+  getElementStateStyle(t, e, s) {
+    var a, n;
+    const { options: i } = this.context, o = ((n = (a = i[t]) === null || a === void 0 ? void 0 : a.state) === null || n === void 0 ? void 0 : n[e]) || {};
+    return L(o, s);
+  }
+  /**
+   * <zh/> 计算单个元素的合并状态样式
+   *
+   * <en/> compute merged state style of single element
+   */
+  computeElementStatesStyle(t, e, s) {
+    this.stateStyle[u(s.datum)] = Object.assign({}, ...e.map((a) => this.getElementStateStyle(t, a, s)));
+  }
+  /**
+   * <zh/> 计算全部元素的状态样式
+   *
+   * <en/> compute state style of all elements
+   * @param ids - <zh/> 计算指定元素的状态样式 | <en/> compute state style of specified elements
+   */
+  computeElementsStatesStyle(t) {
+    const { graph: e } = this.context;
+    this.forEachElementData((s, a) => {
+      const n = a.length;
+      for (let i = 0; i < n; i++) {
+        const o = a[i];
+        if (t === void 0 || t.includes(u(o))) {
+          const r = this.getElementState(u(o));
+          this.computeElementStatesStyle(s, r, { datum: o, graph: e });
+        }
+      }
+    });
+  }
+  getStateStyle(t) {
+    return this.stateStyle[t] || {};
+  }
+  computeStyle(t, e) {
+    t && ["translate", "zIndex"].includes(t) || (this.computePaletteStyle(), this.computeElementsDefaultStyle(e), this.computeElementsStatesStyle(e));
+  }
+  getElement(t) {
+    return this.elementMap[t];
+  }
+  getNodes() {
+    return this.context.model.getNodeData().map(({ id: t }) => this.elementMap[t]);
+  }
+  getEdges() {
+    return this.context.model.getEdgeData().map((t) => this.elementMap[u(t)]);
+  }
+  getCombos() {
+    return this.context.model.getComboData().map(({ id: t }) => this.elementMap[t]);
+  }
+  getElementComputedStyle(t, e) {
+    const s = u(e), a = this.getThemeStyle(t), n = this.getPaletteStyle(t, s), i = e.style || {}, o = this.getDefaultStyle(s), r = this.getThemeStateStyle(t, this.getElementState(s)), l = this.getStateStyle(s), d = x(e) ? Object.assign({}, a, n, i, o, r, l) : Object.assign({}, i);
+    if (t === "combo") {
+      const c = this.context.model.getChildrenData(s), h = !!d.collapsed ? [] : c.map(u).filter((f) => this.getElement(f));
+      Object.assign(d, { childrenNode: h, childrenData: c });
+    }
+    return d;
+  }
+  getDrawData(t) {
+    this.init();
+    const e = this.computeChangesAndDrawData(t);
+    if (!e)
+      return null;
+    const { type: s = "draw", stage: a = s } = t;
+    return this.markDestroyElement(e.drawData), this.computeStyle(a), { type: s, stage: a, data: e };
+  }
+  /**
+   * <zh/> 开始绘制流程
+   *
+   * <en/> start render process
+   */
+  draw(t = { animation: !0 }) {
+    const e = this.getDrawData(t);
+    if (!e)
+      return;
+    const { data: { drawData: { add: s, update: a, remove: n } } } = e;
+    return this.destroyElements(n, t), this.createElements(s, t), this.updateElements(a, t), this.setAnimationTask(t, e);
+  }
+  preLayoutDraw() {
+    return D(this, arguments, void 0, function* (t = { animation: !0 }) {
+      var e, s;
+      const a = this.getDrawData(t);
+      if (!a)
+        return;
+      const { data: { drawData: n } } = a;
+      yield (s = (e = this.context.layout) === null || e === void 0 ? void 0 : e.preLayout) === null || s === void 0 ? void 0 : s.call(e, n);
+      const { add: i, update: o, remove: r } = n;
+      return this.destroyElements(r, t), this.createElements(i, t), this.updateElements(o, t), this.setAnimationTask(t, a);
+    });
+  }
+  setAnimationTask(t, e) {
+    const { animation: s, silence: a } = t, { data: { dataChanges: n, drawData: i }, stage: o, type: r } = e;
+    return this.context.animation.animate(s, a ? {} : {
+      before: () => this.emit(new S(p.BEFORE_DRAW, {
+        dataChanges: n,
+        animation: s,
+        stage: o,
+        render: r === "render"
+      }), t),
+      beforeAnimate: (l) => this.emit(new y(p.BEFORE_ANIMATE, E.DRAW, l, i), t),
+      afterAnimate: (l) => this.emit(new y(p.AFTER_ANIMATE, E.DRAW, l, i), t),
+      after: () => this.emit(new S(p.AFTER_DRAW, {
+        dataChanges: n,
+        animation: s,
+        stage: o,
+        render: r === "render",
+        firstRender: this.context.graph.rendered === !1
+      }), t)
+    });
+  }
+  computeChangesAndDrawData(t) {
+    const { model: e } = this.context, s = e.getChanges(), a = Y(s);
+    if (a.length === 0)
+      return null;
+    const { NodeAdded: n = [], NodeUpdated: i = [], NodeRemoved: o = [], EdgeAdded: r = [], EdgeUpdated: l = [], EdgeRemoved: d = [], ComboAdded: c = [], ComboUpdated: m = [], ComboRemoved: h = [] } = Z(a, (b) => b.type), f = (b, O) => {
+      const w = [];
+      return b.forEach((R) => {
+        const B = u(R.value);
+        this.getElement(B) ? w.push(R) : O.push(R);
+      }), w;
+    }, g = f(i, n), C = f(l, r), P = f(m, c), v = (b) => new Map(b.map((O) => {
+      const w = O.value;
+      return [u(w), w];
+    })), j = {
+      add: {
+        nodes: v(n),
+        edges: v(r),
+        combos: v(c)
+      },
+      update: {
+        nodes: v(g),
+        edges: v(C),
+        combos: v(P)
+      },
+      remove: {
+        nodes: v(o),
+        edges: v(d),
+        combos: v(h)
+      }
+    }, k = this.transformData(j, t);
+    return e.clearChanges(), { dataChanges: s, drawData: k };
+  }
+  transformData(t, e) {
+    const s = this.context.transform.getTransformInstance();
+    return Object.values(s).reduce((a, n) => n.beforeDraw(a, e), t);
+  }
+  createElement(t, e, s) {
+    var a;
+    const n = u(e);
+    if (this.getElement(n))
+      return;
+    const o = this.getElementType(t, e), r = this.getElementComputedStyle(t, e), l = W(t, o);
+    if (!l)
+      return q.warn(`The element ${o} of ${t} is not registered.`);
+    this.emit(new A(p.BEFORE_ELEMENT_CREATE, t, e), s);
+    const d = this.container.appendChild(new l({
+      id: n,
+      context: this.context,
+      style: r
+    }));
+    this.shapeTypeMap[n] = o, this.elementMap[n] = d;
+    const { stage: c = "enter" } = s;
+    (a = this.context.animation) === null || a === void 0 || a.add({
+      element: d,
+      elementType: t,
+      stage: c,
+      originalStyle: Object.assign({}, d.attributes),
+      updatedStyle: r
+    }, {
+      after: () => {
+        var m;
+        this.emit(new A(p.AFTER_ELEMENT_CREATE, t, e), s), (m = d.onCreate) === null || m === void 0 || m.call(d);
+      }
+    });
+  }
+  createElements(t, e) {
+    const { nodes: s, edges: a, combos: n } = t;
+    [
+      ["node", s],
+      ["combo", n],
+      ["edge", a]
+    ].forEach(([o, r]) => {
+      r.forEach((l) => this.createElement(o, l, e));
+    });
+  }
+  getUpdateStageStyle(t, e, s) {
+    const { stage: a = "update" } = s;
+    if (a === "translate")
+      if (t === "node" || t === "combo") {
+        const { style: { x: n = 0, y: i = 0, z: o = 0 } = {} } = e;
+        return { x: n, y: i, z: o };
+      } else
+        return {};
+    return this.getElementComputedStyle(t, e);
+  }
+  updateElement(t, e, s) {
+    var a;
+    const n = u(e), { stage: i = "update" } = s, o = this.getElement(n);
+    if (!o)
+      return () => null;
+    this.emit(new A(p.BEFORE_ELEMENT_UPDATE, t, e), s);
+    const r = this.getElementType(t, e), l = this.getUpdateStageStyle(t, e, s);
+    this.shapeTypeMap[n] !== r && (o.destroy(), delete this.shapeTypeMap[n], delete this.elementMap[n], this.createElement(t, e, { animation: !1, silence: !0 }));
+    const d = i !== "visibility" ? i : l.visibility === "hidden" ? "hide" : "show";
+    d === "hide" && delete l.visibility, (a = this.context.animation) === null || a === void 0 || a.add({
+      element: o,
+      elementType: t,
+      stage: d,
+      originalStyle: Object.assign({}, o.attributes),
+      updatedStyle: l
+    }, {
+      before: () => {
+        const c = this.elementMap[n];
+        i !== "collapse" && M(c, l), i === "visibility" && (z(c, "opacity") || X(c, "opacity"), this.visibilityCache.set(c, d === "show" ? "visible" : "hidden"), d === "show" && F(c, "visible"));
+      },
+      after: () => {
+        var c;
+        const m = this.elementMap[n];
+        i === "collapse" && M(m, l), d === "hide" && F(m, this.visibilityCache.get(m)), this.emit(new A(p.AFTER_ELEMENT_UPDATE, t, e), s), (c = m.onUpdate) === null || c === void 0 || c.call(m);
+      }
+    });
+  }
+  updateElements(t, e) {
+    const { nodes: s, edges: a, combos: n } = t;
+    [
+      ["node", s],
+      ["combo", n],
+      ["edge", a]
+    ].forEach(([o, r]) => {
+      r.forEach((l) => this.updateElement(o, l, e));
+    });
+  }
+  /**
+   * <zh/> 标记销毁元素
+   *
+   * <en/> mark destroy element
+   * @param data - <zh/> 绘制数据 | <en/> draw data
+   */
+  markDestroyElement(t) {
+    Object.values(t.remove).forEach((e) => {
+      e.forEach((s) => {
+        const a = u(s), n = this.getElement(a);
+        n && $(n);
+      });
+    });
+  }
+  destroyElement(t, e, s) {
+    var a;
+    const { stage: n = "exit" } = s, i = u(e), o = this.elementMap[i];
+    if (!o)
+      return () => null;
+    this.emit(new A(p.BEFORE_ELEMENT_DESTROY, t, e), s), (a = this.context.animation) === null || a === void 0 || a.add({
+      element: o,
+      elementType: t,
+      stage: n,
+      originalStyle: Object.assign({}, o.attributes),
+      updatedStyle: {}
+    }, {
+      after: () => {
+        var r;
+        this.clearElement(i), o.destroy(), (r = o.onDestroy) === null || r === void 0 || r.call(o), this.emit(new A(p.AFTER_ELEMENT_DESTROY, t, e), s);
+      }
+    });
+  }
+  destroyElements(t, e) {
+    const { nodes: s, edges: a, combos: n } = t;
+    [
+      ["combo", n],
+      ["edge", a],
+      ["node", s]
+    ].forEach(([o, r]) => {
+      r.forEach((l) => this.destroyElement(o, l, e));
+    });
+  }
+  clearElement(t) {
+    delete this.paletteStyle[t], delete this.defaultStyle[t], delete this.stateStyle[t], delete this.elementMap[t], delete this.shapeTypeMap[t];
+  }
+  /**
+   * <zh/> 将布局结果对齐到元素，避免视图偏移。会修改布局结果
+   *
+   * <en/> Align the layout result to the element to avoid view offset. Will modify the layout result
+   * @param layoutResult - <zh/> 布局结果 | <en/> layout result
+   * @param id - <zh/> 元素 ID | <en/> element ID
+   */
+  alignLayoutResultToElement(t, e) {
+    var s, a;
+    const n = (s = t.nodes) === null || s === void 0 ? void 0 : s.find((i) => u(i) === e);
+    if (n) {
+      const i = _(this.context.model.getNodeLikeDatum(e)), o = _(n), r = J(i, o);
+      (a = t.nodes) === null || a === void 0 || a.forEach((l) => {
+        var d, c, m;
+        !((d = l.style) === null || d === void 0) && d.x && (l.style.x += r[0]), !((c = l.style) === null || c === void 0) && c.y && (l.style.y += r[1]), !((m = l.style) === null || m === void 0) && m.z && (l.style.z += r[2] || 0);
+      });
+    }
+  }
+  /**
+   * <zh/> 同步布局结果
+   *
+   * <en/> Sync layout result
+   * @param id - <zh/> 元素 ID | <en/> element ID
+   * @param align - <zh/> 是否对齐 | <en/> whether to align
+   */
+  syncLayoutResult(t, e) {
+    return D(this, void 0, void 0, function* () {
+      const { layout: s, model: a } = this.context;
+      if (!s)
+        return;
+      const n = this.context.options.layout, i = (r) => Array.isArray(r) ? r.map((l) => Object.assign(Object.assign({}, l), { preLayout: !0 })) : Object.assign(Object.assign({}, r), { preLayout: !0 }), o = yield s.simulate(n ? i(n) : void 0);
+      e && this.alignLayoutResultToElement(o, t), a.updateData(o);
+    });
+  }
+  /**
+   * <zh/> 收起节点
+   *
+   * <en/> collapse node
+   * @param id - <zh/> 元素 ID | <en/> element ID
+   * @param options - <zh/> 选项 | <en/> options
+   */
+  collapseNode(t, e) {
+    return D(this, void 0, void 0, function* () {
+      var s;
+      const { animation: a, align: n } = e;
+      yield this.syncLayoutResult(t, n);
+      const i = this.computeChangesAndDrawData({ stage: "collapse", animation: a });
+      if (this.context.animation.clear(), this.computeStyle("collapse"), !i)
+        return;
+      const { drawData: o } = i, { add: r, remove: l, update: d } = o;
+      this.markDestroyElement(o);
+      const c = { animation: a, stage: "collapse", data: o };
+      this.destroyElements(l, c), this.createElements(r, c), this.updateElements(d, c), yield (s = this.context.animation.animate(a, {
+        beforeAnimate: (m) => this.emit(new y(p.BEFORE_ANIMATE, E.COLLAPSE, m, o), c),
+        afterAnimate: (m) => this.emit(new y(p.AFTER_ANIMATE, E.COLLAPSE, m, o), c)
+      }, {
+        collapse: {
+          target: t,
+          descendants: Array.from(l.nodes).map(([, m]) => u(m)),
+          position: _(d.nodes.get(t))
+        }
+      })) === null || s === void 0 ? void 0 : s.finished;
+    });
+  }
+  /**
+   * <zh/> 展开节点
+   *
+   * <en/> expand node
+   * @param id - <zh/> 元素 ID | <en/> element ID
+   * @param animation - <zh/> 是否使用动画，默认为 true | <en/> Whether to use animation, default is true
+   */
+  expandNode(t, e) {
+    return D(this, void 0, void 0, function* () {
+      var s;
+      const { model: a } = this.context, { animation: n, align: i } = e, o = _(a.getNodeData([t])[0]);
+      yield this.syncLayoutResult(t, i);
+      const r = this.computeChangesAndDrawData({ stage: "expand", animation: n });
+      if (this.createElements(r.drawData.add, { animation: !1, stage: "expand", target: t }), this.context.animation.clear(), this.computeStyle("expand"), !r)
+        return;
+      const { drawData: l } = r, { update: d, add: c } = l, m = { animation: n, stage: "expand", data: l };
+      c.edges.forEach((h) => d.edges.set(u(h), h)), c.nodes.forEach((h) => d.nodes.set(u(h), h)), this.updateElements(d, m), yield (s = this.context.animation.animate(n, {
+        beforeAnimate: (h) => this.emit(new y(p.BEFORE_ANIMATE, E.EXPAND, h, l), m),
+        afterAnimate: (h) => this.emit(new y(p.AFTER_ANIMATE, E.EXPAND, h, l), m)
+      }, {
+        expand: {
+          target: t,
+          descendants: Array.from(c.nodes).map(([, h]) => u(h)),
+          position: o
+        }
+      })) === null || s === void 0 ? void 0 : s.finished;
+    });
+  }
+  collapseCombo(t, e) {
+    return D(this, void 0, void 0, function* () {
+      var s;
+      const { model: a, element: n } = this.context;
+      if (a.getAncestorsData(t, I).some((g) => G(g)))
+        return;
+      const i = n.getElement(t), o = i.getComboPosition(Object.assign(Object.assign({}, i.attributes), { collapsed: !0 })), r = this.computeChangesAndDrawData({ stage: "collapse", animation: e });
+      if (!r)
+        return;
+      const { dataChanges: l, drawData: d } = r;
+      this.markDestroyElement(d);
+      const { update: c, remove: m } = d, h = { animation: e, stage: "collapse", data: d };
+      this.destroyElements(m, h), this.updateElements(c, h);
+      const f = (g) => Array.from(g).map(([, C]) => u(C));
+      yield (s = this.context.animation.animate(e, {
+        before: () => this.emit(new S(p.BEFORE_DRAW, { dataChanges: l, animation: e }), h),
+        beforeAnimate: (g) => this.emit(new y(p.BEFORE_ANIMATE, E.COLLAPSE, g, d), h),
+        afterAnimate: (g) => this.emit(new y(p.AFTER_ANIMATE, E.COLLAPSE, g, d), h),
+        after: () => this.emit(new S(p.AFTER_DRAW, { dataChanges: l, animation: e }), h)
+      }, {
+        collapse: {
+          target: t,
+          descendants: [...f(m.nodes), ...f(m.combos)],
+          position: o
+        }
+      })) === null || s === void 0 ? void 0 : s.finished;
+    });
+  }
+  expandCombo(t, e) {
+    return D(this, void 0, void 0, function* () {
+      var s;
+      const { model: a } = this.context, n = _(a.getComboData([t])[0]);
+      this.computeStyle("expand");
+      const i = this.computeChangesAndDrawData({ stage: "expand", animation: e });
+      if (!i)
+        return;
+      const { dataChanges: o, drawData: r } = i, { add: l, update: d } = r, c = { animation: e, stage: "expand", data: r, target: t };
+      this.createElements(l, c), this.updateElements(d, c);
+      const m = (h) => Array.from(h).map(([, f]) => u(f));
+      yield (s = this.context.animation.animate(e, {
+        before: () => this.emit(new S(p.BEFORE_DRAW, { dataChanges: o, animation: e }), c),
+        beforeAnimate: (h) => this.emit(new y(p.BEFORE_ANIMATE, E.EXPAND, h, r), c),
+        afterAnimate: (h) => this.emit(new y(p.AFTER_ANIMATE, E.EXPAND, h, r), c),
+        after: () => this.emit(new S(p.AFTER_DRAW, { dataChanges: o, animation: e }), c)
+      }, {
+        expand: {
+          target: t,
+          descendants: [...m(l.nodes), ...m(l.combos)],
+          position: n
+        }
+      })) === null || s === void 0 ? void 0 : s.finished;
+    });
+  }
+  /**
+   * <zh/> 清空所有元素
+   *
+   * <en/> clear all elements
+   */
+  clear() {
+    this.container.destroy(), this.initContainer(), this.elementMap = {}, this.shapeTypeMap = {}, this.defaultStyle = {}, this.stateStyle = {}, this.paletteStyle = {};
+  }
+  destroy() {
+    this.clear(), this.container.destroy(), this.context = {};
+  }
+}
+export {
+  Nt as ElementController
+};
+//# sourceMappingURL=element.js.map