@mdesignable/core 1.0.0-beta.64

package/esm/types.d.ts

@@ -0,0 +1,131 @@
+import { IEventProps, Event } from '@mdesignable/shared';
+import { ISchema } from '@formily/json-schema';
+import { Engine, ITreeNode, ScreenType, Shortcut, Viewport, Workbench, Workspace, TreeNode } from './models';
+export type IEngineProps<T = Event> = IEventProps<T> & {
+    shortcuts?: Shortcut[];
+    sourceIdAttrName?: string;
+    nodeIdAttrName?: string;
+    contentEditableAttrName?: string;
+    contentEditableNodeIdAttrName?: string;
+    clickStopPropagationAttrName?: string;
+    outlineNodeIdAttrName?: string;
+    nodeSelectionIdAttrName?: string;
+    nodeDragHandlerAttrName?: string;
+    screenResizeHandlerAttrName?: string;
+    nodeResizeHandlerAttrName?: string;
+    nodeTranslateAttrName?: string;
+    defaultComponentTree?: ITreeNode;
+    defaultScreenType?: ScreenType;
+    rootComponentName?: string;
+};
+export type IEngineContext = {
+    workspace: Workspace;
+    workbench: Workbench;
+    engine: Engine;
+    viewport: Viewport;
+};
+export type IResizable = {
+    width?: (node: TreeNode, element: Element) => {
+        plus: () => void;
+        minus: () => void;
+    };
+    height?: (node: TreeNode, element: Element) => {
+        plus: () => void;
+        minus: () => void;
+    };
+};
+export type ITranslate = {
+    x: (node: TreeNode, element: HTMLElement, diffX: string | number) => {
+        translate: () => void;
+    };
+    y: (node: TreeNode, element: HTMLElement, diffY: string | number) => {
+        translate: () => void;
+    };
+};
+export interface IDesignerProps {
+    package?: string;
+    registry?: string;
+    version?: string;
+    path?: string;
+    title?: string;
+    description?: string;
+    icon?: string;
+    droppable?: boolean;
+    draggable?: boolean;
+    deletable?: boolean;
+    cloneable?: boolean;
+    resizable?: IResizable;
+    translatable?: ITranslate;
+    inlineChildrenLayout?: boolean;
+    selfRenderChildren?: boolean;
+    propsSchema?: ISchema;
+    defaultProps?: any;
+    getDragNodes?: (node: TreeNode) => TreeNode | TreeNode[];
+    getDropNodes?: (node: TreeNode, parent: TreeNode) => TreeNode | TreeNode[];
+    getComponentProps?: (node: TreeNode) => any;
+    allowAppend?: (target: TreeNode, sources?: TreeNode[]) => boolean;
+    allowSiblings?: (target: TreeNode, sources?: TreeNode[]) => boolean;
+    allowDrop?: (target: TreeNode) => boolean;
+    [key: string]: any;
+}
+export type IDesignerPropsMap = Record<string, IDesignerProps>;
+export type IDesignerControllerProps = IDesignerProps | ((node: TreeNode) => IDesignerProps);
+export type IDesignerControllerPropsMap = Record<string, IDesignerControllerProps>;
+export interface IDesignerLocales {
+    [ISOCode: string]: {
+        [key: string]: any;
+    };
+}
+export interface IDesignerMiniLocales {
+    [ISOCode: string]: string;
+}
+export interface IDesignerBehaviors {
+    [key: string]: IBehaviorHost;
+}
+export interface IDesignerStore<P> {
+    value: P;
+}
+export type IDesignerIcons = Record<string, any>;
+export type IDesignerIconsStore = IDesignerStore<IDesignerIcons>;
+export type IDesignerLocaleStore = IDesignerStore<IDesignerLocales>;
+export type IDesignerBehaviorStore = IDesignerStore<IBehavior[]>;
+export type IDesignerLanguageStore = IDesignerStore<string>;
+export type WorkbenchTypes = 'DESIGNABLE' | 'PREVIEW' | 'JSONTREE' | 'MARKUP' | (string & {});
+export interface IBehavior {
+    name: string;
+    extends?: string[];
+    selector: (node: TreeNode) => boolean;
+    designerProps?: IDesignerControllerProps;
+    designerLocales?: IDesignerLocales;
+}
+export interface IBehaviorCreator {
+    name: string;
+    extends?: string[];
+    selector: string | ((node: TreeNode) => boolean);
+    designerProps?: IDesignerControllerProps;
+    designerLocales?: IDesignerLocales;
+}
+export interface IBehaviorHost {
+    Behavior?: IBehavior[];
+}
+export type IBehaviorLike = IBehavior[] | IBehaviorHost;
+export interface IResource {
+    title?: string | IDesignerMiniLocales;
+    description?: string | IDesignerMiniLocales;
+    icon?: any;
+    thumb?: string;
+    span?: number;
+    node?: TreeNode;
+}
+export interface IResourceHost {
+    Resource?: IResource[];
+}
+export type IResourceLike = IResource[] | IResourceHost;
+export interface IResourceCreator {
+    title?: string | IDesignerMiniLocales;
+    description?: string | IDesignerMiniLocales;
+    icon?: any;
+    thumb?: string;
+    span?: number;
+    elements?: ITreeNode[];
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/lib/drivers/DragDropDriver.d.ts

@@ -0,0 +1,14 @@
+import { EventDriver } from '@mdesignable/shared';
+import { Engine } from '../models/Engine';
+export declare class DragDropDriver extends EventDriver<Engine> {
+    mouseDownTimer: any;
+    startEvent: MouseEvent;
+    onMouseDown: (e: MouseEvent) => boolean;
+    onMouseUp: (e: MouseEvent) => void;
+    onMouseMove: (e: MouseEvent | DragEvent) => void;
+    onContextMenuWhileDragging: (e: MouseEvent) => void;
+    onStartDrag: (e: MouseEvent | DragEvent) => void;
+    onDistanceChange: (e: MouseEvent) => void;
+    attach(): void;
+    detach(): void;
+}

package/lib/drivers/DragDropDriver.js

@@ -0,0 +1,160 @@
+"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.DragDropDriver = void 0;
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+var GlobalState = {
+    dragging: false,
+    onMouseDownAt: 0,
+    startEvent: null,
+    moveEvent: null,
+};
+var DragDropDriver = /** @class */ (function (_super) {
+    __extends(DragDropDriver, _super);
+    function DragDropDriver() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.mouseDownTimer = null;
+        _this.onMouseDown = function (e) {
+            var _a, _b;
+            if (e.button !== 0 || e.ctrlKey || e.metaKey) {
+                return;
+            }
+            if (e.target['isContentEditable'] ||
+                e.target['contentEditable'] === 'true') {
+                return true;
+            }
+            if ((_b = (_a = e.target) === null || _a === void 0 ? void 0 : _a['closest']) === null || _b === void 0 ? void 0 : _b.call(_a, '.monaco-editor'))
+                return;
+            GlobalState.startEvent = e;
+            GlobalState.dragging = false;
+            GlobalState.onMouseDownAt = Date.now();
+            _this.batchAddEventListener('mouseup', _this.onMouseUp);
+            _this.batchAddEventListener('dragend', _this.onMouseUp);
+            _this.batchAddEventListener('dragstart', _this.onStartDrag);
+            _this.batchAddEventListener('mousemove', _this.onDistanceChange);
+        };
+        _this.onMouseUp = function (e) {
+            if (GlobalState.dragging) {
+                _this.dispatch(new events_1.DragStopEvent({
+                    clientX: e.clientX,
+                    clientY: e.clientY,
+                    pageX: e.pageX,
+                    pageY: e.pageY,
+                    target: e.target,
+                    view: e.view,
+                }));
+            }
+            _this.batchRemoveEventListener('contextmenu', _this.onContextMenuWhileDragging, true);
+            _this.batchRemoveEventListener('mouseup', _this.onMouseUp);
+            _this.batchRemoveEventListener('mousedown', _this.onMouseDown);
+            _this.batchRemoveEventListener('dragover', _this.onMouseMove);
+            _this.batchRemoveEventListener('mousemove', _this.onMouseMove);
+            _this.batchRemoveEventListener('mousemove', _this.onDistanceChange);
+            GlobalState.dragging = false;
+        };
+        _this.onMouseMove = function (e) {
+            var _a, _b;
+            if (e.clientX === ((_a = GlobalState.moveEvent) === null || _a === void 0 ? void 0 : _a.clientX) &&
+                e.clientY === ((_b = GlobalState.moveEvent) === null || _b === void 0 ? void 0 : _b.clientY))
+                return;
+            _this.dispatch(new events_1.DragMoveEvent({
+                clientX: e.clientX,
+                clientY: e.clientY,
+                pageX: e.pageX,
+                pageY: e.pageY,
+                target: e.target,
+                view: e.view,
+            }));
+            GlobalState.moveEvent = e;
+        };
+        _this.onContextMenuWhileDragging = function (e) {
+            e.preventDefault();
+        };
+        _this.onStartDrag = function (e) {
+            if (GlobalState.dragging)
+                return;
+            GlobalState.startEvent = GlobalState.startEvent || e;
+            _this.batchAddEventListener('dragover', _this.onMouseMove);
+            _this.batchAddEventListener('mousemove', _this.onMouseMove);
+            _this.batchAddEventListener('contextmenu', _this.onContextMenuWhileDragging, true);
+            _this.dispatch(new events_1.DragStartEvent({
+                clientX: GlobalState.startEvent.clientX,
+                clientY: GlobalState.startEvent.clientY,
+                pageX: GlobalState.startEvent.pageX,
+                pageY: GlobalState.startEvent.pageY,
+                target: GlobalState.startEvent.target,
+                view: GlobalState.startEvent.view,
+            }));
+            GlobalState.dragging = true;
+        };
+        _this.onDistanceChange = function (e) {
+            var distance = Math.sqrt(Math.pow(e.pageX - GlobalState.startEvent.pageX, 2) +
+                Math.pow(e.pageY - GlobalState.startEvent.pageY, 2));
+            var timeDelta = Date.now() - GlobalState.onMouseDownAt;
+            if (timeDelta > 10 && e !== GlobalState.startEvent && distance > 4) {
+                _this.batchRemoveEventListener('mousemove', _this.onDistanceChange);
+                _this.onStartDrag(e);
+            }
+        };
+        return _this;
+    }
+    DragDropDriver.prototype.attach = function () {
+        this.batchAddEventListener('mousedown', this.onMouseDown, true);
+    };
+    DragDropDriver.prototype.detach = function () {
+        GlobalState.dragging = false;
+        GlobalState.moveEvent = null;
+        GlobalState.onMouseDownAt = null;
+        GlobalState.startEvent = null;
+        this.batchRemoveEventListener('mousedown', this.onMouseDown, true);
+        this.batchRemoveEventListener('dragstart', this.onStartDrag);
+        this.batchRemoveEventListener('dragend', this.onMouseUp);
+        this.batchRemoveEventListener('dragover', this.onMouseMove);
+        this.batchRemoveEventListener('mouseup', this.onMouseUp);
+        this.batchRemoveEventListener('mousemove', this.onMouseMove);
+        this.batchRemoveEventListener('mousemove', this.onDistanceChange);
+        this.batchRemoveEventListener('contextmenu', this.onContextMenuWhileDragging, true);
+    };
+    return DragDropDriver;
+}(shared_1.EventDriver));
+exports.DragDropDriver = DragDropDriver;

package/lib/drivers/KeyboardDriver.d.ts

@@ -0,0 +1,7 @@
+import { EventDriver } from '@mdesignable/shared';
+export declare class KeyboardDriver extends EventDriver {
+    onKeyDown: (e: KeyboardEvent) => void;
+    onKeyUp: (e: KeyboardEvent) => void;
+    attach(): void;
+    detach(): void;
+}

package/lib/drivers/KeyboardDriver.js

@@ -0,0 +1,93 @@
+"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.KeyboardDriver = void 0;
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+function filter(event) {
+    var target = event.target;
+    var tagName = target.tagName;
+    var flag = true;
+    // ignore: isContentEditable === 'true', <input> and <textarea> when readOnly state is false, <select>、Web Components
+    if (target['isContentEditable'] ||
+        ((tagName === 'INPUT' ||
+            tagName === 'TEXTAREA' ||
+            tagName === 'SELECT' ||
+            customElements.get(tagName.toLocaleLowerCase())) &&
+            !target.readOnly)) {
+        flag = false;
+    }
+    return flag;
+}
+var KeyboardDriver = /** @class */ (function (_super) {
+    __extends(KeyboardDriver, _super);
+    function KeyboardDriver() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.onKeyDown = function (e) {
+            if (!filter(e))
+                return;
+            _this.dispatch(new events_1.KeyDownEvent(e));
+        };
+        _this.onKeyUp = function (e) {
+            _this.dispatch(new events_1.KeyUpEvent(e));
+        };
+        return _this;
+    }
+    KeyboardDriver.prototype.attach = function () {
+        this.addEventListener('keydown', this.onKeyDown, {
+            mode: 'onlyParent',
+        });
+        this.addEventListener('keyup', this.onKeyUp, {
+            mode: 'onlyParent',
+        });
+    };
+    KeyboardDriver.prototype.detach = function () {
+        this.removeEventListener('keydown', this.onKeyDown, {
+            mode: 'onlyParent',
+        });
+        this.removeEventListener('keyup', this.onKeyUp, {
+            mode: 'onlyParent',
+        });
+    };
+    return KeyboardDriver;
+}(shared_1.EventDriver));
+exports.KeyboardDriver = KeyboardDriver;

package/lib/drivers/MouseClickDriver.d.ts

@@ -0,0 +1,8 @@
+import { EventDriver } from '@mdesignable/shared';
+import { Engine } from '../models/Engine';
+export declare class MouseClickDriver extends EventDriver<Engine> {
+    onMouseClick: (e: MouseEvent) => void;
+    onMouseDoubleClick: (e: MouseEvent) => void;
+    attach(): void;
+    detach(): void;
+}

package/lib/drivers/MouseClickDriver.js

@@ -0,0 +1,98 @@
+"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.MouseClickDriver = void 0;
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+var MouseClickDriver = /** @class */ (function (_super) {
+    __extends(MouseClickDriver, _super);
+    function MouseClickDriver() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.onMouseClick = function (e) {
+            var target = e.target;
+            if (target === null || target === void 0 ? void 0 : target.closest("*[".concat(_this.engine.props.clickStopPropagationAttrName, "]"))) {
+                return;
+            }
+            _this.dispatch(new events_1.MouseClickEvent({
+                clientX: e.clientX,
+                clientY: e.clientY,
+                pageX: e.pageX,
+                pageY: e.pageY,
+                target: e.target,
+                view: e.view,
+            }));
+        };
+        _this.onMouseDoubleClick = function (e) {
+            var target = e.target;
+            if (target === null || target === void 0 ? void 0 : target.closest("*[".concat(_this.engine.props.clickStopPropagationAttrName, "]"))) {
+                return;
+            }
+            _this.dispatch(new events_1.MouseDoubleClickEvent({
+                clientX: e.clientX,
+                clientY: e.clientY,
+                pageX: e.pageX,
+                pageY: e.pageY,
+                target: e.target,
+                view: e.view,
+            }));
+        };
+        return _this;
+    }
+    MouseClickDriver.prototype.attach = function () {
+        this.addEventListener('click', this.onMouseClick, {
+            mode: 'onlyChild',
+        });
+        this.addEventListener('dblclick', this.onMouseDoubleClick, {
+            mode: 'onlyChild',
+        });
+    };
+    MouseClickDriver.prototype.detach = function () {
+        this.removeEventListener('click', this.onMouseClick, {
+            mode: 'onlyChild',
+        });
+        this.removeEventListener('dblclick', this.onMouseDoubleClick, {
+            mode: 'onlyChild',
+        });
+    };
+    return MouseClickDriver;
+}(shared_1.EventDriver));
+exports.MouseClickDriver = MouseClickDriver;

package/lib/drivers/MouseMoveDriver.d.ts

@@ -0,0 +1,8 @@
+import { EventDriver } from '@mdesignable/shared';
+import { Engine } from '../models/Engine';
+export declare class MouseMoveDriver extends EventDriver<Engine> {
+    request: any;
+    onMouseMove: (e: MouseEvent) => void;
+    attach(): void;
+    detach(): void;
+}

package/lib/drivers/MouseMoveDriver.js

@@ -0,0 +1,78 @@
+"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.MouseMoveDriver = void 0;
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+var MouseMoveDriver = /** @class */ (function (_super) {
+    __extends(MouseMoveDriver, _super);
+    function MouseMoveDriver() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.request = null;
+        _this.onMouseMove = function (e) {
+            _this.request = requestAnimationFrame(function () {
+                cancelAnimationFrame(_this.request);
+                _this.dispatch(new events_1.MouseMoveEvent({
+                    clientX: e.clientX,
+                    clientY: e.clientY,
+                    pageX: e.pageX,
+                    pageY: e.pageY,
+                    target: e.target,
+                    view: e.view,
+                }));
+            });
+        };
+        return _this;
+    }
+    MouseMoveDriver.prototype.attach = function () {
+        this.addEventListener('mousemove', this.onMouseMove, {
+            mode: 'onlyOne',
+        });
+    };
+    MouseMoveDriver.prototype.detach = function () {
+        this.removeEventListener('mouseover', this.onMouseMove, {
+            mode: 'onlyOne',
+        });
+    };
+    return MouseMoveDriver;
+}(shared_1.EventDriver));
+exports.MouseMoveDriver = MouseMoveDriver;

package/lib/drivers/ViewportResizeDriver.d.ts

@@ -0,0 +1,10 @@
+import { EventDriver } from '@mdesignable/shared';
+import { Engine } from '../models/Engine';
+import { ResizeObserver } from '@juggle/resize-observer';
+export declare class ViewportResizeDriver extends EventDriver<Engine> {
+    request: any;
+    resizeObserver: ResizeObserver;
+    onResize: import("lodash").DebouncedFunc<(e: any) => void>;
+    attach(): void;
+    detach(): void;
+}