@thienvu18/designable-core 2.0.0

package/lib/effects/useTranslateEffect.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTranslateEffect = void 0;
+const models_1 = require("../models");
+const events_1 = require("../events");
+const useTranslateEffect = (engine) => {
+    engine.subscribeTo(events_1.DragStartEvent, (event) => {
+        const target = event.data.target;
+        const currentWorkspace = event.context?.workspace ?? engine.workbench.activeWorkspace;
+        const handler = target?.closest(`*[${engine.props.nodeTranslateAttrName}]`);
+        if (!currentWorkspace)
+            return;
+        const helper = currentWorkspace.operation.transformHelper;
+        if (handler) {
+            const type = handler.getAttribute(engine.props.nodeTranslateAttrName);
+            if (type) {
+                const selectionElement = handler.closest(`*[${engine.props.nodeSelectionIdAttrName}]`);
+                if (selectionElement) {
+                    const nodeId = selectionElement.getAttribute(engine.props.nodeSelectionIdAttrName);
+                    if (nodeId) {
+                        const node = engine.findNodeById(nodeId);
+                        if (node) {
+                            helper.dragStart({ dragNodes: [node], type: 'translate' });
+                        }
+                    }
+                }
+            }
+        }
+    });
+    engine.subscribeTo(events_1.DragMoveEvent, (event) => {
+        if (engine.cursor.dragType !== models_1.CursorDragType.Translate)
+            return;
+        const currentWorkspace = event.context?.workspace ?? engine.workbench.activeWorkspace;
+        const helper = currentWorkspace?.operation.transformHelper;
+        const dragNodes = helper.dragNodes;
+        if (!dragNodes.length)
+            return;
+        helper.dragMove();
+        dragNodes.forEach((node) => {
+            const element = node.getElement();
+            helper.translate(node, (translate) => {
+                element.style.position = 'absolute';
+                element.style.left = '0px';
+                element.style.top = '0px';
+                element.style.transform = `translate3d(${translate.x}px,${translate.y}px,0)`;
+            });
+        });
+    });
+    engine.subscribeTo(events_1.DragStopEvent, (event) => {
+        if (engine.cursor.dragType !== models_1.CursorDragType.Translate)
+            return;
+        const currentWorkspace = event.context?.workspace ?? engine.workbench.activeWorkspace;
+        const helper = currentWorkspace?.operation.transformHelper;
+        if (helper) {
+            helper.dragEnd();
+        }
+    });
+};
+exports.useTranslateEffect = useTranslateEffect;

package/lib/effects/useViewportEffect.d.ts

@@ -0,0 +1,2 @@
+import { Engine } from '../models';
+export declare const useViewportEffect: (engine: Engine) => void;

package/lib/effects/useViewportEffect.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useViewportEffect = void 0;
+const events_1 = require("../events");
+const useViewportEffect = (engine) => {
+    engine.subscribeTo(events_1.ViewportResizeEvent, (event) => {
+        const currentWorkspace = event?.context?.workspace;
+        if (!currentWorkspace)
+            return;
+        const viewport = currentWorkspace.viewport;
+        const outline = currentWorkspace.outline;
+        if (viewport.matchViewport(event.data.target)) {
+            viewport.digestViewport();
+        }
+        if (outline.matchViewport(event.data.target)) {
+            outline.digestViewport();
+        }
+    });
+    engine.subscribeTo(events_1.ViewportScrollEvent, (event) => {
+        const currentWorkspace = event?.context?.workspace;
+        if (!currentWorkspace)
+            return;
+        const viewport = currentWorkspace.viewport;
+        const outline = currentWorkspace.outline;
+        if (viewport.matchViewport(event.data.target)) {
+            viewport.digestViewport();
+        }
+        if (outline.matchViewport(event.data.target)) {
+            outline.digestViewport();
+        }
+    });
+};
+exports.useViewportEffect = useViewportEffect;

package/lib/effects/useWorkspaceEffect.d.ts

@@ -0,0 +1,2 @@
+import { Engine } from '../models';
+export declare const useWorkspaceEffect: (engine: Engine) => void;

package/lib/effects/useWorkspaceEffect.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWorkspaceEffect = void 0;
+const events_1 = require("../events");
+const useWorkspaceEffect = (engine) => {
+    engine.subscribeWith([
+        'append:node',
+        'insert:after',
+        'insert:before',
+        'insert:children',
+        'drag:node',
+        'drop:node',
+        'prepend:node',
+        'remove:node',
+        'select:node',
+        'update:children',
+        'wrap:node',
+        'update:node:props',
+    ], (event) => {
+        if (event.context?.workbench) {
+            engine.workbench.setActiveWorkspace(event.context.workspace);
+        }
+    });
+    engine.subscribeTo(events_1.SelectNodeEvent, (event) => {
+        engine.workbench.eachWorkspace((workspace) => {
+            if (workspace !== event.context.workspace) {
+                workspace.operation.selection.clear();
+            }
+        });
+    });
+};
+exports.useWorkspaceEffect = useWorkspaceEffect;

package/lib/events/cursor/AbstractCursorEvent.d.ts

@@ -0,0 +1,21 @@
+import { IEngineContext } from '../../types';
+export interface ICursorEventOriginData {
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+    target: EventTarget;
+    view: Window;
+}
+export interface ICursorEventData extends ICursorEventOriginData {
+    topClientX?: number;
+    topClientY?: number;
+    topPageX?: number;
+    topPageY?: number;
+}
+export declare class AbstractCursorEvent {
+    data: ICursorEventData;
+    context: IEngineContext;
+    constructor(data: ICursorEventOriginData);
+    transformCoordinates(): void;
+}

package/lib/events/cursor/AbstractCursorEvent.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCursorEvent = void 0;
+const designable_shared_1 = require("@thienvu18/designable-shared");
+class AbstractCursorEvent {
+    constructor(data) {
+        this.data = data || {
+            clientX: 0,
+            clientY: 0,
+            pageX: 0,
+            pageY: 0,
+            target: null,
+            view: designable_shared_1.globalThisPolyfill,
+        };
+        this.transformCoordinates();
+    }
+    transformCoordinates() {
+        const { frameElement } = this.data?.view || {};
+        if (frameElement && this.data.view !== designable_shared_1.globalThisPolyfill) {
+            const frameRect = frameElement.getBoundingClientRect();
+            const scale = frameRect.width / frameElement['offsetWidth'];
+            this.data.topClientX = this.data.clientX * scale + frameRect.x;
+            this.data.topClientY = this.data.clientY * scale + frameRect.y;
+            this.data.topPageX =
+                this.data.pageX + frameRect.x - this.data.view.scrollX;
+            this.data.topPageY =
+                this.data.pageY + frameRect.y - this.data.view.scrollY;
+            const topElement = document.elementFromPoint(this.data.topPageX, this.data.topClientY);
+            if (topElement !== frameElement) {
+                this.data.target = topElement;
+            }
+        }
+        else {
+            this.data.topClientX = this.data.clientX;
+            this.data.topClientY = this.data.clientY;
+            this.data.topPageX = this.data.pageX;
+            this.data.topPageY = this.data.pageY;
+        }
+    }
+}
+exports.AbstractCursorEvent = AbstractCursorEvent;

package/lib/events/cursor/DragMoveEvent.d.ts

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

package/lib/events/cursor/DragMoveEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragMoveEvent = void 0;
+const AbstractCursorEvent_1 = require("./AbstractCursorEvent");
+class DragMoveEvent extends AbstractCursorEvent_1.AbstractCursorEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'drag:move';
+    }
+}
+exports.DragMoveEvent = DragMoveEvent;

package/lib/events/cursor/DragStartEvent.d.ts

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

package/lib/events/cursor/DragStartEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragStartEvent = void 0;
+const AbstractCursorEvent_1 = require("./AbstractCursorEvent");
+class DragStartEvent extends AbstractCursorEvent_1.AbstractCursorEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'drag:start';
+    }
+}
+exports.DragStartEvent = DragStartEvent;

package/lib/events/cursor/DragStopEvent.d.ts

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

package/lib/events/cursor/DragStopEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragStopEvent = void 0;
+const AbstractCursorEvent_1 = require("./AbstractCursorEvent");
+class DragStopEvent extends AbstractCursorEvent_1.AbstractCursorEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'drag:stop';
+    }
+}
+exports.DragStopEvent = DragStopEvent;

package/lib/events/cursor/MouseClickEvent.d.ts

@@ -0,0 +1,8 @@
+import { ICustomEvent } from '@thienvu18/designable-shared';
+import { AbstractCursorEvent } from './AbstractCursorEvent';
+export declare class MouseClickEvent extends AbstractCursorEvent implements ICustomEvent {
+    type: string;
+}
+export declare class MouseDoubleClickEvent extends AbstractCursorEvent implements ICustomEvent {
+    type: string;
+}

package/lib/events/cursor/MouseClickEvent.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseDoubleClickEvent = exports.MouseClickEvent = void 0;
+const AbstractCursorEvent_1 = require("./AbstractCursorEvent");
+class MouseClickEvent extends AbstractCursorEvent_1.AbstractCursorEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'mouse:click';
+    }
+}
+exports.MouseClickEvent = MouseClickEvent;
+class MouseDoubleClickEvent extends AbstractCursorEvent_1.AbstractCursorEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'mouse:dblclick';
+    }
+}
+exports.MouseDoubleClickEvent = MouseDoubleClickEvent;

package/lib/events/cursor/MouseMoveEvent.d.ts

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

package/lib/events/cursor/MouseMoveEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseMoveEvent = void 0;
+const AbstractCursorEvent_1 = require("./AbstractCursorEvent");
+class MouseMoveEvent extends AbstractCursorEvent_1.AbstractCursorEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'mouse:move';
+    }
+}
+exports.MouseMoveEvent = MouseMoveEvent;

package/lib/events/cursor/index.d.ts

@@ -0,0 +1,5 @@
+export * from './DragMoveEvent';
+export * from './DragStartEvent';
+export * from './DragStopEvent';
+export * from './MouseClickEvent';
+export * from './MouseMoveEvent';

package/lib/events/cursor/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DragMoveEvent"), exports);
+__exportStar(require("./DragStartEvent"), exports);
+__exportStar(require("./DragStopEvent"), exports);
+__exportStar(require("./MouseClickEvent"), exports);
+__exportStar(require("./MouseMoveEvent"), exports);

package/lib/events/history/AbstractHistoryEvent.d.ts

@@ -0,0 +1,6 @@
+import { IEngineContext } from '../../types';
+export declare class AbstractHistoryEvent {
+    data: any;
+    context: IEngineContext;
+    constructor(data: any);
+}

package/lib/events/history/AbstractHistoryEvent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractHistoryEvent = void 0;
+class AbstractHistoryEvent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.AbstractHistoryEvent = AbstractHistoryEvent;

package/lib/events/history/HistoryGotoEvent.d.ts

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

package/lib/events/history/HistoryGotoEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryGotoEvent = void 0;
+const AbstractHistoryEvent_1 = require("./AbstractHistoryEvent");
+class HistoryGotoEvent extends AbstractHistoryEvent_1.AbstractHistoryEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'history:goto';
+    }
+}
+exports.HistoryGotoEvent = HistoryGotoEvent;

package/lib/events/history/HistoryPushEvent.d.ts

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

package/lib/events/history/HistoryPushEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryPushEvent = void 0;
+const AbstractHistoryEvent_1 = require("./AbstractHistoryEvent");
+class HistoryPushEvent extends AbstractHistoryEvent_1.AbstractHistoryEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'history:push';
+    }
+}
+exports.HistoryPushEvent = HistoryPushEvent;

package/lib/events/history/HistoryRedoEvent.d.ts

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

package/lib/events/history/HistoryRedoEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryUndoEvent = void 0;
+const AbstractHistoryEvent_1 = require("./AbstractHistoryEvent");
+class HistoryUndoEvent extends AbstractHistoryEvent_1.AbstractHistoryEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'history:undo';
+    }
+}
+exports.HistoryUndoEvent = HistoryUndoEvent;

package/lib/events/history/HistoryUndoEvent.d.ts

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

package/lib/events/history/HistoryUndoEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryRedoEvent = void 0;
+const AbstractHistoryEvent_1 = require("./AbstractHistoryEvent");
+class HistoryRedoEvent extends AbstractHistoryEvent_1.AbstractHistoryEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'history:redo';
+    }
+}
+exports.HistoryRedoEvent = HistoryRedoEvent;

package/lib/events/history/index.d.ts

@@ -0,0 +1,4 @@
+export * from './HistoryRedoEvent';
+export * from './HistoryUndoEvent';
+export * from './HistoryGotoEvent';
+export * from './HistoryPushEvent';

package/lib/events/history/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HistoryRedoEvent"), exports);
+__exportStar(require("./HistoryUndoEvent"), exports);
+__exportStar(require("./HistoryGotoEvent"), exports);
+__exportStar(require("./HistoryPushEvent"), exports);

package/lib/events/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cursor';
+export * from './keyboard';
+export * from './mutation';
+export * from './viewport';
+export * from './workbench';
+export * from './history';

package/lib/events/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cursor"), exports);
+__exportStar(require("./keyboard"), exports);
+__exportStar(require("./mutation"), exports);
+__exportStar(require("./viewport"), exports);
+__exportStar(require("./workbench"), exports);
+__exportStar(require("./history"), exports);

package/lib/events/keyboard/AbstractKeyboardEvent.d.ts

@@ -0,0 +1,15 @@
+import { KeyCode } from '@thienvu18/designable-shared';
+import { IEngineContext } from '../../types';
+export declare class AbstractKeyboardEvent {
+    data: KeyCode;
+    context: IEngineContext;
+    originEvent: KeyboardEvent;
+    constructor(e: KeyboardEvent);
+    get eventType(): string;
+    get ctrlKey(): boolean;
+    get shiftKey(): boolean;
+    get metaKey(): boolean;
+    get altkey(): boolean;
+    preventDefault(): void;
+    stopPropagation(): void;
+}

package/lib/events/keyboard/AbstractKeyboardEvent.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractKeyboardEvent = void 0;
+const designable_shared_1 = require("@thienvu18/designable-shared");
+class AbstractKeyboardEvent {
+    constructor(e) {
+        this.data = (0, designable_shared_1.getKeyCodeFromEvent)(e);
+        this.originEvent = e;
+    }
+    get eventType() {
+        return this.originEvent.type;
+    }
+    get ctrlKey() {
+        return this.originEvent.ctrlKey;
+    }
+    get shiftKey() {
+        return this.originEvent.shiftKey;
+    }
+    get metaKey() {
+        return this.originEvent.metaKey;
+    }
+    get altkey() {
+        return this.originEvent.altKey;
+    }
+    preventDefault() {
+        if (this.originEvent.preventDefault) {
+            this.originEvent.preventDefault();
+        }
+        else {
+            this.originEvent.returnValue = false;
+        }
+    }
+    stopPropagation() {
+        if (this.originEvent?.stopPropagation) {
+            this.originEvent.stopPropagation();
+        }
+        else {
+            this.originEvent.cancelBubble = true;
+        }
+    }
+}
+exports.AbstractKeyboardEvent = AbstractKeyboardEvent;

package/lib/events/keyboard/KeyDownEvent.d.ts

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

package/lib/events/keyboard/KeyDownEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyDownEvent = void 0;
+const AbstractKeyboardEvent_1 = require("./AbstractKeyboardEvent");
+class KeyDownEvent extends AbstractKeyboardEvent_1.AbstractKeyboardEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'key:down';
+    }
+}
+exports.KeyDownEvent = KeyDownEvent;

package/lib/events/keyboard/KeyUpEvent.d.ts

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

package/lib/events/keyboard/KeyUpEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyUpEvent = void 0;
+const AbstractKeyboardEvent_1 = require("./AbstractKeyboardEvent");
+class KeyUpEvent extends AbstractKeyboardEvent_1.AbstractKeyboardEvent {
+    constructor() {
+        super(...arguments);
+        this.type = 'key:up';
+    }
+}
+exports.KeyUpEvent = KeyUpEvent;

package/lib/events/keyboard/index.d.ts

@@ -0,0 +1,2 @@
+export * from './KeyDownEvent';
+export * from './KeyUpEvent';

package/lib/events/keyboard/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./KeyDownEvent"), exports);
+__exportStar(require("./KeyUpEvent"), exports);

package/lib/events/mutation/AbstractMutationNodeEvent.d.ts

@@ -0,0 +1,13 @@
+import { TreeNode } from '../../models';
+import { IEngineContext } from '../../types';
+export interface IMutationNodeEventData {
+    source: TreeNode | TreeNode[];
+    target: TreeNode | TreeNode[];
+    originSourceParents?: TreeNode | TreeNode[];
+    extra?: any;
+}
+export declare class AbstractMutationNodeEvent {
+    data: IMutationNodeEventData;
+    context: IEngineContext;
+    constructor(data: IMutationNodeEventData);
+}

package/lib/events/mutation/AbstractMutationNodeEvent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMutationNodeEvent = void 0;
+class AbstractMutationNodeEvent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.AbstractMutationNodeEvent = AbstractMutationNodeEvent;

package/lib/events/mutation/AppendNodeEvent.d.ts

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