@thienvu18/designable-core 2.0.0

package/esm/events/mutation/SelectNodeEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export declare class SelectNodeEvent extends AbstractMutationNodeEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/mutation/SelectNodeEvent.js

@@ -0,0 +1,7 @@
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export class SelectNodeEvent extends AbstractMutationNodeEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'select:node';
+    }
+}

package/esm/events/mutation/UnSelectNodeEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export declare class UnSelectNodeEvent extends AbstractMutationNodeEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/mutation/UnSelectNodeEvent.js

@@ -0,0 +1,7 @@
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export class UnSelectNodeEvent extends AbstractMutationNodeEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'unselect:node';
+    }
+}

package/esm/events/mutation/UpdateChildrenEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export declare class UpdateChildrenEvent extends AbstractMutationNodeEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/mutation/UpdateChildrenEvent.js

@@ -0,0 +1,7 @@
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export class UpdateChildrenEvent extends AbstractMutationNodeEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'update:children';
+    }
+}

package/esm/events/mutation/UpdateNodePropsEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export declare class UpdateNodePropsEvent extends AbstractMutationNodeEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/mutation/UpdateNodePropsEvent.js

@@ -0,0 +1,7 @@
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export class UpdateNodePropsEvent extends AbstractMutationNodeEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'update:node:props';
+    }
+}

package/esm/events/mutation/UserSelectNodeEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export declare class SelectNodeEvent extends AbstractMutationNodeEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/mutation/UserSelectNodeEvent.js

@@ -0,0 +1,7 @@
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export class SelectNodeEvent extends AbstractMutationNodeEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'user:select:node';
+    }
+}

package/esm/events/mutation/WrapNodeEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export declare class WrapNodeEvent extends AbstractMutationNodeEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/mutation/WrapNodeEvent.js

@@ -0,0 +1,7 @@
+import { AbstractMutationNodeEvent } from './AbstractMutationNodeEvent';
+export class WrapNodeEvent extends AbstractMutationNodeEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'wrap:node';
+    }
+}

package/esm/events/mutation/index.d.ts

@@ -0,0 +1,16 @@
+export * from './DragNodeEvent';
+export * from './DropNodeEvent';
+export * from './HoverNodeEvent';
+export * from './InsertAfterEvent';
+export * from './InsertBeforeEvent';
+export * from './InsertChildrenEvent';
+export * from './PrependNodeEvent';
+export * from './RemoveNodeEvent';
+export * from './SelectNodeEvent';
+export * from './UnSelectNodeEvent';
+export * from './UpdateChildrenEvent';
+export * from './UpdateNodePropsEvent';
+export * from './WrapNodeEvent';
+export * from './CloneNodeEvent';
+export * from './AppendNodeEvent';
+export * from './FromNodeEvent';

package/esm/events/mutation/index.js

@@ -0,0 +1,16 @@
+export * from './DragNodeEvent';
+export * from './DropNodeEvent';
+export * from './HoverNodeEvent';
+export * from './InsertAfterEvent';
+export * from './InsertBeforeEvent';
+export * from './InsertChildrenEvent';
+export * from './PrependNodeEvent';
+export * from './RemoveNodeEvent';
+export * from './SelectNodeEvent';
+export * from './UnSelectNodeEvent';
+export * from './UpdateChildrenEvent';
+export * from './UpdateNodePropsEvent';
+export * from './WrapNodeEvent';
+export * from './CloneNodeEvent';
+export * from './AppendNodeEvent';
+export * from './FromNodeEvent';

package/esm/events/viewport/AbstractViewportEvent.d.ts

@@ -0,0 +1,16 @@
+import { IEngineContext } from '../../types';
+export interface IViewportEventData {
+    scrollX: number;
+    scrollY: number;
+    width: number;
+    height: number;
+    view: Window;
+    innerWidth: number;
+    innerHeight: number;
+    target: EventTarget;
+}
+export declare class AbstractViewportEvent {
+    data: IViewportEventData;
+    context: IEngineContext;
+    constructor(data: IViewportEventData);
+}

package/esm/events/viewport/AbstractViewportEvent.js

@@ -0,0 +1,15 @@
+import { globalThisPolyfill } from '@thienvu18/designable-shared';
+export class AbstractViewportEvent {
+    constructor(data) {
+        this.data = data || {
+            scrollX: globalThisPolyfill.scrollX,
+            scrollY: globalThisPolyfill.scrollY,
+            width: globalThisPolyfill.innerWidth,
+            height: globalThisPolyfill.innerHeight,
+            innerWidth: globalThisPolyfill.innerWidth,
+            innerHeight: globalThisPolyfill.innerHeight,
+            view: globalThisPolyfill,
+            target: globalThisPolyfill,
+        };
+    }
+}

package/esm/events/viewport/ViewportResizeEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractViewportEvent } from './AbstractViewportEvent';
+export declare class ViewportResizeEvent extends AbstractViewportEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/viewport/ViewportResizeEvent.js

@@ -0,0 +1,7 @@
+import { AbstractViewportEvent } from './AbstractViewportEvent';
+export class ViewportResizeEvent extends AbstractViewportEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'viewport:resize';
+    }
+}

package/esm/events/viewport/ViewportScrollEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractViewportEvent } from './AbstractViewportEvent';
+export declare class ViewportScrollEvent extends AbstractViewportEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/viewport/ViewportScrollEvent.js

@@ -0,0 +1,7 @@
+import { AbstractViewportEvent } from './AbstractViewportEvent';
+export class ViewportScrollEvent extends AbstractViewportEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'viewport:scroll';
+    }
+}

package/esm/events/viewport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ViewportResizeEvent';
+export * from './ViewportScrollEvent';

package/esm/events/viewport/index.js

@@ -0,0 +1,2 @@
+export * from './ViewportResizeEvent';
+export * from './ViewportScrollEvent';

package/esm/events/workbench/AbstractWorkspaceEvent.d.ts

@@ -0,0 +1,7 @@
+import { Workspace } from '../../models';
+import { IEngineContext } from '../../types';
+export declare class AbstractWorkspaceEvent {
+    data: Workspace;
+    context: IEngineContext;
+    constructor(data: Workspace);
+}

package/esm/events/workbench/AbstractWorkspaceEvent.js

@@ -0,0 +1,5 @@
+export class AbstractWorkspaceEvent {
+    constructor(data) {
+        this.data = data;
+    }
+}

package/esm/events/workbench/AddWorkspaceEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractWorkspaceEvent } from './AbstractWorkspaceEvent';
+export declare class AddWorkspaceEvent extends AbstractWorkspaceEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/workbench/AddWorkspaceEvent.js

@@ -0,0 +1,7 @@
+import { AbstractWorkspaceEvent } from './AbstractWorkspaceEvent';
+export class AddWorkspaceEvent extends AbstractWorkspaceEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'add:workspace';
+    }
+}

package/esm/events/workbench/RemoveWorkspaceEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractWorkspaceEvent } from './AbstractWorkspaceEvent';
+export declare class RemoveWorkspaceEvent extends AbstractWorkspaceEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/workbench/RemoveWorkspaceEvent.js

@@ -0,0 +1,7 @@
+import { AbstractWorkspaceEvent } from './AbstractWorkspaceEvent';
+export class RemoveWorkspaceEvent extends AbstractWorkspaceEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'remove:workspace';
+    }
+}

package/esm/events/workbench/SwitchWorkspaceEvent.d.ts

@@ -0,0 +1,5 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractWorkspaceEvent } from './AbstractWorkspaceEvent';
+export declare class SwitchWorkspaceEvent extends AbstractWorkspaceEvent implements ICustomEvent {
+    type: string;
+}

package/esm/events/workbench/SwitchWorkspaceEvent.js

@@ -0,0 +1,7 @@
+import { AbstractWorkspaceEvent } from './AbstractWorkspaceEvent';
+export class SwitchWorkspaceEvent extends AbstractWorkspaceEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'switch:workspace';
+    }
+}

package/esm/events/workbench/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AddWorkspaceEvent';
+export * from './RemoveWorkspaceEvent';
+export * from './SwitchWorkspaceEvent';

package/esm/events/workbench/index.js

@@ -0,0 +1,3 @@
+export * from './AddWorkspaceEvent';
+export * from './RemoveWorkspaceEvent';
+export * from './SwitchWorkspaceEvent';

package/esm/exports.d.ts

@@ -0,0 +1,5 @@
+export * from './externals';
+export * from './registry';
+export * from './models';
+export * from './events';
+export * from './types';

package/esm/exports.js

@@ -0,0 +1,5 @@
+export * from './externals';
+export * from './registry';
+export * from './models';
+export * from './events';
+export * from './types';

package/esm/externals.d.ts

@@ -0,0 +1,12 @@
+import { Engine } from './models';
+import { IEngineProps, IResourceCreator, IBehaviorCreator, IDesignerLocales, IResource, IBehavior, IBehaviorHost, IResourceHost } from './types';
+export declare const isBehaviorHost: (val: any) => val is IBehaviorHost;
+export declare const isBehaviorList: (val: any) => val is IBehavior[];
+export declare const isBehavior: (val: any) => val is IBehavior;
+export declare const isResourceHost: (val: any) => val is IResourceHost;
+export declare const isResourceList: (val: any) => val is IResource[];
+export declare const isResource: (val: any) => val is IResource;
+export declare const createLocales: (...packages: IDesignerLocales[]) => {};
+export declare const createBehavior: (...behaviors: Array<IBehaviorCreator | IBehaviorCreator[]>) => IBehavior[];
+export declare const createResource: (...sources: IResourceCreator[]) => IResource[];
+export declare const createDesigner: (props?: IEngineProps<Engine>) => Engine;

package/esm/externals.js

@@ -0,0 +1,58 @@
+import { isArr } from '@thienvu18/designable-shared';
+import { untracked } from '@formily/reactive';
+import { DEFAULT_DRIVERS, DEFAULT_EFFECTS, DEFAULT_SHORTCUTS } from './presets';
+import { Engine, TreeNode } from './models';
+import { mergeLocales } from './internals';
+export const isBehaviorHost = (val) => val?.Behavior && isBehaviorList(val.Behavior);
+export const isBehaviorList = (val) => Array.isArray(val) && val.every(isBehavior);
+export const isBehavior = (val) => val?.name ||
+    val?.selector ||
+    val?.extends ||
+    val?.designerProps ||
+    val?.designerLocales;
+export const isResourceHost = (val) => val?.Resource && isResourceList(val.Resource);
+export const isResourceList = (val) => Array.isArray(val) && val.every(isResource);
+export const isResource = (val) => val?.node && !!val.node.isSourceNode && val.node instanceof TreeNode;
+export const createLocales = (...packages) => {
+    const results = {};
+    packages.forEach((locales) => {
+        mergeLocales(results, locales);
+    });
+    return results;
+};
+export const createBehavior = (...behaviors) => {
+    return behaviors.reduce((buf, behavior) => {
+        if (isArr(behavior))
+            return buf.concat(createBehavior(...behavior));
+        const { selector } = behavior || {};
+        if (!selector)
+            return buf;
+        if (typeof selector === 'string') {
+            behavior.selector = (node) => node.componentName === selector;
+        }
+        return buf.concat(behavior);
+    }, []);
+};
+export const createResource = (...sources) => {
+    return sources.reduce((buf, source) => {
+        return buf.concat({
+            ...source,
+            node: new TreeNode({
+                componentName: '$$ResourceNode$$',
+                isSourceNode: true,
+                children: source.elements || [],
+            }),
+        });
+    }, []);
+};
+export const createDesigner = (props = {}) => {
+    const drivers = props.drivers || [];
+    const effects = props.effects || [];
+    const shortcuts = props.shortcuts || [];
+    return untracked(() => new Engine({
+        ...props,
+        effects: [...effects, ...DEFAULT_EFFECTS],
+        drivers: [...drivers, ...DEFAULT_DRIVERS],
+        shortcuts: [...shortcuts, ...DEFAULT_SHORTCUTS],
+    }));
+};

package/esm/index.d.ts

@@ -0,0 +1 @@
+export * from './exports';

package/esm/index.js

@@ -0,0 +1,15 @@
+import * as Core from './exports';
+export * from './exports';
+import { globalThisPolyfill } from '@thienvu18/designable-shared';
+if (globalThisPolyfill?.['Designable']?.['Core']) {
+    if (module.exports) {
+        module.exports = {
+            __esModule: true,
+            ...globalThisPolyfill['Designable']['Core'],
+        };
+    }
+}
+else {
+    globalThisPolyfill['Designable'] = globalThisPolyfill['Designable'] || {};
+    globalThisPolyfill['Designable'].Core = Core;
+}

package/esm/internals.d.ts

@@ -0,0 +1,3 @@
+export declare const lowerSnake: (str: string) => string;
+export declare const mergeLocales: (target: any, source: any) => any;
+export declare const getBrowserLanguage: () => any;

package/esm/internals.js

@@ -0,0 +1,33 @@
+import { each, isPlainObj } from '@thienvu18/designable-shared';
+import { globalThisPolyfill } from '@thienvu18/designable-shared';
+export const lowerSnake = (str) => {
+    return String(str).replace(/\s+/g, '_').toLocaleLowerCase();
+};
+export const mergeLocales = (target, source) => {
+    if (isPlainObj(target) && isPlainObj(source)) {
+        each(source, function (value, key) {
+            const token = lowerSnake(key);
+            const messages = mergeLocales(target[key] || target[token], value);
+            target[token] = messages;
+        });
+        return target;
+    }
+    else if (isPlainObj(source)) {
+        const result = Array.isArray(source) ? [] : {};
+        each(source, function (value, key) {
+            const messages = mergeLocales(undefined, value);
+            result[lowerSnake(key)] = messages;
+        });
+        return result;
+    }
+    return source;
+};
+export const getBrowserLanguage = () => {
+    /* istanbul ignore next */
+    if (!globalThisPolyfill.navigator) {
+        return 'en';
+    }
+    return (globalThisPolyfill.navigator['browserlanguage'] ||
+        globalThisPolyfill.navigator?.language ||
+        'en');
+};

package/esm/models/Cursor.d.ts

@@ -0,0 +1,60 @@
+import { Engine } from './Engine';
+export declare enum CursorStatus {
+    Normal = "NORMAL",
+    DragStart = "DRAG_START",
+    Dragging = "DRAGGING",
+    DragStop = "DRAG_STOP"
+}
+export declare enum CursorDragType {
+    Move = "MOVE",
+    Resize = "RESIZE",
+    Rotate = "ROTATE",
+    Scale = "SCALE",
+    Translate = "TRANSLATE",
+    Round = "ROUND"
+}
+export declare enum CursorType {
+    Normal = "NORMAL",
+    Selection = "SELECTION",
+    Sketch = "SKETCH"
+}
+export interface ICursorPosition {
+    pageX?: number;
+    pageY?: number;
+    clientX?: number;
+    clientY?: number;
+    topPageX?: number;
+    topPageY?: number;
+    topClientX?: number;
+    topClientY?: number;
+}
+export interface ICursor {
+    status?: CursorStatus;
+    position?: ICursorPosition;
+    dragStartPosition?: ICursorPosition;
+    dragEndPosition?: ICursorPosition;
+    view?: Window;
+}
+export declare class Cursor {
+    engine: Engine;
+    type: CursorType | string;
+    dragType: CursorDragType | string;
+    status: CursorStatus;
+    position: ICursorPosition;
+    dragStartPosition: ICursorPosition;
+    dragEndPosition: ICursorPosition;
+    dragAtomDelta: ICursorPosition;
+    dragStartToCurrentDelta: ICursorPosition;
+    dragStartToEndDelta: ICursorPosition;
+    view: Window;
+    constructor(engine: Engine);
+    makeObservable(): void;
+    get speed(): number;
+    setStatus(status: CursorStatus): void;
+    setType(type: CursorType | string): void;
+    setDragType(type: CursorDragType | string): void;
+    setStyle(style: string): void;
+    setPosition(position?: ICursorPosition): void;
+    setDragStartPosition(position?: ICursorPosition): void;
+    setDragEndPosition(position?: ICursorPosition): void;
+}

package/esm/models/Cursor.js

@@ -0,0 +1,133 @@
+import { action, define, observable } from '@formily/reactive';
+import { globalThisPolyfill, isValidNumber } from '@thienvu18/designable-shared';
+export var CursorStatus;
+(function (CursorStatus) {
+    CursorStatus["Normal"] = "NORMAL";
+    CursorStatus["DragStart"] = "DRAG_START";
+    CursorStatus["Dragging"] = "DRAGGING";
+    CursorStatus["DragStop"] = "DRAG_STOP";
+})(CursorStatus || (CursorStatus = {}));
+export var CursorDragType;
+(function (CursorDragType) {
+    CursorDragType["Move"] = "MOVE";
+    CursorDragType["Resize"] = "RESIZE";
+    CursorDragType["Rotate"] = "ROTATE";
+    CursorDragType["Scale"] = "SCALE";
+    CursorDragType["Translate"] = "TRANSLATE";
+    CursorDragType["Round"] = "ROUND";
+})(CursorDragType || (CursorDragType = {}));
+export var CursorType;
+(function (CursorType) {
+    CursorType["Normal"] = "NORMAL";
+    CursorType["Selection"] = "SELECTION";
+    CursorType["Sketch"] = "SKETCH";
+})(CursorType || (CursorType = {}));
+const DEFAULT_POSITION = {
+    pageX: 0,
+    pageY: 0,
+    clientX: 0,
+    clientY: 0,
+    topPageX: 0,
+    topPageY: 0,
+    topClientX: 0,
+    topClientY: 0,
+};
+const setCursorStyle = (contentWindow, style) => {
+    const currentRoot = document?.getElementsByTagName?.('html')?.[0];
+    const root = contentWindow?.document?.getElementsByTagName('html')?.[0];
+    if (root && root.style.cursor !== style) {
+        root.style.cursor = style;
+    }
+    if (currentRoot && currentRoot.style.cursor !== style) {
+        currentRoot.style.cursor = style;
+    }
+};
+const calcPositionDelta = (end, start) => {
+    return Object.keys(end || {}).reduce((buf, key) => {
+        if (isValidNumber(end?.[key]) && isValidNumber(start?.[key])) {
+            buf[key] = end[key] - start[key];
+        }
+        else {
+            buf[key] = end[key];
+        }
+        return buf;
+    }, {});
+};
+export class Cursor {
+    constructor(engine) {
+        this.type = CursorType.Normal;
+        this.dragType = CursorDragType.Move;
+        this.status = CursorStatus.Normal;
+        this.position = DEFAULT_POSITION;
+        this.dragAtomDelta = DEFAULT_POSITION;
+        this.dragStartToCurrentDelta = DEFAULT_POSITION;
+        this.dragStartToEndDelta = DEFAULT_POSITION;
+        this.view = globalThisPolyfill;
+        this.engine = engine;
+        this.makeObservable();
+    }
+    makeObservable() {
+        define(this, {
+            type: observable.ref,
+            dragType: observable.ref,
+            status: observable.ref,
+            position: observable.ref,
+            dragStartPosition: observable.ref,
+            dragEndPosition: observable.ref,
+            dragAtomDelta: observable.ref,
+            dragStartToCurrentDelta: observable.ref,
+            dragStartToEndDelta: observable.ref,
+            view: observable.ref,
+            setStyle: action,
+            setPosition: action,
+            setStatus: action,
+            setType: action,
+        });
+    }
+    get speed() {
+        return Math.sqrt(Math.pow(this.dragAtomDelta.clientX, 2) +
+            Math.pow(this.dragAtomDelta.clientY, 2));
+    }
+    setStatus(status) {
+        this.status = status;
+    }
+    setType(type) {
+        this.type = type;
+    }
+    setDragType(type) {
+        this.dragType = type;
+    }
+    setStyle(style) {
+        this.engine.workbench.eachWorkspace((workspace) => {
+            setCursorStyle(workspace.viewport.contentWindow, style);
+        });
+    }
+    setPosition(position) {
+        this.dragAtomDelta = calcPositionDelta(this.position, position);
+        this.position = { ...position };
+        if (this.status === CursorStatus.Dragging) {
+            this.dragStartToCurrentDelta = calcPositionDelta(this.position, this.dragStartPosition);
+        }
+    }
+    setDragStartPosition(position) {
+        if (position) {
+            this.dragStartPosition = { ...position };
+        }
+        else {
+            this.dragStartPosition = null;
+            this.dragStartToCurrentDelta = DEFAULT_POSITION;
+        }
+    }
+    setDragEndPosition(position) {
+        if (!this.dragStartPosition)
+            return;
+        if (position) {
+            this.dragEndPosition = { ...position };
+            this.dragStartToEndDelta = calcPositionDelta(this.dragStartPosition, this.dragEndPosition);
+        }
+        else {
+            this.dragEndPosition = null;
+            this.dragStartToEndDelta = DEFAULT_POSITION;
+        }
+    }
+}

package/esm/models/Engine.d.ts

@@ -0,0 +1,29 @@
+import { IEngineProps } from '../types';
+import { ITreeNode, TreeNode } from './TreeNode';
+import { Workbench } from './Workbench';
+import { Cursor } from './Cursor';
+import { Keyboard } from './Keyboard';
+import { Screen } from './Screen';
+import { Event } from '@thienvu18/designable-shared';
+/**
+ * 设计器引擎
+ */
+export declare class Engine extends Event {
+    id: string;
+    props: IEngineProps<Engine>;
+    cursor: Cursor;
+    workbench: Workbench;
+    keyboard: Keyboard;
+    screen: Screen;
+    constructor(props: IEngineProps<Engine>);
+    init(): void;
+    setCurrentTree(tree?: ITreeNode): void;
+    getCurrentTree(): TreeNode;
+    getAllSelectedNodes(): TreeNode[];
+    findNodeById(id: string): TreeNode;
+    findMovingNodes(): TreeNode[];
+    createNode(node: ITreeNode, parent?: TreeNode): TreeNode;
+    mount(): void;
+    unmount(): void;
+    static defaultProps: IEngineProps<Engine>;
+}