@mdesignable/core 1.0.0-beta.64

package/lib/externals.js

@@ -0,0 +1,126 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.createDesigner = exports.createResource = exports.createBehavior = exports.createLocales = exports.isResource = exports.isResourceList = exports.isResourceHost = exports.isBehavior = exports.isBehaviorList = exports.isBehaviorHost = void 0;
+var shared_1 = require("@mdesignable/shared");
+var reactive_1 = require("@formily/reactive");
+var presets_1 = require("./presets");
+var models_1 = require("./models");
+var internals_1 = require("./internals");
+var isBehaviorHost = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.Behavior) && (0, exports.isBehaviorList)(val.Behavior);
+};
+exports.isBehaviorHost = isBehaviorHost;
+var isBehaviorList = function (val) {
+    return Array.isArray(val) && val.every(exports.isBehavior);
+};
+exports.isBehaviorList = isBehaviorList;
+var isBehavior = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.name) ||
+        (val === null || val === void 0 ? void 0 : val.selector) ||
+        (val === null || val === void 0 ? void 0 : val.extends) ||
+        (val === null || val === void 0 ? void 0 : val.designerProps) ||
+        (val === null || val === void 0 ? void 0 : val.designerLocales);
+};
+exports.isBehavior = isBehavior;
+var isResourceHost = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.Resource) && (0, exports.isResourceList)(val.Resource);
+};
+exports.isResourceHost = isResourceHost;
+var isResourceList = function (val) {
+    return Array.isArray(val) && val.every(exports.isResource);
+};
+exports.isResourceList = isResourceList;
+var isResource = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.node) && !!val.node.isSourceNode && val.node instanceof models_1.TreeNode;
+};
+exports.isResource = isResource;
+var createLocales = function () {
+    var packages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        packages[_i] = arguments[_i];
+    }
+    var results = {};
+    packages.forEach(function (locales) {
+        (0, internals_1.mergeLocales)(results, locales);
+    });
+    return results;
+};
+exports.createLocales = createLocales;
+var createBehavior = function () {
+    var behaviors = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        behaviors[_i] = arguments[_i];
+    }
+    return behaviors.reduce(function (buf, behavior) {
+        if ((0, shared_1.isArr)(behavior))
+            return buf.concat(exports.createBehavior.apply(void 0, __spreadArray([], __read(behavior), false)));
+        var selector = (behavior || {}).selector;
+        if (!selector)
+            return buf;
+        if (typeof selector === 'string') {
+            behavior.selector = function (node) { return node.componentName === selector; };
+        }
+        return buf.concat(behavior);
+    }, []);
+};
+exports.createBehavior = createBehavior;
+var createResource = function () {
+    var sources = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+    }
+    return sources.reduce(function (buf, source) {
+        return buf.concat(__assign(__assign({}, source), { node: new models_1.TreeNode({
+                componentName: '$$ResourceNode$$',
+                isSourceNode: true,
+                children: source.elements || [],
+            }) }));
+    }, []);
+};
+exports.createResource = createResource;
+var createDesigner = function (props) {
+    if (props === void 0) { props = {}; }
+    var drivers = props.drivers || [];
+    var effects = props.effects || [];
+    var shortcuts = props.shortcuts || [];
+    return (0, reactive_1.untracked)(function () {
+        return new models_1.Engine(__assign(__assign({}, props), { effects: __spreadArray(__spreadArray([], __read(effects), false), __read(presets_1.DEFAULT_EFFECTS), false), drivers: __spreadArray(__spreadArray([], __read(drivers), false), __read(presets_1.DEFAULT_DRIVERS), false), shortcuts: __spreadArray(__spreadArray([], __read(shortcuts), false), __read(presets_1.DEFAULT_SHORTCUTS), false) }));
+    });
+};
+exports.createDesigner = createDesigner;

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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);
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+var Core = __importStar(require("./exports"));
+__exportStar(require("./exports"), exports);
+var shared_1 = require("@mdesignable/shared");
+if ((_a = shared_1.globalThisPolyfill === null || shared_1.globalThisPolyfill === void 0 ? void 0 : shared_1.globalThisPolyfill['Designable']) === null || _a === void 0 ? void 0 : _a['Core']) {
+    if (module.exports) {
+        module.exports = __assign({ __esModule: true }, shared_1.globalThisPolyfill['Designable']['Core']);
+    }
+}
+else {
+    shared_1.globalThisPolyfill['Designable'] = shared_1.globalThisPolyfill['Designable'] || {};
+    shared_1.globalThisPolyfill['Designable'].Core = Core;
+}

package/lib/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/lib/internals.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserLanguage = exports.mergeLocales = exports.lowerSnake = void 0;
+var shared_1 = require("@mdesignable/shared");
+var shared_2 = require("@mdesignable/shared");
+var lowerSnake = function (str) {
+    return String(str).replace(/\s+/g, '_').toLocaleLowerCase();
+};
+exports.lowerSnake = lowerSnake;
+var mergeLocales = function (target, source) {
+    if ((0, shared_1.isPlainObj)(target) && (0, shared_1.isPlainObj)(source)) {
+        (0, shared_1.each)(source, function (value, key) {
+            var token = (0, exports.lowerSnake)(key);
+            var messages = (0, exports.mergeLocales)(target[key] || target[token], value);
+            target[token] = messages;
+        });
+        return target;
+    }
+    else if ((0, shared_1.isPlainObj)(source)) {
+        var result_1 = Array.isArray(source) ? [] : {};
+        (0, shared_1.each)(source, function (value, key) {
+            var messages = (0, exports.mergeLocales)(undefined, value);
+            result_1[(0, exports.lowerSnake)(key)] = messages;
+        });
+        return result_1;
+    }
+    return source;
+};
+exports.mergeLocales = mergeLocales;
+var getBrowserLanguage = function () {
+    var _a;
+    /* istanbul ignore next */
+    if (!shared_2.globalThisPolyfill.navigator) {
+        return 'en';
+    }
+    return (shared_2.globalThisPolyfill.navigator['browserlanguage'] ||
+        ((_a = shared_2.globalThisPolyfill.navigator) === null || _a === void 0 ? void 0 : _a.language) ||
+        'en');
+};
+exports.getBrowserLanguage = getBrowserLanguage;

package/lib/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/lib/models/Cursor.js

@@ -0,0 +1,154 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = exports.CursorType = exports.CursorDragType = exports.CursorStatus = void 0;
+var reactive_1 = require("@formily/reactive");
+var shared_1 = require("@mdesignable/shared");
+var CursorStatus;
+(function (CursorStatus) {
+    CursorStatus["Normal"] = "NORMAL";
+    CursorStatus["DragStart"] = "DRAG_START";
+    CursorStatus["Dragging"] = "DRAGGING";
+    CursorStatus["DragStop"] = "DRAG_STOP";
+})(CursorStatus || (exports.CursorStatus = CursorStatus = {}));
+var CursorDragType;
+(function (CursorDragType) {
+    CursorDragType["Move"] = "MOVE";
+    CursorDragType["Resize"] = "RESIZE";
+    CursorDragType["Rotate"] = "ROTATE";
+    CursorDragType["Scale"] = "SCALE";
+    CursorDragType["Translate"] = "TRANSLATE";
+    CursorDragType["Round"] = "ROUND";
+})(CursorDragType || (exports.CursorDragType = CursorDragType = {}));
+var CursorType;
+(function (CursorType) {
+    CursorType["Normal"] = "NORMAL";
+    CursorType["Selection"] = "SELECTION";
+    CursorType["Sketch"] = "SKETCH";
+})(CursorType || (exports.CursorType = CursorType = {}));
+var DEFAULT_POSITION = {
+    pageX: 0,
+    pageY: 0,
+    clientX: 0,
+    clientY: 0,
+    topPageX: 0,
+    topPageY: 0,
+    topClientX: 0,
+    topClientY: 0,
+};
+var setCursorStyle = function (contentWindow, style) {
+    var _a, _b, _c, _d;
+    var currentRoot = (_b = (_a = document === null || document === void 0 ? void 0 : document.getElementsByTagName) === null || _a === void 0 ? void 0 : _a.call(document, 'html')) === null || _b === void 0 ? void 0 : _b[0];
+    var root = (_d = (_c = contentWindow === null || contentWindow === void 0 ? void 0 : contentWindow.document) === null || _c === void 0 ? void 0 : _c.getElementsByTagName('html')) === null || _d === void 0 ? void 0 : _d[0];
+    if (root && root.style.cursor !== style) {
+        root.style.cursor = style;
+    }
+    if (currentRoot && currentRoot.style.cursor !== style) {
+        currentRoot.style.cursor = style;
+    }
+};
+var calcPositionDelta = function (end, start) {
+    return Object.keys(end || {}).reduce(function (buf, key) {
+        if ((0, shared_1.isValidNumber)(end === null || end === void 0 ? void 0 : end[key]) && (0, shared_1.isValidNumber)(start === null || start === void 0 ? void 0 : start[key])) {
+            buf[key] = end[key] - start[key];
+        }
+        else {
+            buf[key] = end[key];
+        }
+        return buf;
+    }, {});
+};
+var Cursor = /** @class */ (function () {
+    function Cursor(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 = shared_1.globalThisPolyfill;
+        this.engine = engine;
+        this.makeObservable();
+    }
+    Cursor.prototype.makeObservable = function () {
+        (0, reactive_1.define)(this, {
+            type: reactive_1.observable.ref,
+            dragType: reactive_1.observable.ref,
+            status: reactive_1.observable.ref,
+            position: reactive_1.observable.ref,
+            dragStartPosition: reactive_1.observable.ref,
+            dragEndPosition: reactive_1.observable.ref,
+            dragAtomDelta: reactive_1.observable.ref,
+            dragStartToCurrentDelta: reactive_1.observable.ref,
+            dragStartToEndDelta: reactive_1.observable.ref,
+            view: reactive_1.observable.ref,
+            setStyle: reactive_1.action,
+            setPosition: reactive_1.action,
+            setStatus: reactive_1.action,
+            setType: reactive_1.action,
+        });
+    };
+    Object.defineProperty(Cursor.prototype, "speed", {
+        get: function () {
+            return Math.sqrt(Math.pow(this.dragAtomDelta.clientX, 2) +
+                Math.pow(this.dragAtomDelta.clientY, 2));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Cursor.prototype.setStatus = function (status) {
+        this.status = status;
+    };
+    Cursor.prototype.setType = function (type) {
+        this.type = type;
+    };
+    Cursor.prototype.setDragType = function (type) {
+        this.dragType = type;
+    };
+    Cursor.prototype.setStyle = function (style) {
+        this.engine.workbench.eachWorkspace(function (workspace) {
+            setCursorStyle(workspace.viewport.contentWindow, style);
+        });
+    };
+    Cursor.prototype.setPosition = function (position) {
+        this.dragAtomDelta = calcPositionDelta(this.position, position);
+        this.position = __assign({}, position);
+        if (this.status === CursorStatus.Dragging) {
+            this.dragStartToCurrentDelta = calcPositionDelta(this.position, this.dragStartPosition);
+        }
+    };
+    Cursor.prototype.setDragStartPosition = function (position) {
+        if (position) {
+            this.dragStartPosition = __assign({}, position);
+        }
+        else {
+            this.dragStartPosition = null;
+            this.dragStartToCurrentDelta = DEFAULT_POSITION;
+        }
+    };
+    Cursor.prototype.setDragEndPosition = function (position) {
+        if (!this.dragStartPosition)
+            return;
+        if (position) {
+            this.dragEndPosition = __assign({}, position);
+            this.dragStartToEndDelta = calcPositionDelta(this.dragStartPosition, this.dragEndPosition);
+        }
+        else {
+            this.dragEndPosition = null;
+            this.dragStartToEndDelta = DEFAULT_POSITION;
+        }
+    };
+    return Cursor;
+}());
+exports.Cursor = Cursor;

package/lib/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 '@mdesignable/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>;
+}

package/lib/models/Engine.js

@@ -0,0 +1,115 @@
+"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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Engine = void 0;
+var TreeNode_1 = require("./TreeNode");
+var Workbench_1 = require("./Workbench");
+var Cursor_1 = require("./Cursor");
+var Keyboard_1 = require("./Keyboard");
+var Screen_1 = require("./Screen");
+var shared_1 = require("@mdesignable/shared");
+/**
+ * 设计器引擎
+ */
+var Engine = /** @class */ (function (_super) {
+    __extends(Engine, _super);
+    function Engine(props) {
+        var _this = _super.call(this, props) || this;
+        _this.props = __assign(__assign({}, Engine.defaultProps), props);
+        _this.init();
+        _this.id = (0, shared_1.uid)();
+        return _this;
+    }
+    Engine.prototype.init = function () {
+        this.workbench = new Workbench_1.Workbench(this);
+        this.screen = new Screen_1.Screen(this);
+        this.cursor = new Cursor_1.Cursor(this);
+        this.keyboard = new Keyboard_1.Keyboard(this);
+    };
+    Engine.prototype.setCurrentTree = function (tree) {
+        if (this.workbench.currentWorkspace) {
+            this.workbench.currentWorkspace.operation.tree.from(tree);
+        }
+    };
+    Engine.prototype.getCurrentTree = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.workbench) === null || _a === void 0 ? void 0 : _a.currentWorkspace) === null || _b === void 0 ? void 0 : _b.operation) === null || _c === void 0 ? void 0 : _c.tree;
+    };
+    Engine.prototype.getAllSelectedNodes = function () {
+        var results = [];
+        for (var i = 0; i < this.workbench.workspaces.length; i++) {
+            var workspace = this.workbench.workspaces[i];
+            results = results.concat(workspace.operation.selection.selectedNodes);
+        }
+        return results;
+    };
+    Engine.prototype.findNodeById = function (id) {
+        return TreeNode_1.TreeNode.findById(id);
+    };
+    Engine.prototype.findMovingNodes = function () {
+        var results = [];
+        this.workbench.eachWorkspace(function (workspace) {
+            var _a;
+            (_a = workspace.operation.moveHelper.dragNodes) === null || _a === void 0 ? void 0 : _a.forEach(function (node) {
+                if (!results.includes(node)) {
+                    results.push(node);
+                }
+            });
+        });
+        return results;
+    };
+    Engine.prototype.createNode = function (node, parent) {
+        return new TreeNode_1.TreeNode(node, parent);
+    };
+    Engine.prototype.mount = function () {
+        this.attachEvents(shared_1.globalThisPolyfill);
+    };
+    Engine.prototype.unmount = function () {
+        this.detachEvents();
+    };
+    Engine.defaultProps = {
+        shortcuts: [],
+        effects: [],
+        drivers: [],
+        rootComponentName: 'Root',
+        sourceIdAttrName: 'data-designer-source-id',
+        nodeIdAttrName: 'data-designer-node-id',
+        contentEditableAttrName: 'data-content-editable',
+        contentEditableNodeIdAttrName: 'data-content-editable-node-id',
+        clickStopPropagationAttrName: 'data-click-stop-propagation',
+        nodeSelectionIdAttrName: 'data-designer-node-helpers-id',
+        nodeDragHandlerAttrName: 'data-designer-node-drag-handler',
+        screenResizeHandlerAttrName: 'data-designer-screen-resize-handler',
+        nodeResizeHandlerAttrName: 'data-designer-node-resize-handler',
+        outlineNodeIdAttrName: 'data-designer-outline-node-id',
+        nodeTranslateAttrName: 'data-designer-node-translate-handler',
+        defaultScreenType: Screen_1.ScreenType.PC,
+    };
+    return Engine;
+}(shared_1.Event));
+exports.Engine = Engine;

package/lib/models/History.d.ts

@@ -0,0 +1,34 @@
+export interface IHistoryProps<T> {
+    onPush?: (item: T) => void;
+    onRedo?: (item: T) => void;
+    onUndo?: (item: T) => void;
+    onGoto?: (item: T) => void;
+}
+export interface HistoryItem<T> {
+    data: T;
+    type?: string;
+    timestamp: number;
+}
+export interface ISerializable {
+    from(json: any): void;
+    serialize(): any;
+}
+export declare class History<T extends ISerializable = any> {
+    context: ISerializable;
+    props: IHistoryProps<HistoryItem<T>>;
+    current: number;
+    history: HistoryItem<T>[];
+    updateTimer: any;
+    maxSize: number;
+    locking: boolean;
+    constructor(context: T, props?: IHistoryProps<HistoryItem<T>>);
+    makeObservable(): void;
+    list(): HistoryItem<T>[];
+    push(type?: string): void;
+    get allowUndo(): boolean;
+    get allowRedo(): boolean;
+    redo(): void;
+    undo(): void;
+    goTo(index: number): void;
+    clear(): void;
+}