@tmagic/stage 1.2.0-beta.8 → 1.2.0

package/src/StageRender.ts

@@ -18,28 +18,30 @@
 
 import { EventEmitter } from 'events';
 
+import { Id } from '@tmagic/schema';
 import { getHost, injectStyle, isSameDomain } from '@tmagic/utils';
 
+import { DEFAULT_ZOOM } from './const';
 import style from './style.css?raw';
-import type { Runtime, RuntimeWindow, StageRenderConfig } from './types';
+import type { Point, RemoveData, Runtime, RuntimeWindow, StageRenderConfig, UpdateData } from './types';
+import { addSelectedClassName, removeSelectedClassName } from './util';
 
 export default class StageRender extends EventEmitter {
   /** 组件的js、css执行的环境，直接渲染为当前window，iframe渲染则为iframe.contentWindow */
   public contentWindow: RuntimeWindow | null = null;
-
   public runtime: Runtime | null = null;
-
   public iframe?: HTMLIFrameElement;
 
-  public runtimeUrl?: string;
+  private runtimeUrl?: string;
+  private zoom = DEFAULT_ZOOM;
+  private customizedRender?: () => Promise<HTMLElement | null>;
 
-  private render?: () => Promise<HTMLElement | null>;
-
-  constructor({ runtimeUrl, render }: StageRenderConfig) {
+  constructor({ runtimeUrl, zoom, customizedRender }: StageRenderConfig) {
     super();
 
     this.runtimeUrl = runtimeUrl || '';
-    this.render = render;
+    this.customizedRender = customizedRender;
+    this.setZoom(zoom);
 
     this.iframe = globalThis.document.createElement('iframe');
     // 同源，直接加载
@@ -63,6 +65,38 @@ export default class StageRender extends EventEmitter {
     },
   });
 
+  public async add(data: UpdateData): Promise<void> {
+    const runtime = await this.getRuntime();
+    return runtime?.add?.(data);
+  }
+
+  public async remove(data: RemoveData): Promise<void> {
+    const runtime = await this.getRuntime();
+    return runtime?.remove?.(data);
+  }
+
+  public async update(data: UpdateData): Promise<void> {
+    const runtime = await this.getRuntime();
+    // 更新画布中的组件
+    runtime?.update?.(data);
+  }
+
+  public async select(els: HTMLElement[]): Promise<void> {
+    const runtime = await this.getRuntime();
+
+    for (const el of els) {
+      await runtime?.select?.(el.id);
+      if (runtime?.beforeSelect) {
+        await runtime.beforeSelect(el);
+      }
+      this.flagSelectedEl(el);
+    }
+  }
+
+  public setZoom(zoom: number = DEFAULT_ZOOM): void {
+    this.zoom = zoom;
+  }
+
   /**
    * 挂载Dom节点
    * @param el 将页面挂载到该Dom节点上
@@ -101,6 +135,35 @@ export default class StageRender extends EventEmitter {
     return this.contentWindow?.document;
   }
 
+  /**
+   * 通过坐标获得坐标下所有HTML元素数组
+   * @param point 坐标
+   * @returns 坐标下方所有HTML元素数组，会包含父元素直至html，元素层叠时返回顺序是从上到下
+   */
+  public getElementsFromPoint(point: Point): HTMLElement[] {
+    let x = point.clientX;
+    let y = point.clientY;
+
+    if (this.iframe) {
+      const rect = this.iframe.getClientRects()[0];
+      if (rect) {
+        x = x - rect.left;
+        y = y - rect.top;
+      }
+    }
+
+    return this.getDocument()?.elementsFromPoint(x / this.zoom, y / this.zoom) as HTMLElement[];
+  }
+
+  public getTargetElement(idOrEl: Id | HTMLElement): HTMLElement {
+    if (typeof idOrEl === 'string' || typeof idOrEl === 'number') {
+      const el = this.getDocument()?.getElementById(`${idOrEl}`);
+      if (!el) throw new Error(`不存在ID为${idOrEl}的元素`);
+      return el;
+    }
+    return idOrEl;
+  }
+
   /**
    * 销毁实例
    */
@@ -112,6 +175,18 @@ export default class StageRender extends EventEmitter {
     this.removeAllListeners();
   }
 
+  /**
+   * 在runtime中对被选中的元素进行标记，部分组件有对选中态进行特殊显示的需求
+   * @param el 被选中的元素
+   */
+  private flagSelectedEl(el: HTMLElement): void {
+    const doc = this.getDocument();
+    if (doc) {
+      removeSelectedClassName(doc);
+      addSelectedClassName(el, doc);
+    }
+  }
+
   private loadHandler = async () => {
     if (!this.contentWindow?.magic) {
       this.postTmagicRuntimeReady();
@@ -119,8 +194,8 @@ export default class StageRender extends EventEmitter {
 
     if (!this.contentWindow) return;
 
-    if (this.render) {
-      const el = await this.render();
+    if (this.customizedRender) {
+      const el = await this.customizedRender();
       if (el) {
         this.contentWindow.document?.body?.appendChild(el);
       }

package/src/TargetShadow.ts

@@ -0,0 +1,120 @@
+/*
+ * Tencent is pleased to support the open source community by making TMagicEditor available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Mode, ZIndex } from './const';
+import type { TargetElement as ShadowElement, TargetShadowConfig, UpdateDragEl } from './types';
+import { getTargetElStyle, isFixedParent } from './util';
+
+/**
+ * 将选中的节点修正定位后，添加一个操作节点到蒙层上
+ */
+export default class TargetShadow {
+  public el?: ShadowElement;
+  public els: ShadowElement[] = [];
+
+  private idPrefix = 'target_calibrate_';
+  private container: HTMLElement;
+  private scrollLeft = 0;
+  private scrollTop = 0;
+  private zIndex?: ZIndex;
+
+  private updateDragEl?: UpdateDragEl;
+
+  constructor(config: TargetShadowConfig) {
+    this.container = config.container;
+
+    if (config.updateDragEl) {
+      this.updateDragEl = config.updateDragEl;
+    }
+
+    if (typeof config.zIndex !== 'undefined') {
+      this.zIndex = config.zIndex;
+    }
+
+    if (config.idPrefix) {
+      this.idPrefix = config.idPrefix;
+    }
+
+    this.container.addEventListener('customScroll', this.scrollHandler);
+  }
+
+  public update(target: ShadowElement): ShadowElement {
+    this.el = this.updateEl(target, this.el);
+
+    return this.el;
+  }
+
+  public updateGroup(targetGroup: ShadowElement[]): ShadowElement[] {
+    if (this.els.length > targetGroup.length) {
+      this.els.slice(targetGroup.length - 1).forEach((el) => {
+        el.remove();
+      });
+    }
+
+    this.els = targetGroup.map((target, index) => this.updateEl(target, this.els[index]));
+
+    return this.els;
+  }
+
+  public destroyEl(): void {
+    this.el?.remove();
+    this.el = undefined;
+  }
+
+  public destroyEls(): void {
+    this.els.forEach((el) => {
+      el.remove();
+    });
+    this.els = [];
+  }
+
+  public destroy(): void {
+    this.container.removeEventListener('customScroll', this.scrollHandler);
+    this.destroyEl();
+    this.destroyEls();
+  }
+
+  private updateEl(target: ShadowElement, src?: ShadowElement): ShadowElement {
+    const el = src || globalThis.document.createElement('div');
+
+    el.id = `${this.idPrefix}${target.id}`;
+
+    el.style.cssText = getTargetElStyle(target, this.zIndex);
+
+    if (typeof this.updateDragEl === 'function') {
+      this.updateDragEl(el, target);
+    }
+    const isFixed = isFixedParent(target);
+    const mode = this.container.dataset.mode || Mode.ABSOLUTE;
+    if (isFixed && mode !== Mode.FIXED) {
+      el.style.transform = `translate3d(${this.scrollLeft}px, ${this.scrollTop}px, 0)`;
+    } else if (!isFixed && mode === Mode.FIXED) {
+      el.style.transform = `translate3d(${-this.scrollLeft}px, ${-this.scrollTop}px, 0)`;
+    }
+
+    if (!globalThis.document.getElementById(el.id)) {
+      this.container.append(el);
+    }
+
+    return el;
+  }
+
+  private scrollHandler = (e: any) => {
+    this.scrollLeft = e.detail.scrollLeft;
+    this.scrollTop = e.detail.scrollTop;
+  };
+}

package/src/const.ts

@@ -25,7 +25,7 @@ export const DRAG_EL_ID_PREFIX = 'drag_el_';
 /** 高亮时需要在蒙层中创建一个占位节点，该节点的id前缀 */
 export const HIGHLIGHT_EL_ID_PREFIX = 'highlight_el_';
 
-export const CONTAINER_HIGHLIGHT_CLASS = 'tmagic-stage-container-highlight';
+export const CONTAINER_HIGHLIGHT_CLASS_NAME = 'tmagic-stage-container-highlight';
 
 export const PAGE_CLASS = 'magic-ui-page';
 

package/src/types.ts

@@ -16,25 +16,44 @@
  * limitations under the License.
  */
 
-import { MoveableOptions } from 'moveable';
+import type { MoveableOptions } from 'moveable';
 
 import Core from '@tmagic/core';
 import type { Id, MApp, MContainer, MNode } from '@tmagic/schema';
 
-import { GuidesType } from './const';
+import { GuidesType, ZIndex } from './const';
 import StageCore from './StageCore';
-import StageDragResize from './StageDragResize';
-import StageMask from './StageMask';
+
+export type TargetElement = HTMLElement | SVGElement;
 
 export type CanSelect = (el: HTMLElement, event: MouseEvent, stop: () => boolean) => boolean | Promise<boolean>;
 export type IsContainer = (el: HTMLElement) => boolean | Promise<boolean>;
-
+export type CustomizeRender = (renderer: StageCore) => Promise<HTMLElement> | HTMLElement;
+/** 业务方自定义的moveableOptions，可以是配置，也可以是回调函数 */
+export type CustomizeMoveableOptions =
+  | ((config?: CustomizeMoveableOptionsCallbackConfig) => MoveableOptions)
+  | MoveableOptions
+  | undefined;
+/** render提供给的接口，如果是id则转成el，如果是el则直接返回 */
+export type GetTargetElement = (idOrEl: Id | HTMLElement) => HTMLElement;
+/** render提供的接口，通过坐标获得坐标下所有HTML元素数组 */
+export type GetElementsFromPoint = (point: Point) => HTMLElement[];
+export type GetRenderDocument = () => Document | undefined;
+export type DelayedMarkContainer = (event: MouseEvent, exclude: Element[]) => NodeJS.Timeout | undefined;
+export type MarkContainerEnd = () => HTMLElement | null;
+export type GetRootContainer = () => HTMLDivElement | undefined;
+
+/** 将组件添加到容器的方式 */
 export enum ContainerHighlightType {
+  /** 默认方式：组件在容器上方悬停一段时间后加入 */
   DEFAULT = 'default',
+  /** 按住alt键，并在容器上方悬停一段时间后加入 */
   ALT = 'alt',
 }
 
-export type StageCoreConfig = {
+export type UpdateDragEl = (el: TargetElement, target: TargetElement) => void;
+
+export interface StageCoreConfig {
   /** 需要对齐的dom节点的CSS选择器字符串 */
   snapElementQuerySelector?: string;
   /** 放大倍数，默认1倍 */
@@ -44,18 +63,47 @@ export type StageCoreConfig = {
   containerHighlightClassName?: string;
   containerHighlightDuration?: number;
   containerHighlightType?: ContainerHighlightType;
-  moveableOptions?: ((core?: StageCore) => MoveableOptions) | MoveableOptions;
-  multiMoveableOptions?: ((core?: StageCore) => MoveableOptions) | MoveableOptions;
+  moveableOptions?: CustomizeMoveableOptions;
+  multiMoveableOptions?: CustomizeMoveableOptions;
   /** runtime 的HTML地址，可以是一个HTTP地址，如果和编辑器不同域，需要设置跨域，也可以是一个相对或绝对路径 */
   runtimeUrl?: string;
   render?: (renderer: StageCore) => Promise<HTMLElement> | HTMLElement;
   autoScrollIntoView?: boolean;
-  updateDragEl?: (el: HTMLDivElement, target: HTMLElement) => void;
-};
+  updateDragEl?: UpdateDragEl;
+  disabledDragStart?: boolean;
+}
+
+export interface ActionManagerConfig {
+  container: HTMLElement;
+  containerHighlightClassName?: string;
+  containerHighlightDuration?: number;
+  containerHighlightType?: ContainerHighlightType;
+  moveableOptions?: CustomizeMoveableOptions;
+  multiMoveableOptions?: CustomizeMoveableOptions;
+  disabledDragStart?: boolean;
+  canSelect?: CanSelect;
+  isContainer: IsContainer;
+  getRootContainer: GetRootContainer;
+  getRenderDocument: GetRenderDocument;
+  updateDragEl?: UpdateDragEl;
+  getTargetElement: GetTargetElement;
+  getElementsFromPoint: GetElementsFromPoint;
+}
+
+export interface MoveableOptionsManagerConfig {
+  container: HTMLElement;
+  moveableOptions?: CustomizeMoveableOptions;
+  getRootContainer: GetRootContainer;
+}
+
+export interface CustomizeMoveableOptionsCallbackConfig {
+  targetElId?: string;
+}
 
 export interface StageRenderConfig {
   runtimeUrl?: string;
-  render?: () => Promise<HTMLElement | null>;
+  zoom: number | undefined;
+  customizedRender?: () => Promise<HTMLElement | null>;
 }
 
 export interface StageMaskConfig {
@@ -63,9 +111,35 @@ export interface StageMaskConfig {
 }
 
 export interface StageDragResizeConfig {
-  core: StageCore;
   container: HTMLElement;
-  mask: StageMask;
+  moveableOptions?: CustomizeMoveableOptions;
+  disabledDragStart?: boolean;
+  getRootContainer: GetRootContainer;
+  getRenderDocument: GetRenderDocument;
+  markContainerEnd: MarkContainerEnd;
+  delayedMarkContainer: DelayedMarkContainer;
+  updateDragEl?: UpdateDragEl;
+}
+
+export interface StageMultiDragResizeConfig {
+  container: HTMLElement;
+  multiMoveableOptions?: CustomizeMoveableOptions;
+  getRootContainer: GetRootContainer;
+  getRenderDocument: GetRenderDocument;
+  updateDragEl?: UpdateDragEl;
+}
+
+export interface DragResizeHelperConfig {
+  container: HTMLElement;
+  updateDragEl?: UpdateDragEl;
+}
+
+/** 选择状态 */
+export enum SelectStatus {
+  /** 单选 */
+  SELECT = 'select',
+  /** 多选 */
+  MULTI_SELECT = 'multiSelect',
 }
 
 /** 拖动状态 */
@@ -88,6 +162,11 @@ export interface Offset {
   top: number;
 }
 
+export interface Point {
+  clientX: number;
+  clientY: number;
+}
+
 export interface GuidesEventData {
   type: GuidesType;
   guides: number[];
@@ -154,13 +233,14 @@ export interface RuntimeWindow extends Window {
 }
 
 export interface StageHighlightConfig {
-  core: StageCore;
   container: HTMLElement;
+  updateDragEl?: UpdateDragEl;
+  getRootContainer: GetRootContainer;
 }
 
-export interface TargetCalibrateConfig {
-  parent: HTMLElement;
-  mask: StageMask;
-  dr: StageDragResize;
-  core: StageCore;
+export interface TargetShadowConfig {
+  container: HTMLElement;
+  zIndex?: ZIndex;
+  updateDragEl?: UpdateDragEl;
+  idPrefix?: string;
 }

package/src/util.ts

@@ -18,7 +18,7 @@
 import { removeClassName } from '@tmagic/utils';
 
 import { GHOST_EL_ID_PREFIX, Mode, SELECTED_CLASS, ZIndex } from './const';
-import type { Offset, SortEventData } from './types';
+import type { Offset, SortEventData, TargetElement } from './types';
 
 const getParents = (el: Element, relative: Element) => {
   let cur: Element | null = el.parentElement;
@@ -30,12 +30,16 @@ const getParents = (el: Element, relative: Element) => {
   return parents;
 };
 
-export const getOffset = (el: HTMLElement): Offset => {
-  const { offsetParent } = el;
+export const getOffset = (el: TargetElement): Offset => {
+  const htmlEl = el as HTMLElement;
+  const { offsetParent } = htmlEl;
 
-  const left = el.offsetLeft;
-  const top = el.offsetTop;
+  const left = htmlEl.offsetLeft || 0;
+  const top = htmlEl.offsetTop || 0;
 
+  // 在 Webkit 中，如果元素为隐藏的（该元素或其祖先元素的 style.display 为 "none"），或者该元素的 style.position 被设为 "fixed"，则该属性返回 null。
+  // 在 IE 9 中，如果该元素的 style.position 被设置为 "fixed"，则该属性返回 null。（display:none 无影响。）
+  // body offsetParent 为 null
   if (offsetParent) {
     const parentOffset = getOffset(offsetParent as HTMLElement);
     return {
@@ -51,7 +55,7 @@ export const getOffset = (el: HTMLElement): Offset => {
 };
 
 // 将蒙层占位节点覆盖在原节点上方
-export const getTargetElStyle = (el: HTMLElement) => {
+export const getTargetElStyle = (el: TargetElement, zIndex?: ZIndex) => {
   const offset = getOffset(el);
   const { transform } = getComputedStyle(el);
   return `
@@ -61,13 +65,16 @@ export const getTargetElStyle = (el: HTMLElement) => {
     top: ${offset.top}px;
     width: ${el.clientWidth}px;
     height: ${el.clientHeight}px;
-    z-index: ${ZIndex.DRAG_EL};
+    ${typeof zIndex !== 'undefined' ? `z-index: ${zIndex};` : ''}
   `;
 };
 
 export const getAbsolutePosition = (el: HTMLElement, { top, left }: Offset) => {
   const { offsetParent } = el;
 
+  // 在 Webkit 中，如果元素为隐藏的（该元素或其祖先元素的 style.display 为 "none"），或者该元素的 style.position 被设为 "fixed"，则该属性返回 null。
+  // 在 IE 9 中，如果该元素的 style.position 被设置为 "fixed"，则该属性返回 null。（display:none 无影响。）
+  // body offsetParent 为 null
   if (offsetParent) {
     const parentOffset = getOffset(offsetParent as HTMLElement);
     return {
@@ -87,7 +94,7 @@ export const isStatic = (style: CSSStyleDeclaration): boolean => style.position
 
 export const isFixed = (style: CSSStyleDeclaration): boolean => style.position === 'fixed';
 
-export const isFixedParent = (el: HTMLElement) => {
+export const isFixedParent = (el: Element) => {
   let fixed = false;
   let dom = el;
   while (dom) {
@@ -104,7 +111,7 @@ export const isFixedParent = (el: HTMLElement) => {
   return fixed;
 };
 
-export const getMode = (el: HTMLElement): Mode => {
+export const getMode = (el: Element): Mode => {
   if (isFixedParent(el)) return Mode.FIXED;
   const style = getComputedStyle(el);
   if (isStatic(style) || isRelative(style)) return Mode.SORTABLE;
@@ -168,7 +175,7 @@ export const calcValueByFontsize = (doc: Document, value: number) => {
  * @param {number} deltaTop 偏移量
  * @param {Object} detail 当前选中的组件配置
  */
-export const down = (deltaTop: number, target: HTMLElement | SVGElement): SortEventData | void => {
+export const down = (deltaTop: number, target: TargetElement): SortEventData | void => {
   let swapIndex = 0;
   let addUpH = target.clientHeight;
   const brothers = Array.from(target.parentNode?.children || []).filter(
@@ -204,7 +211,7 @@ export const down = (deltaTop: number, target: HTMLElement | SVGElement): SortEv
  * @param {number} deltaTop 偏移量
  * @param {Object} detail 当前选中的组件配置
  */
-export const up = (deltaTop: number, target: HTMLElement | SVGElement): SortEventData | void => {
+export const up = (deltaTop: number, target: TargetElement): SortEventData | void => {
   const brothers = Array.from(target.parentNode?.children || []).filter(
     (node) => !node.id.startsWith(GHOST_EL_ID_PREFIX),
   );

package/types/ActionManager.d.ts

@@ -0,0 +1,141 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Id } from '@tmagic/schema';
+import { GuidesType } from './const';
+import { ActionManagerConfig, SelectStatus } from './types';
+/**
+ * 管理蒙层mask之上的操作：1、监听键盘鼠标事件，判断形成单选、多选、高亮操作；2、管理单选、多选、高亮三个类协同工作。
+ * @extends EventEmitter
+ */
+export default class ActionManager extends EventEmitter {
+    private dr;
+    private multiDr;
+    private highlightLayer;
+    /** 单选、多选、高亮的容器（蒙层的content） */
+    private container;
+    /** 当前选中的节点 */
+    private selectedEl;
+    /** 多选选中的节点组 */
+    private selectedElList;
+    /** 当前高亮的节点 */
+    private highlightedEl;
+    /** 当前是否处于多选状态 */
+    private isMultiSelectStatus;
+    /** 当拖拽组件到容器上方进入可加入容器状态时，给容器添加的一个class名称 */
+    private containerHighlightClassName;
+    /** 当拖拽组件到容器上方时，需要悬停多久才能将组件加入容器 */
+    private containerHighlightDuration;
+    /** 将组件加入容器的操作方式 */
+    private containerHighlightType?;
+    private isAltKeydown;
+    private getTargetElement;
+    private getElementsFromPoint;
+    private canSelect;
+    private isContainer;
+    private getRenderDocument;
+    private mouseMoveHandler;
+    constructor(config: ActionManagerConfig);
+    /**
+     * 设置水平/垂直参考线
+     * @param type 参考线类型
+     * @param guidelines 参考线坐标数组
+     */
+    setGuidelines(type: GuidesType, guidelines: number[]): void;
+    /**
+     * 清空所有参考线
+     */
+    clearGuides(): void;
+    /**
+     * 更新moveable，外部主要调用场景是元素配置变更、页面大小变更
+     * @param el 变更的元素
+     */
+    updateMoveable(el?: HTMLElement): void;
+    /**
+     * 判断是否单选选中的元素
+     */
+    isSelectedEl(el: HTMLElement): boolean;
+    setSelectedEl(el: HTMLElement): void;
+    getSelectedEl(): HTMLElement | undefined;
+    getSelectedElList(): HTMLElement[];
+    /**
+     * 获取鼠标下方第一个可选中元素，如果元素层叠，返回到是最上层元素
+     * @param event 鼠标事件
+     * @returns 鼠标下方第一个可选中元素
+     */
+    getElementFromPoint(event: MouseEvent): Promise<HTMLElement | undefined>;
+    /**
+     * 判断一个元素能否在当前场景被选中
+     * @param el 被判断的元素
+     * @param event 鼠标事件
+     * @param stop 通过该元素如果得知剩下的元素都不可被选中，通知调用方终止对剩下元素的判断
+     * @returns 能否选中
+     */
+    isElCanSelect(el: HTMLElement, event: MouseEvent, stop: () => boolean): Promise<boolean>;
+    /**
+     * 判断一个元素是否可以被多选，如果当前元素是page，则调stop函数告诉调用方不必继续判断其它元素了
+     */
+    canMultiSelect(el: HTMLElement, stop: () => boolean): boolean;
+    select(el: HTMLElement, event: MouseEvent | undefined): void;
+    multiSelect(idOrElList: HTMLElement[] | Id[]): void;
+    getHighlightEl(): HTMLElement | undefined;
+    setHighlightEl(el: HTMLElement | undefined): void;
+    highlight(idOrEl: Id | HTMLElement): void;
+    clearHighlight(): void;
+    /**
+     * 用于在切换选择模式时清除上一次的状态
+     * @param selectType 需要清理的选择模式
+     */
+    clearSelectStatus(selectType: SelectStatus): void;
+    /**
+     * 找到鼠标下方的容器，通过添加className对容器进行标记
+     * @param event 鼠标事件
+     * @param excludeElList 计算鼠标点所在容器时要排除的元素列表
+     */
+    addContainerHighlightClassName(event: MouseEvent, excludeElList: Element[]): Promise<void>;
+    /**
+     * 鼠标拖拽着元素，在容器上方悬停，延迟一段时间后，对容器进行标记，如果悬停时间够长将标记成功，悬停时间短，调用方通过返回的timeoutId取消标记
+     * 标记的作用：1、高亮容器，给用户一个加入容器的交互感知；2、释放鼠标后，通过标记的标志找到要加入的容器
+     * @param event 鼠标事件
+     * @param excludeElList 计算鼠标所在容器时要排除的元素列表
+     * @returns timeoutId，调用方在鼠标移走时要取消该timeout，阻止标记
+     */
+    delayedMarkContainer(event: MouseEvent, excludeElList?: Element[]): NodeJS.Timeout;
+    destroy(): void;
+    private changeCallback;
+    /**
+     * 在执行多选逻辑前，先准备好多选选中元素
+     * @param el 新选中的元素
+     * @returns 多选选中的元素列表
+     */
+    private beforeMultiSelect;
+    /**
+     * 当前状态下能否将组件加入容器，默认是鼠标悬停一段时间加入，alt模式则是按住alt+鼠标悬停一段时间加入
+     */
+    private canAddToContainer;
+    /**
+     * 结束对container的标记状态
+     * @returns 标记的容器元素，没有标记的容器时返回null
+     */
+    private markContainerEnd;
+    private initMouseEvent;
+    /**
+     * 初始化键盘事件监听
+     */
+    private initKeyEvent;
+    /**
+     * 处理单选、多选抛出来的事件
+     */
+    private initActionEvent;
+    /**
+     * 在down事件中集中cpu处理画布中选中操作渲染，在up事件中再通知外面的编辑器更新
+     */
+    private mouseDownHandler;
+    private isStopTriggerSelect;
+    /**
+     * 在up事件中负责对外通知选中事件，通知画布之外的编辑器更新
+     */
+    private mouseUpHandler;
+    private mouseLeaveHandler;
+    private mouseWheelHandler;
+}