@mdesignable/core 1.0.0-beta.64

package/esm/externals.js

@@ -0,0 +1,113 @@
+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));
+};
+import { isArr } from '@mdesignable/shared';
+import { untracked } from '@formily/reactive';
+import { DEFAULT_DRIVERS, DEFAULT_EFFECTS, DEFAULT_SHORTCUTS } from './presets';
+import { Engine, TreeNode } from './models';
+import { mergeLocales } from './internals';
+export var isBehaviorHost = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.Behavior) && isBehaviorList(val.Behavior);
+};
+export var isBehaviorList = function (val) {
+    return Array.isArray(val) && val.every(isBehavior);
+};
+export 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);
+};
+export var isResourceHost = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.Resource) && isResourceList(val.Resource);
+};
+export var isResourceList = function (val) {
+    return Array.isArray(val) && val.every(isResource);
+};
+export var isResource = function (val) {
+    return (val === null || val === void 0 ? void 0 : val.node) && !!val.node.isSourceNode && val.node instanceof TreeNode;
+};
+export var createLocales = function () {
+    var packages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        packages[_i] = arguments[_i];
+    }
+    var results = {};
+    packages.forEach(function (locales) {
+        mergeLocales(results, locales);
+    });
+    return results;
+};
+export var createBehavior = function () {
+    var behaviors = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        behaviors[_i] = arguments[_i];
+    }
+    return behaviors.reduce(function (buf, behavior) {
+        if (isArr(behavior))
+            return buf.concat(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);
+    }, []);
+};
+export 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 TreeNode({
+                componentName: '$$ResourceNode$$',
+                isSourceNode: true,
+                children: source.elements || [],
+            }) }));
+    }, []);
+};
+export var createDesigner = function (props) {
+    if (props === void 0) { props = {}; }
+    var drivers = props.drivers || [];
+    var effects = props.effects || [];
+    var shortcuts = props.shortcuts || [];
+    return untracked(function () {
+        return new Engine(__assign(__assign({}, props), { effects: __spreadArray(__spreadArray([], __read(effects), false), __read(DEFAULT_EFFECTS), false), drivers: __spreadArray(__spreadArray([], __read(drivers), false), __read(DEFAULT_DRIVERS), false), shortcuts: __spreadArray(__spreadArray([], __read(shortcuts), false), __read(DEFAULT_SHORTCUTS), false) }));
+    });
+};

package/esm/index.d.ts

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

package/esm/index.js

@@ -0,0 +1,24 @@
+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 _a;
+import * as Core from './exports';
+export * from './exports';
+import { globalThisPolyfill } from '@mdesignable/shared';
+if ((_a = globalThisPolyfill === null || globalThisPolyfill === void 0 ? void 0 : globalThisPolyfill['Designable']) === null || _a === void 0 ? void 0 : _a['Core']) {
+    if (module.exports) {
+        module.exports = __assign({ __esModule: true }, globalThisPolyfill['Designable']['Core']);
+    }
+}
+else {
+    globalThisPolyfill['Designable'] = globalThisPolyfill['Designable'] || {};
+    globalThisPolyfill['Designable'].Core = Core;
+}

package/esm/internals.d.ts

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

package/esm/internals.js

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

package/esm/models/Cursor.d.ts

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

package/esm/models/Cursor.js

@@ -0,0 +1,151 @@
+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);
+};
+import { action, define, observable } from '@formily/reactive';
+import { globalThisPolyfill, isValidNumber } from '@mdesignable/shared';
+export var CursorStatus;
+(function (CursorStatus) {
+    CursorStatus["Normal"] = "NORMAL";
+    CursorStatus["DragStart"] = "DRAG_START";
+    CursorStatus["Dragging"] = "DRAGGING";
+    CursorStatus["DragStop"] = "DRAG_STOP";
+})(CursorStatus || (CursorStatus = {}));
+export var CursorDragType;
+(function (CursorDragType) {
+    CursorDragType["Move"] = "MOVE";
+    CursorDragType["Resize"] = "RESIZE";
+    CursorDragType["Rotate"] = "ROTATE";
+    CursorDragType["Scale"] = "SCALE";
+    CursorDragType["Translate"] = "TRANSLATE";
+    CursorDragType["Round"] = "ROUND";
+})(CursorDragType || (CursorDragType = {}));
+export var CursorType;
+(function (CursorType) {
+    CursorType["Normal"] = "NORMAL";
+    CursorType["Selection"] = "SELECTION";
+    CursorType["Sketch"] = "SKETCH";
+})(CursorType || (CursorType = {}));
+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 (isValidNumber(end === null || end === void 0 ? void 0 : end[key]) && 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 = globalThisPolyfill;
+        this.engine = engine;
+        this.makeObservable();
+    }
+    Cursor.prototype.makeObservable = function () {
+        define(this, {
+            type: observable.ref,
+            dragType: observable.ref,
+            status: observable.ref,
+            position: observable.ref,
+            dragStartPosition: observable.ref,
+            dragEndPosition: observable.ref,
+            dragAtomDelta: observable.ref,
+            dragStartToCurrentDelta: observable.ref,
+            dragStartToEndDelta: observable.ref,
+            view: observable.ref,
+            setStyle: action,
+            setPosition: action,
+            setStatus: action,
+            setType: action,
+        });
+    };
+    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;
+}());
+export { Cursor };

package/esm/models/Engine.d.ts

@@ -0,0 +1,29 @@
+import { IEngineProps } from '../types';
+import { ITreeNode, TreeNode } from './TreeNode';
+import { Workbench } from './Workbench';
+import { Cursor } from './Cursor';
+import { Keyboard } from './Keyboard';
+import { Screen } from './Screen';
+import { Event } from '@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/esm/models/Engine.js

@@ -0,0 +1,112 @@
+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);
+};
+import { TreeNode } from './TreeNode';
+import { Workbench } from './Workbench';
+import { Cursor } from './Cursor';
+import { Keyboard } from './Keyboard';
+import { Screen, ScreenType } from './Screen';
+import { Event, uid, globalThisPolyfill } from '@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 = uid();
+        return _this;
+    }
+    Engine.prototype.init = function () {
+        this.workbench = new Workbench(this);
+        this.screen = new Screen(this);
+        this.cursor = new Cursor(this);
+        this.keyboard = new 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.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(node, parent);
+    };
+    Engine.prototype.mount = function () {
+        this.attachEvents(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: ScreenType.PC,
+    };
+    return Engine;
+}(Event));
+export { Engine };

package/esm/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;
+}

package/esm/models/History.js

@@ -0,0 +1,110 @@
+import { define, observable, action } from '@formily/reactive';
+var History = /** @class */ (function () {
+    function History(context, props) {
+        this.current = 0;
+        this.history = [];
+        this.updateTimer = null;
+        this.maxSize = 100;
+        this.locking = false;
+        this.context = context;
+        this.props = props;
+        this.push();
+        this.makeObservable();
+    }
+    History.prototype.makeObservable = function () {
+        define(this, {
+            current: observable.ref,
+            history: observable.shallow,
+            push: action,
+            undo: action,
+            redo: action,
+            goTo: action,
+            clear: action,
+        });
+    };
+    History.prototype.list = function () {
+        return this.history;
+    };
+    History.prototype.push = function (type) {
+        var _a;
+        if (this.locking)
+            return;
+        if (this.current < this.history.length - 1) {
+            this.history = this.history.slice(0, this.current + 1);
+        }
+        var item = {
+            data: this.context.serialize(),
+            timestamp: Date.now(),
+            type: type,
+        };
+        this.current = this.history.length;
+        this.history.push(item);
+        var overSizeCount = this.history.length - this.maxSize;
+        if (overSizeCount > 0) {
+            this.history.splice(0, overSizeCount);
+            this.current = this.history.length - 1;
+        }
+        if ((_a = this.props) === null || _a === void 0 ? void 0 : _a.onPush) {
+            this.props.onPush(item);
+        }
+    };
+    Object.defineProperty(History.prototype, "allowUndo", {
+        get: function () {
+            return this.history.length > 0 && this.current - 1 >= 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(History.prototype, "allowRedo", {
+        get: function () {
+            return this.history.length > this.current + 1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    History.prototype.redo = function () {
+        var _a;
+        if (this.allowRedo) {
+            var item = this.history[this.current + 1];
+            this.locking = true;
+            this.context.from(item.data);
+            this.locking = false;
+            this.current++;
+            if ((_a = this.props) === null || _a === void 0 ? void 0 : _a.onRedo) {
+                this.props.onRedo(item);
+            }
+        }
+    };
+    History.prototype.undo = function () {
+        var _a;
+        if (this.allowUndo) {
+            var item = this.history[this.current - 1];
+            this.locking = true;
+            this.context.from(item.data);
+            this.locking = false;
+            this.current--;
+            if ((_a = this.props) === null || _a === void 0 ? void 0 : _a.onUndo) {
+                this.props.onUndo(item);
+            }
+        }
+    };
+    History.prototype.goTo = function (index) {
+        var _a;
+        var item = this.history[index];
+        if (item) {
+            this.locking = true;
+            this.context.from(item.data);
+            this.locking = false;
+            this.current = index;
+            if ((_a = this.props) === null || _a === void 0 ? void 0 : _a.onGoto) {
+                this.props.onGoto(item);
+            }
+        }
+    };
+    History.prototype.clear = function () {
+        this.history = [];
+        this.current = 0;
+    };
+    return History;
+}());
+export { History };