build-dxf 0.0.19 → 0.0.20-10

package/src/pages/Editor.vue.d.ts

@@ -1,2 +1,4 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    dom: HTMLDivElement;
+}, HTMLDivElement>;
 export default _default;

package/src/selectLocalFile.js

@@ -1,5 +1,206 @@
-import { getCurrentInstance, inject, ref, computed, unref, shallowRef, watchEffect, readonly, getCurrentScope, onScopeDispose, onMounted, nextTick, isRef, warn, provide, defineComponent, createElementBlock, openBlock, mergeProps, renderSlot, createElementVNode, watch, toRef, onUnmounted, useSlots, Text, createBlock, resolveDynamicComponent, withCtx, createCommentVNode, Fragment, normalizeClass, reactive, toRaw, withDirectives, withModifiers, vModelCheckbox, createTextVNode, toDisplayString, normalizeStyle, toRefs } from "vue";
 import * as THREE from "three";
+import { Vector2 } from "three";
+import { CSS3DObject, CSS3DSprite, CSS3DRenderer } from "three/addons/renderers/CSS3DRenderer.js";
+import { CSS2DObject, CSS2DRenderer } from "three/addons/renderers/CSS2DRenderer.js";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import * as TWEEN from "@tweenjs/tween.js";
+import { C as Component, P as Point, V as Variable } from "./build.js";
+import { getCurrentInstance, inject, ref, computed, unref, shallowRef, watchEffect, readonly, getCurrentScope, onScopeDispose, onMounted, nextTick, isRef, warn, provide, defineComponent, createElementBlock, openBlock, mergeProps, renderSlot, createElementVNode, watch, toRef, onUnmounted, useSlots, Text, createBlock, resolveDynamicComponent, withCtx, createCommentVNode, Fragment, normalizeClass, reactive, toRaw, withDirectives, withModifiers, vModelCheckbox, createTextVNode, toDisplayString, normalizeStyle, toRefs } from "vue";
+THREE.Object3D.DEFAULT_UP = new THREE.Vector3(0, 0, 1);
+class Renderer extends Component {
+  static name = "Renderer";
+  static CSS2DObject = CSS2DObject;
+  static CSS3DObject = CSS3DObject;
+  static CSS3DSprite = CSS3DSprite;
+  static Group = THREE.Group;
+  static Object3D = THREE.Object3D;
+  static Mesh = THREE.Mesh;
+  static Line = THREE.Line;
+  static LineSegments = THREE.LineSegments;
+  static Points = THREE.Points;
+  scene;
+  camera;
+  renderer;
+  orbitControls;
+  resizeObserver;
+  description;
+  html2DRenderer;
+  html3DRenderer;
+  container = new THREE.Group();
+  onUpdate;
+  onResize;
+  tweenTaskList = [];
+  constructor(description) {
+    super();
+    this.description = description;
+    const {
+      scene = new THREE.Scene(),
+      camera = new THREE.PerspectiveCamera(45, 1, 0.01, 1e3)
+    } = description;
+    this.camera = camera;
+    this.scene = scene;
+    scene.add(this.container);
+    this.renderer = new THREE.WebGLRenderer({
+      canvas: this.description.canvas,
+      antialias: true
+    });
+    this.renderer.setPixelRatio(window.devicePixelRatio);
+    if (description.htmlRenderer) {
+      if (description.htmlRenderer["2d"]) {
+        this.html2DRenderer = new CSS2DRenderer();
+        Object.assign(this.html2DRenderer.domElement.style, { position: "absolute", left: "0px", top: "0px" });
+        description.htmlRenderer["2d"].appendChild(this.html2DRenderer.domElement);
+      }
+      if (description.htmlRenderer["3d"]) {
+        this.html3DRenderer = new CSS3DRenderer();
+        Object.assign(this.html3DRenderer.domElement.style, { position: "absolute", left: "0px", top: "0px" });
+        description.htmlRenderer["3d"].appendChild(this.html3DRenderer.domElement);
+      }
+    }
+    if (description.orbitControls) {
+      this.orbitControls = new OrbitControls(this.camera, description.orbitControls.domElement);
+      Object.assign(this.orbitControls, description.orbitControls);
+    }
+    if (this.description.resizeObserver) {
+      const dom = this.description.resizeObserver;
+      this.resizeObserver = new ResizeObserver(() => {
+        const camera2 = this.camera;
+        const { width, height } = dom.getBoundingClientRect();
+        this.renderer.setSize(width, height);
+        if (this.html2DRenderer) this.html2DRenderer.setSize(width, height);
+        if (this.html3DRenderer) this.html3DRenderer.setSize(width, height);
+        if (this.orbitControls) {
+          if (camera2 instanceof THREE.PerspectiveCamera) {
+            camera2.aspect = width / height;
+          } else if (camera2 instanceof THREE.OrthographicCamera) {
+            camera2.left = -width * 0.5;
+            camera2.right = width * 0.5;
+            camera2.top = height * 0.5;
+            camera2.bottom = -height * 0.5;
+          }
+          camera2.updateProjectionMatrix();
+        }
+        this.onResize && this.onResize(width, height);
+        this.dispatchEvent({ type: "resize", width, height });
+      });
+      this.resizeObserver.observe(dom);
+    }
+    this.renderer.setAnimationLoop(() => {
+      if (this.html2DRenderer) this.html2DRenderer.render(this.scene, this.camera);
+      if (this.html3DRenderer) this.html3DRenderer.render(this.scene, this.camera);
+      this.renderer.render(this.scene, this.camera);
+      if (this.orbitControls && this.orbitControls.enabled) this.orbitControls.update();
+      this.tweenTaskList.forEach((tween) => tween.update());
+      this.onUpdate && this.onUpdate();
+      this.parent?.components.forEach((c) => c.dispatchEvent({ type: "update" }));
+    });
+    this.scene.add(new THREE.AmbientLight(16777215, 0.5));
+    this.scene.background = new THREE.Color(3355443);
+    const directLight = new THREE.DirectionalLight(16777215, 4);
+    directLight.position.set(100, -100, 100);
+    this.scene.add(directLight);
+  }
+  /**
+   * 世界坐标转屏幕坐标
+   * @param worldPosition 
+   * @param camera 
+   * @param renderer 
+   * @returns 
+   */
+  worldToScreenPosition(worldPosition) {
+    const vector = new THREE.Vector3();
+    vector.copy(worldPosition);
+    vector.project(this.camera);
+    const x = (vector.x * 0.5 + 0.5) * this.renderer.domElement.clientWidth;
+    const z = (-vector.z * 0.5 + 0.5) * this.renderer.domElement.clientHeight;
+    return new THREE.Vector2(x, z);
+  }
+  cameraPositionRecord = [];
+  /**
+   * 相机
+   * @param position 
+   * @param lookAt 
+   * @param onEnd 
+   */
+  cameraTo(position, lookAt, onEnd) {
+    this.cameraPositionRecord.push([
+      this.camera.position.clone(),
+      this.camera.quaternion.clone()
+    ]);
+    const tween = new TWEEN.Tween(this.camera.position);
+    tween.to(position, 600);
+    tween.start();
+    tween.onUpdate(() => {
+      this.camera.lookAt(lookAt);
+    });
+    tween.onComplete(() => {
+      const i = this.tweenTaskList.indexOf(tween);
+      this.tweenTaskList.splice(i, 1);
+      onEnd && onEnd();
+    });
+    this.tweenTaskList.push(tween);
+  }
+  cameraBack() {
+    if (this.cameraPositionRecord.length) {
+      const [pos, quat] = this.cameraPositionRecord.pop();
+      this.camera.position.copy(pos);
+      this.camera.quaternion.copy(quat);
+    }
+  }
+  /**
+   * 创建点
+   * @param pos 
+   */
+  createPointMesh(pos, size = 0.02, parameters, parent = this.container) {
+    const box = new THREE.Mesh(
+      new THREE.SphereGeometry(size),
+      new THREE.MeshBasicMaterial(parameters)
+    );
+    if (pos instanceof Point) box.position.set(pos.x, pos.y, 0);
+    else if (pos instanceof THREE.Vector3) box.position.copy(pos);
+    parent.add(box);
+    return box;
+  }
+  /**
+   * 创建文本
+   * @param text 
+   * @param pos 
+   * @param style 
+   */
+  createText(text, pos, style, parent = this.container) {
+    const div = document.createElement("div");
+    div.innerHTML = text;
+    div.style.pointerEvents = "none";
+    Object.assign(div.style, { fontSize: "10px", color: "#ffffff", ...style });
+    const css2DObject = new Renderer.CSS2DObject(div);
+    if (pos instanceof Point) css2DObject.position.set(pos.x, pos.y, 0);
+    else if (pos instanceof THREE.Vector3) css2DObject.position.copy(pos);
+    parent.add(css2DObject);
+    return css2DObject;
+  }
+  /**
+   * 创建几何缓冲区
+   * @param map 
+   * @param count 
+   */
+  createLineSegments(map, count, parameters, parent = this.container) {
+    const geometry = new THREE.BufferGeometry();
+    Object.keys(map).forEach((key) => {
+      const value = map[key];
+      geometry.setAttribute(key, new THREE.BufferAttribute(new Float32Array(value), value.length / count));
+    });
+    const lineSegmentList = new THREE.LineSegments(geometry, new THREE.LineBasicMaterial({ ...parameters }));
+    parent.add(lineSegmentList);
+    return lineSegmentList;
+  }
+  destroy() {
+    if (this.resizeObserver) {
+      this.renderer.dispose();
+      this.resizeObserver.disconnect();
+      this.resizeObserver = void 0;
+    }
+  }
+}
 const configProviderContextKey = Symbol();
 const defaultNamespace = "el";
 const statePrefix = "is-";
@@ -3667,6 +3868,225 @@ class Lines extends THREE.LineSegments {
     });
   }
 }
+class DomContainer extends Component {
+  static name = "DomContainer";
+  domElement = document.createElement("div");
+  canvas = document.createElement("canvas");
+  html2DRenderer = document.createElement("div");
+  html3DRenderer = document.createElement("div");
+  constructor() {
+    super();
+    this.domElement.id = "build-dxf-container";
+    this.domElement.appendChild(this.canvas);
+    this.domElement.appendChild(this.html3DRenderer);
+    this.domElement.appendChild(this.html2DRenderer);
+    Object.assign(this.domElement.style, {
+      width: "100%",
+      height: "100%",
+      position: "relative",
+      userSelect: "none"
+    });
+    Object.assign(this.html3DRenderer.style, {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      // zIndex: 9,
+      width: "100%",
+      height: "100%"
+    });
+    Object.assign(this.html2DRenderer.style, {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      // zIndex: 10,
+      width: "100%",
+      height: "100%"
+    });
+  }
+}
+class DomEventRegister extends Component {
+  static name = "DomEventRegister";
+  cancelDefaultBehaviorList = [];
+  pointer = new Vector2();
+  _isMouseEnter = false;
+  set isMouseEnter(isMouseEnter) {
+    if (this._isMouseEnter === isMouseEnter) return;
+    this._isMouseEnter = isMouseEnter;
+  }
+  get isMouseEnter() {
+    return this._isMouseEnter;
+  }
+  _mouseMoveEventProxylock = false;
+  set mouseMoveEventProxylock(lock) {
+    this._mouseMoveEventProxylock = lock;
+    if (lock) {
+      this._isMouseEnter = false;
+    }
+  }
+  get mouseMoveEventProxylock() {
+    return this._mouseMoveEventProxylock;
+  }
+  /**
+   * 组件被添加到父组件上时调用
+   */
+  onAddFromParent() {
+    this.initMouseMoveEventProxy();
+    this.initKeyEvent();
+    this.initWheelEvent();
+    this.autoBodyCursor();
+  }
+  /**
+   * 初始化鼠标事件代理(判断鼠标是否在domElement上)
+   */
+  initMouseMoveEventProxy() {
+    const domContainer = this.parent?.findComponentByType(DomContainer), domElement = domContainer.domElement, variable = this.parent?.findComponentByType(Variable), globalMousemoveFun = (e) => {
+      if (this._mouseMoveEventProxylock) return;
+      const rect = domElement.getBoundingClientRect(), offsetX = e.clientX - rect.left, offsetY = e.clientY - rect.top;
+      if (offsetX >= 0 && offsetY >= 0 && offsetX <= rect.width && offsetY <= rect.height) {
+        this.pointer.set(offsetX, offsetY);
+        this.dispatchEvent({
+          type: "mousemove",
+          x: offsetX,
+          y: offsetY,
+          moveX: e.movementX,
+          moveY: e.movementY
+        });
+        this.isMouseEnter = true;
+      } else {
+        this.isMouseEnter = false;
+      }
+    }, globalMousedownFun = (e) => {
+      if (!this.isMouseEnter) return;
+      const rect = domElement.getBoundingClientRect(), offsetX = e.clientX - rect.left, offsetY = e.clientY - rect.top;
+      this.pointer.set(offsetX, offsetY);
+      variable.set("currentMouseDown", "mouse_" + e.button);
+      this.dispatchEvent({
+        type: "mousedown",
+        x: offsetX,
+        y: offsetY
+      });
+    }, globalMouseupFun = (e) => {
+      if (!this.isMouseEnter) return;
+      variable.set("currentMouseUp", "mouse_" + e.button);
+    };
+    document.addEventListener("mousemove", globalMousemoveFun);
+    document.addEventListener("mousedown", globalMousedownFun);
+    document.addEventListener("mouseup", globalMouseupFun);
+    this.addEventRecord("destory", () => {
+      document.removeEventListener("mousemove", globalMousemoveFun);
+      document.removeEventListener("mousedown", globalMousedownFun);
+      document.removeEventListener("mouseup", globalMouseupFun);
+    });
+  }
+  /**
+   * 初始化键盘事件
+   */
+  initKeyEvent() {
+    const variable = this.parent?.findComponentByType(Variable);
+    document.body.tabIndex = 1;
+    const onKeyup = (e) => {
+      if (!this.isMouseEnter) return;
+      const key = e.key.toLocaleLowerCase();
+      variable.set("currentKeyUp", key);
+      for (let i = 0; i < this.cancelDefaultBehaviorList.length; i++) {
+        const element = this.cancelDefaultBehaviorList[i];
+        if (element(e)) e.preventDefault();
+      }
+    };
+    document.body.addEventListener("keyup", onKeyup);
+    const onKeydown = (e) => {
+      if (!this.isMouseEnter) return;
+      const key = e.key.toLocaleLowerCase();
+      variable.set("currentKeyDown", key);
+      for (let i = 0; i < this.cancelDefaultBehaviorList.length; i++) {
+        const element = this.cancelDefaultBehaviorList[i];
+        if (element(e)) e.preventDefault();
+      }
+    };
+    document.body.addEventListener("keydown", onKeydown);
+    const onFocus = () => variable.set("focus", true);
+    document.body.addEventListener("focus", onFocus);
+    const onBlur = () => variable.set("focus", false);
+    document.body.addEventListener("blur", onBlur);
+    this.addEventRecord("destory", () => {
+      document.body.removeEventListener("keyup", onKeyup);
+      document.body.removeEventListener("keydown", onKeydown);
+      document.body.removeEventListener("focus", onFocus);
+      document.body.removeEventListener("blur", onBlur);
+    });
+  }
+  /**
+   * 初始化滚轮事件
+   */
+  initWheelEvent() {
+    const variable = this.parent?.findComponentByType(Variable);
+    const onWheel = (e) => variable.set("currentWheel", e.wheelDelta);
+    document.body.addEventListener("wheel", onWheel);
+    this.addEventRecord("destory", () => {
+      document.body.removeEventListener("wheel", onWheel);
+    });
+  }
+  /**
+   * 根据domElement的cursor自动设置body的cursor
+   */
+  autoBodyCursor() {
+    const domContainer = this.parent?.findComponentByType(DomContainer), domElement = domContainer.domElement;
+    let bodyCursor = null;
+    this.addEventListener("update", () => {
+      if (this._mouseMoveEventProxylock) return;
+      if (this.isMouseEnter) {
+        if (bodyCursor === null) {
+          bodyCursor = document.body.style.cursor;
+        }
+        document.body.style.cursor = domElement.style.cursor;
+      } else {
+        if (bodyCursor !== null) {
+          document.body.style.cursor = bodyCursor;
+          bodyCursor = null;
+        }
+      }
+    });
+  }
+  /**
+   * 
+   * @param callBack 
+   */
+  addCancelDefaultBehavior(callBack) {
+    this.cancelDefaultBehaviorList.push(callBack);
+    return this;
+  }
+  /**
+   * 
+   * @param el 
+   * @param callBack 
+   * @param offset 
+   * @param condition 
+   */
+  static dragMoveHelper(el, callBack, offset = { x: 0, y: 0 }, condition = () => true) {
+    function onMousedown() {
+      if (!condition()) return;
+      const move = (e) => {
+        offset.x += e.movementX;
+        offset.y += e.movementY;
+        callBack({ ...offset }, e.movementX, e.movementY);
+      };
+      const end = () => {
+        document.removeEventListener("mousemove", move);
+        document.removeEventListener("mouseup", end);
+      };
+      document.addEventListener("mousemove", move);
+      document.addEventListener("mouseup", end);
+    }
+    el.addEventListener("mousedown", onMousedown);
+    callBack({ ...offset }, 0, 0);
+    return () => {
+      el.removeEventListener("mousedown", onMousedown);
+    };
+  }
+  destroy() {
+    this.canceEventRecord("destory");
+  }
+}
 function selectLocalFileFun() {
   return new Promise((resolve) => {
     const input = document.createElement("input");
@@ -3710,36 +4130,39 @@ const SelectLocalFile = Object.assign(selectLocalFileFun, {
   }
 });
 export {
-  withInstallFunction as A,
+  isElement as A,
+  withInstallFunction as B,
+  DomEventRegister as D,
   ElButton as E,
   Lines as L,
+  Renderer as R,
   SelectLocalFile as S,
   TypeComponentsMap as T,
   _export_sfc as _,
-  ElCheckbox as a,
-  isClient as b,
-  tryOnMounted as c,
-  identity as d,
-  buildProps as e,
-  definePropType as f,
-  isNumber as g,
-  addUnit as h,
+  DomContainer as a,
+  ElCheckbox as b,
+  isClient as c,
+  tryOnMounted as d,
+  identity as e,
+  buildProps as f,
+  definePropType as g,
+  isNumber as h,
   isString as i,
-  useEmptyValuesProps as j,
-  useSizeProp as k,
-  iconPropType as l,
-  useGlobalComponentSettings as m,
+  addUnit as j,
+  useEmptyValuesProps as k,
+  useSizeProp as l,
+  iconPropType as m,
   noop as n,
-  ElIcon as o,
+  useGlobalComponentSettings as o,
   provideGlobalConfig as p,
-  TypeComponents as q,
+  ElIcon as q,
   resolveUnref as r,
-  useTimeoutFn as s,
+  TypeComponents as s,
   tryOnScopeDispose as t,
   useNamespace as u,
-  isString$1 as v,
+  useTimeoutFn as v,
   withInstall as w,
-  isFunction$1 as x,
-  isBoolean as y,
-  isElement as z
+  isString$1 as x,
+  isFunction$1 as y,
+  isBoolean as z
 };

package/src/utils/CommandManager/CommandFlow.d.ts

@@ -18,6 +18,22 @@ export declare class CommandFlow extends EventDispatcher<{
     finally: {};
 }> {
     list: CommandFlowCallBack[];
+    rollbacklist: ((data?: any) => void)[];
+    revokeRollbacklist: ((data?: any) => void)[];
+    /**
+     *
+     * @param operation
+     * @returns
+     */
     add(operation: CommandFlowCallBack): this;
+    /** 添加回滚回调列表
+     * @param callBack
+     */
+    addRollback(callBack: (data?: any) => void): this;
+    /** 添加撤回回滚回调列表
+     * @param callBack
+     * @returns
+     */
+    addRevokeRollback(callBack: (data?: any) => void): this;
 }
 export {};

package/src/utils/CommandManager/CommandManager.d.ts

@@ -1,5 +1,9 @@
 import { EventDispatcher } from '../ComponentManager';
 import { CommandFlow } from './CommandFlow';
+export type Operation = {
+    name: string;
+    data: any;
+};
 export declare class CommandManager extends EventDispatcher<{
     startedBefore: {
         name: string;
@@ -31,6 +35,12 @@ export declare class CommandManager extends EventDispatcher<{
     finally: {
         name: string;
     };
+    rollback: {
+        name: string;
+    };
+    revokeRollback: {
+        name: string;
+    };
 }> {
     commandFlowMap: Map<string, CommandFlow>;
     lock: boolean;
@@ -40,6 +50,11 @@ export declare class CommandManager extends EventDispatcher<{
     private _disabled;
     set disabled(disabled: boolean);
     get disabled(): boolean;
+    /**
+     * 操作记录
+     */
+    operationList: Operation[];
+    rollbackList: Operation[];
     constructor();
     /** 添加命令流
      * @param name
@@ -56,4 +71,12 @@ export declare class CommandManager extends EventDispatcher<{
     /** 取消当前命令
      */
     cancel(): void;
+    /**
+     * 回滚
+     */
+    rollback(): boolean;
+    /**
+     * 撤销回滚
+     */
+    revokeRollback(): boolean;
 }

package/src/utils/ComponentManager/Component.d.ts

@@ -10,6 +10,7 @@ export declare class Component<TEventMap extends {} = {}> extends EventDispatche
     update: {};
 } & TEventMap> {
     parent?: ComponentManager;
+    destroyed: boolean;
     constructor(...arg: any[]);
     onAddFromParent(parent: ComponentManager): void;
     onRemoveFromParent(parent: ComponentManager): void;

package/src/utils/ComponentManager/ComponentManager.d.ts

@@ -32,7 +32,7 @@ export declare class ComponentManager<TEventMap extends {} = {}> extends EventDi
      * 查找所有符合条件的组件
      * @param callBack
      */
-    findComponents(predicate: (component: Component, index: number) => boolean): Component<{}> | undefined;
+    findComponents(predicate: (component: Component, index: number) => boolean): Component<{}>[];
     /**
      *
      * @param type

package/src/utils/DxfSystem/components/Dxf.d.ts

@@ -22,6 +22,7 @@ export interface OriginalDataItem {
             z?: number;
         };
     }[];
+    length: number;
     isDoor?: boolean;
     doorDirectConnection?: boolean;
     drawDoorData?: {

package/src/utils/DxfSystem/plugin/Editor/components/CommandFlow/CommandFlowComponent.d.ts

@@ -1,8 +1,9 @@
-import { Component } from '../../../../../ComponentManager';
+import { Component, ComponentManager } from '../../../../../ComponentManager';
 import { Editor } from '../Editor';
 import { EventInput, Renderer } from '../../../RenderPlugin/components';
 import { CommandManager } from '../../../../../CommandManager';
 import { RenderManager } from '../RenderManager';
+import { Default } from './Default';
 export declare class CommandFlowComponent<TEventMap extends {} = {}> extends Component<TEventMap> {
     private _renderer?;
     get renderer(): Renderer;
@@ -16,9 +17,18 @@ export declare class CommandFlowComponent<TEventMap extends {} = {}> extends Com
     get renderManager(): RenderManager;
     private _commandManager?;
     get commandManager(): CommandManager;
+    private _default?;
+    get default(): Default;
     interruptKeys: string[];
+    commandName: string;
+    constructor();
+    onAddFromParent(parent: ComponentManager): void;
     /**
-     * 创建中断
+     * 取消
+     */
+    cancel(): void;
+    /**
+     * 创建中断处理命令节点
      * @returns
      */
     createInterrupt(): (next: any, data: any) => void;
@@ -32,5 +42,5 @@ export declare class CommandFlowComponent<TEventMap extends {} = {}> extends Com
      * 创建清理
      * @returns
      */
-    createFinally(): () => void;
+    createFinally(keys?: string[]): () => void;
 }

package/src/utils/DxfSystem/plugin/Editor/components/CommandFlow/ConnectionLine.d.ts

@@ -0,0 +1,33 @@
+import { CommandFlowComponent } from './CommandFlowComponent';
+import { ComponentManager } from '../../../../../ComponentManager';
+/**
+ * 连接选择的线段
+ */
+export declare class ConnectionLine extends CommandFlowComponent<{}> {
+    static name: string;
+    shortcutKeys: string[];
+    static commandName: string;
+    onAddFromParent(parent: ComponentManager): void;
+    /**
+     * 进入命令约束
+     */
+    private constraint;
+    /** 连接
+     * @param next
+     */
+    private connection;
+    /** 成功
+     * @param next
+     * @param selectLines
+     */
+    private completed;
+    /** 回滚操作
+     * @param data
+     */
+    private rollback;
+    /** 撤回回滚
+     * @param lines
+     * @returns
+     */
+    private revokeRollback;
+}