@seed-ship/mcp-ui-solid 5.7.0 → 6.1.0

package/dist/node_modules/.pnpm/@antv_g6@5.1.0/node_modules/@antv/g6/esm/runtime/element.cjs

@@ -0,0 +1,743 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../../../@antv_g@6.3.1/node_modules/@antv/g/dist/index.esm.cjs");
+require("../constants/change.cjs");
+const animation = require("../constants/events/animation.cjs");
+require("../constants/events/canvas.cjs");
+require("../constants/events/combo.cjs");
+require("../constants/events/common.cjs");
+require("../constants/events/container.cjs");
+require("../constants/events/edge.cjs");
+const graph = require("../constants/events/graph.cjs");
+require("../constants/events/history.cjs");
+require("../constants/events/node.cjs");
+const graphlib = require("../constants/graphlib.cjs");
+require("../constants/registry.cjs");
+const element = require("../constants/element.cjs");
+const get = require("../registry/get.cjs");
+const cache = require("../utils/cache.cjs");
+const change = require("../utils/change.cjs");
+const collapsibility = require("../utils/collapsibility.cjs");
+const data = require("../utils/data.cjs");
+const element$1 = require("../utils/element.cjs");
+const index = require("../utils/event/index.cjs");
+const id = require("../utils/id.cjs");
+const palette = require("../utils/palette.cjs");
+const position = require("../utils/position.cjs");
+const print = require("../utils/print.cjs");
+const style = require("../utils/style.cjs");
+const theme = require("../utils/theme.cjs");
+const vector = require("../utils/vector.cjs");
+const visibility = require("../utils/visibility.cjs");
+const events = require("../utils/event/events.cjs");
+const groupBy = require("../../../../../../@antv_util@3.3.11/node_modules/@antv/util/esm/lodash/group-by.cjs");
+const index_esm = require("../../../../../../@antv_g-lite@2.7.0/node_modules/@antv/g-lite/dist/index.esm.cjs");
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+class ElementController {
+  constructor(context) {
+    this.elementMap = {};
+    this.shapeTypeMap = {};
+    this.paletteStyle = {};
+    this.defaultStyle = {};
+    this.stateStyle = {};
+    this.visibilityCache = /* @__PURE__ */ new WeakMap();
+    this.context = context;
+  }
+  init() {
+    this.initContainer();
+  }
+  initContainer() {
+    if (!this.container || this.container.destroyed) {
+      const { canvas } = this.context;
+      this.container = canvas.appendChild(new index_esm.Group({ className: "elements" }));
+    }
+  }
+  emit(event, context) {
+    if (context.silence)
+      return;
+    index.emit(this.context.graph, event);
+  }
+  forEachElementData(callback) {
+    element.ELEMENT_TYPES.forEach((elementType) => {
+      const elementData = this.context.model.getElementsDataByType(elementType);
+      callback(elementType, elementData);
+    });
+  }
+  getElementType(elementType, datum) {
+    var _a;
+    const { options, graph: graph2 } = this.context;
+    const userDefinedType = data.isOverridable(datum) ? ((_a = options[elementType]) === null || _a === void 0 ? void 0 : _a.type) || datum.type : datum.type;
+    if (!userDefinedType) {
+      if (elementType === "edge")
+        return "line";
+      else
+        return "circle";
+    }
+    if (typeof userDefinedType === "string")
+      return userDefinedType;
+    return userDefinedType.call(graph2, datum);
+  }
+  getTheme(elementType) {
+    return theme.themeOf(this.context.options)[elementType] || {};
+  }
+  getThemeStyle(elementType) {
+    return this.getTheme(elementType).style || {};
+  }
+  getThemeStateStyle(elementType, states) {
+    const { state = {} } = this.getTheme(elementType);
+    return Object.assign({}, ...states.map((name) => state[name] || {}));
+  }
+  computePaletteStyle() {
+    const { options } = this.context;
+    this.paletteStyle = {};
+    this.forEachElementData((elementType, elementData) => {
+      var _a, _b;
+      const palette$1 = Object.assign({}, palette.parsePalette((_a = this.getTheme(elementType)) === null || _a === void 0 ? void 0 : _a.palette), palette.parsePalette((_b = options[elementType]) === null || _b === void 0 ? void 0 : _b.palette));
+      if (palette$1 === null || palette$1 === void 0 ? void 0 : palette$1.field) {
+        Object.assign(this.paletteStyle, palette.assignColorByPalette(elementData, palette$1));
+      }
+    });
+  }
+  getPaletteStyle(elementType, id2) {
+    const color = this.paletteStyle[id2];
+    if (!color)
+      return {};
+    if (elementType === "edge")
+      return { stroke: color };
+    return { fill: color };
+  }
+  /**
+   * <zh/> 计算单个元素的默认样式
+   *
+   * <en/> compute default style of single element
+   */
+  computeElementDefaultStyle(elementType, context) {
+    var _a;
+    const { options } = this.context;
+    const defaultStyle = ((_a = options[elementType]) === null || _a === void 0 ? void 0 : _a.style) || {};
+    if ("transform" in defaultStyle && Array.isArray(defaultStyle.transform)) {
+      defaultStyle.transform = [...defaultStyle.transform];
+    }
+    this.defaultStyle[id.idOf(context.datum)] = style.computeElementCallbackStyle(defaultStyle, context);
+  }
+  computeElementsDefaultStyle(ids) {
+    const { graph: graph2 } = this.context;
+    this.forEachElementData((elementType, elementData) => {
+      const length = elementData.length;
+      for (let i = 0; i < length; i++) {
+        const datum = elementData[i];
+        if (ids === void 0 || ids.includes(id.idOf(datum))) {
+          this.computeElementDefaultStyle(elementType, { datum, graph: graph2 });
+        }
+      }
+    });
+  }
+  getDefaultStyle(id2) {
+    return this.defaultStyle[id2] || {};
+  }
+  getElementState(id2) {
+    try {
+      const { model } = this.context;
+      return model.getElementState(id2);
+    } catch (_a) {
+      return [];
+    }
+  }
+  /**
+   * <zh/> 获取单个元素的单个状态的样式
+   *
+   * <en/> get single state style of single element
+   */
+  getElementStateStyle(elementType, state, context) {
+    var _a, _b;
+    const { options } = this.context;
+    const stateStyle = ((_b = (_a = options[elementType]) === null || _a === void 0 ? void 0 : _a.state) === null || _b === void 0 ? void 0 : _b[state]) || {};
+    return style.computeElementCallbackStyle(stateStyle, context);
+  }
+  /**
+   * <zh/> 计算单个元素的合并状态样式
+   *
+   * <en/> compute merged state style of single element
+   */
+  computeElementStatesStyle(elementType, states, context) {
+    this.stateStyle[id.idOf(context.datum)] = Object.assign({}, ...states.map((state) => this.getElementStateStyle(elementType, state, context)));
+  }
+  /**
+   * <zh/> 计算全部元素的状态样式
+   *
+   * <en/> compute state style of all elements
+   * @param ids - <zh/> 计算指定元素的状态样式 | <en/> compute state style of specified elements
+   */
+  computeElementsStatesStyle(ids) {
+    const { graph: graph2 } = this.context;
+    this.forEachElementData((elementType, elementData) => {
+      const length = elementData.length;
+      for (let i = 0; i < length; i++) {
+        const datum = elementData[i];
+        if (ids === void 0 || ids.includes(id.idOf(datum))) {
+          const states = this.getElementState(id.idOf(datum));
+          this.computeElementStatesStyle(elementType, states, { datum, graph: graph2 });
+        }
+      }
+    });
+  }
+  getStateStyle(id2) {
+    return this.stateStyle[id2] || {};
+  }
+  computeStyle(stage, ids) {
+    const skip = ["translate", "zIndex"];
+    if (stage && skip.includes(stage))
+      return;
+    this.computePaletteStyle();
+    this.computeElementsDefaultStyle(ids);
+    this.computeElementsStatesStyle(ids);
+  }
+  getElement(id2) {
+    return this.elementMap[id2];
+  }
+  getNodes() {
+    return this.context.model.getNodeData().map(({ id: id2 }) => this.elementMap[id2]);
+  }
+  getEdges() {
+    return this.context.model.getEdgeData().map((edge) => this.elementMap[id.idOf(edge)]);
+  }
+  getCombos() {
+    return this.context.model.getComboData().map(({ id: id2 }) => this.elementMap[id2]);
+  }
+  getElementComputedStyle(elementType, datum) {
+    const id$1 = id.idOf(datum);
+    const themeStyle = this.getThemeStyle(elementType);
+    const paletteStyle = this.getPaletteStyle(elementType, id$1);
+    const dataStyle = datum.style || {};
+    const defaultStyle = this.getDefaultStyle(id$1);
+    const themeStateStyle = this.getThemeStateStyle(elementType, this.getElementState(id$1));
+    const stateStyle = this.getStateStyle(id$1);
+    const style2 = data.isOverridable(datum) ? Object.assign({}, themeStyle, paletteStyle, dataStyle, defaultStyle, themeStateStyle, stateStyle) : Object.assign({}, dataStyle);
+    if (elementType === "combo") {
+      const childrenData = this.context.model.getChildrenData(id$1);
+      const isCollapsed = !!style2.collapsed;
+      const childrenNode = isCollapsed ? [] : childrenData.map(id.idOf).filter((id2) => this.getElement(id2));
+      Object.assign(style2, { childrenNode, childrenData });
+    }
+    return style2;
+  }
+  getDrawData(context) {
+    this.init();
+    const data2 = this.computeChangesAndDrawData(context);
+    if (!data2)
+      return null;
+    const { type = "draw", stage = type } = context;
+    this.markDestroyElement(data2.drawData);
+    this.computeStyle(stage);
+    return { type, stage, data: data2 };
+  }
+  /**
+   * <zh/> 开始绘制流程
+   *
+   * <en/> start render process
+   */
+  draw(context = { animation: true }) {
+    const drawData = this.getDrawData(context);
+    if (!drawData)
+      return;
+    const { data: { drawData: { add, update, remove } } } = drawData;
+    this.destroyElements(remove, context);
+    this.createElements(add, context);
+    this.updateElements(update, context);
+    return this.setAnimationTask(context, drawData);
+  }
+  preLayoutDraw() {
+    return __awaiter(this, arguments, void 0, function* (context = { animation: true }) {
+      var _a, _b;
+      const preResult = this.getDrawData(context);
+      if (!preResult)
+        return;
+      const { data: { drawData } } = preResult;
+      yield (_b = (_a = this.context.layout) === null || _a === void 0 ? void 0 : _a.preLayout) === null || _b === void 0 ? void 0 : _b.call(_a, drawData);
+      const { add, update, remove } = drawData;
+      this.destroyElements(remove, context);
+      this.createElements(add, context);
+      this.updateElements(update, context);
+      return this.setAnimationTask(context, preResult);
+    });
+  }
+  setAnimationTask(context, data2) {
+    const { animation: animation$1, silence } = context;
+    const { data: { dataChanges, drawData }, stage, type } = data2;
+    return this.context.animation.animate(animation$1, silence ? {} : {
+      before: () => this.emit(new events.GraphLifeCycleEvent(graph.GraphEvent.BEFORE_DRAW, {
+        dataChanges,
+        animation: animation$1,
+        stage,
+        render: type === "render"
+      }), context),
+      beforeAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.BEFORE_ANIMATE, animation.AnimationType.DRAW, animation$12, drawData), context),
+      afterAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.AFTER_ANIMATE, animation.AnimationType.DRAW, animation$12, drawData), context),
+      after: () => this.emit(new events.GraphLifeCycleEvent(graph.GraphEvent.AFTER_DRAW, {
+        dataChanges,
+        animation: animation$1,
+        stage,
+        render: type === "render",
+        firstRender: this.context.graph.rendered === false
+      }), context)
+    });
+  }
+  computeChangesAndDrawData(context) {
+    const { model } = this.context;
+    const dataChanges = model.getChanges();
+    const tasks = change.reduceDataChanges(dataChanges);
+    if (tasks.length === 0)
+      return null;
+    const { NodeAdded = [], NodeUpdated = [], NodeRemoved = [], EdgeAdded = [], EdgeUpdated = [], EdgeRemoved = [], ComboAdded = [], ComboUpdated = [], ComboRemoved = [] } = groupBy(tasks, (change2) => change2.type);
+    const moveToAddedIfUnrendered = (updated, added) => {
+      const keptUpdates = [];
+      updated.forEach((change2) => {
+        const id$1 = id.idOf(change2.value);
+        if (!this.getElement(id$1)) {
+          added.push(change2);
+        } else {
+          keptUpdates.push(change2);
+        }
+      });
+      return keptUpdates;
+    };
+    const finalNodeUpdated = moveToAddedIfUnrendered(NodeUpdated, NodeAdded);
+    const finalEdgeUpdated = moveToAddedIfUnrendered(EdgeUpdated, EdgeAdded);
+    const finalComboUpdated = moveToAddedIfUnrendered(ComboUpdated, ComboAdded);
+    const dataOf = (data2) => new Map(data2.map((datum) => {
+      const data3 = datum.value;
+      return [id.idOf(data3), data3];
+    }));
+    const input = {
+      add: {
+        nodes: dataOf(NodeAdded),
+        edges: dataOf(EdgeAdded),
+        combos: dataOf(ComboAdded)
+      },
+      update: {
+        nodes: dataOf(finalNodeUpdated),
+        edges: dataOf(finalEdgeUpdated),
+        combos: dataOf(finalComboUpdated)
+      },
+      remove: {
+        nodes: dataOf(NodeRemoved),
+        edges: dataOf(EdgeRemoved),
+        combos: dataOf(ComboRemoved)
+      }
+    };
+    const drawData = this.transformData(input, context);
+    model.clearChanges();
+    return { dataChanges, drawData };
+  }
+  transformData(input, context) {
+    const transforms = this.context.transform.getTransformInstance();
+    return Object.values(transforms).reduce((data2, transform) => transform.beforeDraw(data2, context), input);
+  }
+  createElement(elementType, datum, context) {
+    var _a;
+    const id$1 = id.idOf(datum);
+    const currentElement = this.getElement(id$1);
+    if (currentElement)
+      return;
+    const type = this.getElementType(elementType, datum);
+    const style2 = this.getElementComputedStyle(elementType, datum);
+    const Ctor = get.getExtension(elementType, type);
+    if (!Ctor)
+      return print.print.warn(`The element ${type} of ${elementType} is not registered.`);
+    this.emit(new events.ElementLifeCycleEvent(graph.GraphEvent.BEFORE_ELEMENT_CREATE, elementType, datum), context);
+    const element2 = this.container.appendChild(new Ctor({
+      id: id$1,
+      context: this.context,
+      style: style2
+    }));
+    this.shapeTypeMap[id$1] = type;
+    this.elementMap[id$1] = element2;
+    const { stage = "enter" } = context;
+    (_a = this.context.animation) === null || _a === void 0 ? void 0 : _a.add({
+      element: element2,
+      elementType,
+      stage,
+      originalStyle: Object.assign({}, element2.attributes),
+      updatedStyle: style2
+    }, {
+      after: () => {
+        var _a2;
+        this.emit(new events.ElementLifeCycleEvent(graph.GraphEvent.AFTER_ELEMENT_CREATE, elementType, datum), context);
+        (_a2 = element2.onCreate) === null || _a2 === void 0 ? void 0 : _a2.call(element2);
+      }
+    });
+  }
+  createElements(data2, context) {
+    const { nodes, edges, combos } = data2;
+    const iteration = [
+      ["node", nodes],
+      ["combo", combos],
+      ["edge", edges]
+    ];
+    iteration.forEach(([elementType, elementData]) => {
+      elementData.forEach((datum) => this.createElement(elementType, datum, context));
+    });
+  }
+  getUpdateStageStyle(elementType, datum, context) {
+    const { stage = "update" } = context;
+    if (stage === "translate") {
+      if (elementType === "node" || elementType === "combo") {
+        const { style: { x = 0, y = 0, z = 0 } = {} } = datum;
+        return { x, y, z };
+      } else
+        return {};
+    }
+    return this.getElementComputedStyle(elementType, datum);
+  }
+  updateElement(elementType, datum, context) {
+    var _a;
+    const id$1 = id.idOf(datum);
+    const { stage = "update" } = context;
+    const element2 = this.getElement(id$1);
+    if (!element2)
+      return () => null;
+    this.emit(new events.ElementLifeCycleEvent(graph.GraphEvent.BEFORE_ELEMENT_UPDATE, elementType, datum), context);
+    const type = this.getElementType(elementType, datum);
+    const style2 = this.getUpdateStageStyle(elementType, datum, context);
+    if (this.shapeTypeMap[id$1] !== type) {
+      element2.destroy();
+      delete this.shapeTypeMap[id$1];
+      delete this.elementMap[id$1];
+      this.createElement(elementType, datum, { animation: false, silence: true });
+    }
+    const exactStage = stage !== "visibility" ? stage : style2.visibility === "hidden" ? "hide" : "show";
+    if (exactStage === "hide")
+      delete style2["visibility"];
+    (_a = this.context.animation) === null || _a === void 0 ? void 0 : _a.add({
+      element: element2,
+      elementType,
+      stage: exactStage,
+      originalStyle: Object.assign({}, element2.attributes),
+      updatedStyle: style2
+    }, {
+      before: () => {
+        const element3 = this.elementMap[id$1];
+        if (stage !== "collapse")
+          element$1.updateStyle(element3, style2);
+        if (stage === "visibility") {
+          if (!cache.hasCachedStyle(element3, "opacity"))
+            cache.cacheStyle(element3, "opacity");
+          this.visibilityCache.set(element3, exactStage === "show" ? "visible" : "hidden");
+          if (exactStage === "show")
+            visibility.setVisibility(element3, "visible");
+        }
+      },
+      after: () => {
+        var _a2;
+        const element3 = this.elementMap[id$1];
+        if (stage === "collapse")
+          element$1.updateStyle(element3, style2);
+        if (exactStage === "hide")
+          visibility.setVisibility(element3, this.visibilityCache.get(element3));
+        this.emit(new events.ElementLifeCycleEvent(graph.GraphEvent.AFTER_ELEMENT_UPDATE, elementType, datum), context);
+        (_a2 = element3.onUpdate) === null || _a2 === void 0 ? void 0 : _a2.call(element3);
+      }
+    });
+  }
+  updateElements(data2, context) {
+    const { nodes, edges, combos } = data2;
+    const iteration = [
+      ["node", nodes],
+      ["combo", combos],
+      ["edge", edges]
+    ];
+    iteration.forEach(([elementType, elementData]) => {
+      elementData.forEach((datum) => this.updateElement(elementType, datum, context));
+    });
+  }
+  /**
+   * <zh/> 标记销毁元素
+   *
+   * <en/> mark destroy element
+   * @param data - <zh/> 绘制数据 | <en/> draw data
+   */
+  markDestroyElement(data2) {
+    Object.values(data2.remove).forEach((elementData) => {
+      elementData.forEach((datum) => {
+        const id$1 = id.idOf(datum);
+        const element2 = this.getElement(id$1);
+        if (element2)
+          element$1.markToBeDestroyed(element2);
+      });
+    });
+  }
+  destroyElement(elementType, datum, context) {
+    var _a;
+    const { stage = "exit" } = context;
+    const id$1 = id.idOf(datum);
+    const element2 = this.elementMap[id$1];
+    if (!element2)
+      return () => null;
+    this.emit(new events.ElementLifeCycleEvent(graph.GraphEvent.BEFORE_ELEMENT_DESTROY, elementType, datum), context);
+    (_a = this.context.animation) === null || _a === void 0 ? void 0 : _a.add({
+      element: element2,
+      elementType,
+      stage,
+      originalStyle: Object.assign({}, element2.attributes),
+      updatedStyle: {}
+    }, {
+      after: () => {
+        var _a2;
+        this.clearElement(id$1);
+        element2.destroy();
+        (_a2 = element2.onDestroy) === null || _a2 === void 0 ? void 0 : _a2.call(element2);
+        this.emit(new events.ElementLifeCycleEvent(graph.GraphEvent.AFTER_ELEMENT_DESTROY, elementType, datum), context);
+      }
+    });
+  }
+  destroyElements(data2, context) {
+    const { nodes, edges, combos } = data2;
+    const iteration = [
+      ["combo", combos],
+      ["edge", edges],
+      ["node", nodes]
+    ];
+    iteration.forEach(([elementType, elementData]) => {
+      elementData.forEach((datum) => this.destroyElement(elementType, datum, context));
+    });
+  }
+  clearElement(id2) {
+    delete this.paletteStyle[id2];
+    delete this.defaultStyle[id2];
+    delete this.stateStyle[id2];
+    delete this.elementMap[id2];
+    delete this.shapeTypeMap[id2];
+  }
+  /**
+   * <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(layoutResult, id$1) {
+    var _a, _b;
+    const target = (_a = layoutResult.nodes) === null || _a === void 0 ? void 0 : _a.find((node) => id.idOf(node) === id$1);
+    if (target) {
+      const originalPosition = position.positionOf(this.context.model.getNodeLikeDatum(id$1));
+      const modifiedPosition = position.positionOf(target);
+      const delta = vector.subtract(originalPosition, modifiedPosition);
+      (_b = layoutResult.nodes) === null || _b === void 0 ? void 0 : _b.forEach((node) => {
+        var _a2, _b2, _c;
+        if ((_a2 = node.style) === null || _a2 === void 0 ? void 0 : _a2.x)
+          node.style.x += delta[0];
+        if ((_b2 = node.style) === null || _b2 === void 0 ? void 0 : _b2.y)
+          node.style.y += delta[1];
+        if ((_c = node.style) === null || _c === void 0 ? void 0 : _c.z)
+          node.style.z += delta[2] || 0;
+      });
+    }
+  }
+  /**
+   * <zh/> 同步布局结果
+   *
+   * <en/> Sync layout result
+   * @param id - <zh/> 元素 ID | <en/> element ID
+   * @param align - <zh/> 是否对齐 | <en/> whether to align
+   */
+  syncLayoutResult(id2, align) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const { layout, model } = this.context;
+      if (!layout)
+        return;
+      const layoutOptions = this.context.options.layout;
+      const forcePreLayout = (opts) => {
+        if (Array.isArray(opts)) {
+          return opts.map((o) => Object.assign(Object.assign({}, o), { preLayout: true }));
+        }
+        return Object.assign(Object.assign({}, opts), { preLayout: true });
+      };
+      const layoutResult = yield layout.simulate(layoutOptions ? forcePreLayout(layoutOptions) : void 0);
+      if (align)
+        this.alignLayoutResultToElement(layoutResult, id2);
+      model.updateData(layoutResult);
+    });
+  }
+  /**
+   * <zh/> 收起节点
+   *
+   * <en/> collapse node
+   * @param id - <zh/> 元素 ID | <en/> element ID
+   * @param options - <zh/> 选项 | <en/> options
+   */
+  collapseNode(id$1, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const { animation: animation$1, align } = options;
+      yield this.syncLayoutResult(id$1, align);
+      const data2 = this.computeChangesAndDrawData({ stage: "collapse", animation: animation$1 });
+      this.context.animation.clear();
+      this.computeStyle("collapse");
+      if (!data2)
+        return;
+      const { drawData } = data2;
+      const { add, remove, update } = drawData;
+      this.markDestroyElement(drawData);
+      const context = { animation: animation$1, stage: "collapse", data: drawData };
+      this.destroyElements(remove, context);
+      this.createElements(add, context);
+      this.updateElements(update, context);
+      yield (_a = this.context.animation.animate(animation$1, {
+        beforeAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.BEFORE_ANIMATE, animation.AnimationType.COLLAPSE, animation$12, drawData), context),
+        afterAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.AFTER_ANIMATE, animation.AnimationType.COLLAPSE, animation$12, drawData), context)
+      }, {
+        collapse: {
+          target: id$1,
+          descendants: Array.from(remove.nodes).map(([, node]) => id.idOf(node)),
+          position: position.positionOf(update.nodes.get(id$1))
+        }
+      })) === null || _a === void 0 ? void 0 : _a.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(id$1, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const { model } = this.context;
+      const { animation: animation$1, align } = options;
+      const position$1 = position.positionOf(model.getNodeData([id$1])[0]);
+      yield this.syncLayoutResult(id$1, align);
+      const data2 = this.computeChangesAndDrawData({ stage: "expand", animation: animation$1 });
+      this.createElements(data2.drawData.add, { animation: false, stage: "expand", target: id$1 });
+      this.context.animation.clear();
+      this.computeStyle("expand");
+      if (!data2)
+        return;
+      const { drawData } = data2;
+      const { update, add } = drawData;
+      const context = { animation: animation$1, stage: "expand", data: drawData };
+      add.edges.forEach((edge) => update.edges.set(id.idOf(edge), edge));
+      add.nodes.forEach((node) => update.nodes.set(id.idOf(node), node));
+      this.updateElements(update, context);
+      yield (_a = this.context.animation.animate(animation$1, {
+        beforeAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.BEFORE_ANIMATE, animation.AnimationType.EXPAND, animation$12, drawData), context),
+        afterAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.AFTER_ANIMATE, animation.AnimationType.EXPAND, animation$12, drawData), context)
+      }, {
+        expand: {
+          target: id$1,
+          descendants: Array.from(add.nodes).map(([, node]) => id.idOf(node)),
+          position: position$1
+        }
+      })) === null || _a === void 0 ? void 0 : _a.finished;
+    });
+  }
+  collapseCombo(id$1, animation$1) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const { model, element: element2 } = this.context;
+      if (model.getAncestorsData(id$1, graphlib.COMBO_KEY).some((datum) => collapsibility.isCollapsed(datum)))
+        return;
+      const combo = element2.getElement(id$1);
+      const position2 = combo.getComboPosition(Object.assign(Object.assign({}, combo.attributes), { collapsed: true }));
+      const data2 = this.computeChangesAndDrawData({ stage: "collapse", animation: animation$1 });
+      if (!data2)
+        return;
+      const { dataChanges, drawData } = data2;
+      this.markDestroyElement(drawData);
+      const { update, remove } = drawData;
+      const context = { animation: animation$1, stage: "collapse", data: drawData };
+      this.destroyElements(remove, context);
+      this.updateElements(update, context);
+      const idsOf = (data3) => Array.from(data3).map(([, node]) => id.idOf(node));
+      yield (_a = this.context.animation.animate(animation$1, {
+        before: () => this.emit(new events.GraphLifeCycleEvent(graph.GraphEvent.BEFORE_DRAW, { dataChanges, animation: animation$1 }), context),
+        beforeAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.BEFORE_ANIMATE, animation.AnimationType.COLLAPSE, animation$12, drawData), context),
+        afterAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.AFTER_ANIMATE, animation.AnimationType.COLLAPSE, animation$12, drawData), context),
+        after: () => this.emit(new events.GraphLifeCycleEvent(graph.GraphEvent.AFTER_DRAW, { dataChanges, animation: animation$1 }), context)
+      }, {
+        collapse: {
+          target: id$1,
+          descendants: [...idsOf(remove.nodes), ...idsOf(remove.combos)],
+          position: position2
+        }
+      })) === null || _a === void 0 ? void 0 : _a.finished;
+    });
+  }
+  expandCombo(id$1, animation$1) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const { model } = this.context;
+      const position$1 = position.positionOf(model.getComboData([id$1])[0]);
+      this.computeStyle("expand");
+      const data2 = this.computeChangesAndDrawData({ stage: "expand", animation: animation$1 });
+      if (!data2)
+        return;
+      const { dataChanges, drawData } = data2;
+      const { add, update } = drawData;
+      const context = { animation: animation$1, stage: "expand", data: drawData, target: id$1 };
+      this.createElements(add, context);
+      this.updateElements(update, context);
+      const idsOf = (data3) => Array.from(data3).map(([, node]) => id.idOf(node));
+      yield (_a = this.context.animation.animate(animation$1, {
+        before: () => this.emit(new events.GraphLifeCycleEvent(graph.GraphEvent.BEFORE_DRAW, { dataChanges, animation: animation$1 }), context),
+        beforeAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.BEFORE_ANIMATE, animation.AnimationType.EXPAND, animation$12, drawData), context),
+        afterAnimate: (animation$12) => this.emit(new events.AnimateEvent(graph.GraphEvent.AFTER_ANIMATE, animation.AnimationType.EXPAND, animation$12, drawData), context),
+        after: () => this.emit(new events.GraphLifeCycleEvent(graph.GraphEvent.AFTER_DRAW, { dataChanges, animation: animation$1 }), context)
+      }, {
+        expand: {
+          target: id$1,
+          descendants: [...idsOf(add.nodes), ...idsOf(add.combos)],
+          position: position$1
+        }
+      })) === null || _a === void 0 ? void 0 : _a.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 = {};
+  }
+}
+exports.ElementController = ElementController;
+//# sourceMappingURL=element.cjs.map