@mdesignable/core 1.0.0-beta.64

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 '@mdesignable/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,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractKeyboardEvent = void 0;
+var shared_1 = require("@mdesignable/shared");
+var AbstractKeyboardEvent = /** @class */ (function () {
+    function AbstractKeyboardEvent(e) {
+        this.data = (0, shared_1.getKeyCodeFromEvent)(e);
+        this.originEvent = e;
+    }
+    Object.defineProperty(AbstractKeyboardEvent.prototype, "eventType", {
+        get: function () {
+            return this.originEvent.type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractKeyboardEvent.prototype, "ctrlKey", {
+        get: function () {
+            return this.originEvent.ctrlKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractKeyboardEvent.prototype, "shiftKey", {
+        get: function () {
+            return this.originEvent.shiftKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractKeyboardEvent.prototype, "metaKey", {
+        get: function () {
+            return this.originEvent.metaKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractKeyboardEvent.prototype, "altkey", {
+        get: function () {
+            return this.originEvent.altKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractKeyboardEvent.prototype.preventDefault = function () {
+        if (this.originEvent.preventDefault) {
+            this.originEvent.preventDefault();
+        }
+        else {
+            this.originEvent.returnValue = false;
+        }
+    };
+    AbstractKeyboardEvent.prototype.stopPropagation = function () {
+        var _a;
+        if ((_a = this.originEvent) === null || _a === void 0 ? void 0 : _a.stopPropagation) {
+            this.originEvent.stopPropagation();
+        }
+        else {
+            this.originEvent.cancelBubble = true;
+        }
+    };
+    return AbstractKeyboardEvent;
+}());
+exports.AbstractKeyboardEvent = AbstractKeyboardEvent;

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

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

package/lib/events/keyboard/KeyDownEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyDownEvent = void 0;
+var AbstractKeyboardEvent_1 = require("./AbstractKeyboardEvent");
+var KeyDownEvent = /** @class */ (function (_super) {
+    __extends(KeyDownEvent, _super);
+    function KeyDownEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'key:down';
+        return _this;
+    }
+    return KeyDownEvent;
+}(AbstractKeyboardEvent_1.AbstractKeyboardEvent));
+exports.KeyDownEvent = KeyDownEvent;

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

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

package/lib/events/keyboard/KeyUpEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyUpEvent = void 0;
+var AbstractKeyboardEvent_1 = require("./AbstractKeyboardEvent");
+var KeyUpEvent = /** @class */ (function (_super) {
+    __extends(KeyUpEvent, _super);
+    function KeyUpEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'key:up';
+        return _this;
+    }
+    return KeyUpEvent;
+}(AbstractKeyboardEvent_1.AbstractKeyboardEvent));
+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,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMutationNodeEvent = void 0;
+var AbstractMutationNodeEvent = /** @class */ (function () {
+    function AbstractMutationNodeEvent(data) {
+        this.data = data;
+    }
+    return AbstractMutationNodeEvent;
+}());
+exports.AbstractMutationNodeEvent = AbstractMutationNodeEvent;

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

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

package/lib/events/mutation/AppendNodeEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppendNodeEvent = void 0;
+var AbstractMutationNodeEvent_1 = require("./AbstractMutationNodeEvent");
+var AppendNodeEvent = /** @class */ (function (_super) {
+    __extends(AppendNodeEvent, _super);
+    function AppendNodeEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'append:node';
+        return _this;
+    }
+    return AppendNodeEvent;
+}(AbstractMutationNodeEvent_1.AbstractMutationNodeEvent));
+exports.AppendNodeEvent = AppendNodeEvent;

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

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

package/lib/events/mutation/CloneNodeEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloneNodeEvent = void 0;
+var AbstractMutationNodeEvent_1 = require("./AbstractMutationNodeEvent");
+var CloneNodeEvent = /** @class */ (function (_super) {
+    __extends(CloneNodeEvent, _super);
+    function CloneNodeEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'clone:node';
+        return _this;
+    }
+    return CloneNodeEvent;
+}(AbstractMutationNodeEvent_1.AbstractMutationNodeEvent));
+exports.CloneNodeEvent = CloneNodeEvent;

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

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

package/lib/events/mutation/DragNodeEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragNodeEvent = void 0;
+var AbstractMutationNodeEvent_1 = require("./AbstractMutationNodeEvent");
+var DragNodeEvent = /** @class */ (function (_super) {
+    __extends(DragNodeEvent, _super);
+    function DragNodeEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'drag:node';
+        return _this;
+    }
+    return DragNodeEvent;
+}(AbstractMutationNodeEvent_1.AbstractMutationNodeEvent));
+exports.DragNodeEvent = DragNodeEvent;

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

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

package/lib/events/mutation/DropNodeEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropNodeEvent = void 0;
+var AbstractMutationNodeEvent_1 = require("./AbstractMutationNodeEvent");
+var DropNodeEvent = /** @class */ (function (_super) {
+    __extends(DropNodeEvent, _super);
+    function DropNodeEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'drop:node';
+        return _this;
+    }
+    return DropNodeEvent;
+}(AbstractMutationNodeEvent_1.AbstractMutationNodeEvent));
+exports.DropNodeEvent = DropNodeEvent;

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

@@ -0,0 +1,13 @@
+import { ICustomEvent } from '@mdesignable/shared';
+import { ITreeNode, TreeNode } from '../../models';
+import { IEngineContext } from '../../types';
+export interface IFromNodeEventData {
+    source: ITreeNode;
+    target: TreeNode;
+}
+export declare class FromNodeEvent implements ICustomEvent {
+    type: string;
+    data: IFromNodeEventData;
+    context: IEngineContext;
+    constructor(data: IFromNodeEventData);
+}

package/lib/events/mutation/FromNodeEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromNodeEvent = void 0;
+var FromNodeEvent = /** @class */ (function () {
+    function FromNodeEvent(data) {
+        this.type = 'from:node';
+        this.data = data;
+    }
+    return FromNodeEvent;
+}());
+exports.FromNodeEvent = FromNodeEvent;

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

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

package/lib/events/mutation/HoverNodeEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverNodeEvent = void 0;
+var AbstractMutationNodeEvent_1 = require("./AbstractMutationNodeEvent");
+var HoverNodeEvent = /** @class */ (function (_super) {
+    __extends(HoverNodeEvent, _super);
+    function HoverNodeEvent() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.type = 'hover:node';
+        return _this;
+    }
+    return HoverNodeEvent;
+}(AbstractMutationNodeEvent_1.AbstractMutationNodeEvent));
+exports.HoverNodeEvent = HoverNodeEvent;

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

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