@mdesignable/core 1.0.0-beta.64

package/lib/models/Selection.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Selection = void 0;
+var reactive_1 = require("@formily/reactive");
+var events_1 = require("../events");
+var shared_1 = require("@mdesignable/shared");
+var Selection = /** @class */ (function () {
+    function Selection(props) {
+        this.selected = [];
+        this.indexes = {};
+        if (props.selected) {
+            this.selected = props.selected;
+        }
+        if (props.operation) {
+            this.operation = props.operation;
+        }
+        this.makeObservable();
+    }
+    Selection.prototype.makeObservable = function () {
+        (0, reactive_1.define)(this, {
+            selected: reactive_1.observable,
+            select: reactive_1.action,
+            batchSelect: reactive_1.action,
+            add: reactive_1.action,
+            remove: reactive_1.action,
+            clear: reactive_1.action,
+            crossAddTo: reactive_1.action,
+        });
+    };
+    Selection.prototype.trigger = function (type) {
+        if (type === void 0) { type = events_1.SelectNodeEvent; }
+        return this.operation.dispatch(new type({
+            target: this.operation.tree,
+            source: this.selectedNodes,
+        }));
+    };
+    Selection.prototype.select = function (id) {
+        var _a;
+        if ((0, shared_1.isStr)(id)) {
+            if (this.selected.length === 1 && this.selected.includes(id)) {
+                this.trigger(events_1.SelectNodeEvent);
+                return;
+            }
+            this.selected = [id];
+            this.indexes = (_a = {}, _a[id] = true, _a);
+            this.trigger(events_1.SelectNodeEvent);
+        }
+        else {
+            this.select(id === null || id === void 0 ? void 0 : id.id);
+        }
+    };
+    Selection.prototype.safeSelect = function (id) {
+        if (!id)
+            return;
+        this.select(id);
+    };
+    Selection.prototype.mapIds = function (ids) {
+        return (0, shared_1.isArr)(ids)
+            ? ids.map(function (node) { return ((0, shared_1.isStr)(node) ? node : node === null || node === void 0 ? void 0 : node.id); })
+            : [];
+    };
+    Selection.prototype.batchSelect = function (ids) {
+        this.selected = this.mapIds(ids);
+        this.indexes = this.selected.reduce(function (buf, id) {
+            buf[id] = true;
+            return buf;
+        }, {});
+        this.trigger(events_1.SelectNodeEvent);
+    };
+    Selection.prototype.batchSafeSelect = function (ids) {
+        if (!(ids === null || ids === void 0 ? void 0 : ids.length))
+            return;
+        this.batchSelect(ids);
+    };
+    Object.defineProperty(Selection.prototype, "selectedNodes", {
+        get: function () {
+            var _this = this;
+            return this.selected.map(function (id) { return _this.operation.tree.findById(id); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Selection.prototype, "first", {
+        get: function () {
+            if (this.selected && this.selected.length)
+                return this.selected[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Selection.prototype, "last", {
+        get: function () {
+            if (this.selected && this.selected.length)
+                return this.selected[this.selected.length - 1];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Selection.prototype, "length", {
+        get: function () {
+            return this.selected.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Selection.prototype.add = function () {
+        var _this = this;
+        var ids = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            ids[_i] = arguments[_i];
+        }
+        this.mapIds(ids).forEach(function (id) {
+            if ((0, shared_1.isStr)(id)) {
+                if (!_this.selected.includes(id)) {
+                    _this.selected.push(id);
+                    _this.indexes[id] = true;
+                }
+            }
+            else {
+                _this.add(id === null || id === void 0 ? void 0 : id.id);
+            }
+        });
+        this.trigger();
+    };
+    Selection.prototype.crossAddTo = function (node) {
+        var _this = this;
+        if (node.parent) {
+            var selectedNodes = this.selectedNodes;
+            if (this.has(node)) {
+                this.remove(node);
+            }
+            else {
+                var minDistanceNode = selectedNodes.reduce(function (minDistanceNode, item) {
+                    return item.distanceTo(node) < minDistanceNode.distanceTo(node)
+                        ? item
+                        : minDistanceNode;
+                }, selectedNodes[0]);
+                if (minDistanceNode) {
+                    var crossNodes = node.crossSiblings(minDistanceNode);
+                    crossNodes.forEach(function (node) {
+                        if (!_this.has(node.id)) {
+                            _this.selected.push(node.id);
+                            _this.indexes[node.id] = true;
+                        }
+                    });
+                }
+                if (!this.has(node.id)) {
+                    this.selected.push(node.id);
+                    this.indexes[node.id] = true;
+                }
+            }
+        }
+    };
+    Selection.prototype.remove = function () {
+        var _this = this;
+        var ids = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            ids[_i] = arguments[_i];
+        }
+        this.mapIds(ids).forEach(function (id) {
+            if ((0, shared_1.isStr)(id)) {
+                _this.selected = _this.selected.filter(function (item) { return item !== id; });
+                delete _this.indexes[id];
+            }
+            else {
+                _this.remove(id === null || id === void 0 ? void 0 : id.id);
+            }
+        });
+        this.trigger(events_1.UnSelectNodeEvent);
+    };
+    Selection.prototype.has = function () {
+        var _this = this;
+        var ids = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            ids[_i] = arguments[_i];
+        }
+        return this.mapIds(ids).some(function (id) {
+            if ((0, shared_1.isStr)(id)) {
+                return _this.indexes[id];
+            }
+            else {
+                if (!(id === null || id === void 0 ? void 0 : id.id))
+                    return false;
+                return _this.has(id === null || id === void 0 ? void 0 : id.id);
+            }
+        });
+    };
+    Selection.prototype.clear = function () {
+        this.selected = [];
+        this.indexes = {};
+        this.trigger(events_1.UnSelectNodeEvent);
+    };
+    return Selection;
+}());
+exports.Selection = Selection;

package/lib/models/Shortcut.d.ts

@@ -0,0 +1,20 @@
+import { KeyCode } from '@mdesignable/shared';
+import { IEngineContext } from '../types';
+export { KeyCode };
+export interface IShortcutProps {
+    codes?: KeyCode[] | KeyCode[][];
+    matcher?: (codes: KeyCode[]) => boolean;
+    handler?: (context: IEngineContext) => void;
+}
+export declare class Shortcut {
+    codes: KeyCode[][];
+    handler: (context: IEngineContext) => void;
+    matcher: (codes: KeyCode[]) => boolean;
+    constructor(props: IShortcutProps);
+    parseCodes(codes: Array<KeyCode | KeyCode[]>): KeyCode[][];
+    preventCodes(codes: KeyCode[]): boolean;
+    matched(matched: boolean, context: IEngineContext): boolean;
+    match(codes: KeyCode[], context: IEngineContext): boolean;
+    static matchCode: (code1: KeyCode, code2: KeyCode) => boolean;
+    static sortCodes: (codes: KeyCode[]) => KeyCode[];
+}

package/lib/models/Shortcut.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shortcut = exports.KeyCode = void 0;
+var shared_1 = require("@mdesignable/shared");
+Object.defineProperty(exports, "KeyCode", { enumerable: true, get: function () { return shared_1.KeyCode; } });
+var Shortcut = /** @class */ (function () {
+    function Shortcut(props) {
+        this.codes = this.parseCodes(props.codes);
+        this.handler = props.handler;
+        this.matcher = props.matcher;
+    }
+    Shortcut.prototype.parseCodes = function (codes) {
+        var results = [];
+        codes.forEach(function (code) {
+            if (Array.isArray(code)) {
+                results.push(code);
+            }
+            else {
+                results.push([code]);
+            }
+        });
+        return results;
+    };
+    Shortcut.prototype.preventCodes = function (codes) {
+        var _a;
+        if (this.codes.length) {
+            for (var i = 0; i < codes.length; i++) {
+                var sequence = (_a = this.codes[i]) !== null && _a !== void 0 ? _a : [];
+                for (var j = 0; j < sequence.length; j++) {
+                    if (!Shortcut.matchCode(codes[j], sequence[j])) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+    Shortcut.prototype.matched = function (matched, context) {
+        if ((0, shared_1.isFn)(this.handler) && matched) {
+            this.handler(context);
+        }
+        return matched;
+    };
+    Shortcut.prototype.match = function (codes, context) {
+        var _this = this;
+        return this.codes.some(function (sequence) {
+            var sortedSelf = Shortcut.sortCodes(sequence);
+            var sortedTarget = Shortcut.sortCodes(codes);
+            if ((0, shared_1.isFn)(_this.matcher)) {
+                return _this.matched(_this.matcher(sortedTarget), context);
+            }
+            if (sortedTarget.length !== sortedSelf.length)
+                return _this.matched(false, context);
+            for (var i = 0; i < sortedSelf.length; i++) {
+                if (!Shortcut.matchCode(sortedTarget[i], sortedSelf[i])) {
+                    return _this.matched(false, context);
+                }
+            }
+            return _this.matched(true, context);
+        });
+    };
+    Shortcut.matchCode = function (code1, code2) {
+        var _a, _b;
+        return ((_a = code1 === null || code1 === void 0 ? void 0 : code1.toLocaleLowerCase) === null || _a === void 0 ? void 0 : _a.call(code1)) === ((_b = code2 === null || code2 === void 0 ? void 0 : code2.toLocaleLowerCase) === null || _b === void 0 ? void 0 : _b.call(code2));
+    };
+    Shortcut.sortCodes = function (codes) {
+        return codes.map(function (code) { return code.toLocaleLowerCase(); }).sort();
+    };
+    return Shortcut;
+}());
+exports.Shortcut = Shortcut;

package/lib/models/SnapLine.d.ts

@@ -0,0 +1,27 @@
+import { ILineSegment, IPoint, Rect } from '@mdesignable/shared';
+import { TreeNode } from './TreeNode';
+import { TransformHelper } from './TransformHelper';
+export type ISnapLineType = 'ruler' | 'space-block' | 'normal';
+export type ISnapLine = ILineSegment & {
+    type?: ISnapLineType;
+    distance?: number;
+    id?: string;
+    refer?: TreeNode;
+};
+export declare class SnapLine {
+    _id: string;
+    type: ISnapLineType;
+    distance: number;
+    refer: TreeNode;
+    start: IPoint;
+    end: IPoint;
+    helper: TransformHelper;
+    constructor(helper: TransformHelper, line: ISnapLine);
+    get id(): string;
+    get direction(): "v" | "h";
+    get closest(): boolean;
+    get rect(): Rect;
+    translate(node: TreeNode, translate: IPoint): void;
+    resize(node: TreeNode, rect: Rect): void;
+    snapEdge(rect: Rect): "ht" | "hc" | "hb" | "vl" | "vc" | "vr";
+}

package/lib/models/SnapLine.js

@@ -0,0 +1,144 @@
+"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.SnapLine = void 0;
+var shared_1 = require("@mdesignable/shared");
+var TransformHelper_1 = require("./TransformHelper");
+var SnapLine = /** @class */ (function () {
+    function SnapLine(helper, line) {
+        this.helper = helper;
+        this.type = line.type || 'normal';
+        this._id = line.id;
+        this.refer = line.refer;
+        this.start = __assign({}, line.start);
+        this.end = __assign({}, line.end);
+        this.distance = line.distance;
+    }
+    Object.defineProperty(SnapLine.prototype, "id", {
+        get: function () {
+            var _a;
+            return ((_a = this._id) !== null && _a !== void 0 ? _a : "".concat(this.start.x, "-").concat(this.start.y, "-").concat(this.end.x, "-").concat(this.end.y));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SnapLine.prototype, "direction", {
+        get: function () {
+            var _a, _b;
+            if (((_a = this.start) === null || _a === void 0 ? void 0 : _a.x) === ((_b = this.end) === null || _b === void 0 ? void 0 : _b.x))
+                return 'v';
+            return 'h';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SnapLine.prototype, "closest", {
+        get: function () {
+            return this.distance < TransformHelper_1.TransformHelper.threshold;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SnapLine.prototype, "rect", {
+        get: function () {
+            return (0, shared_1.calcRectOfAxisLineSegment)(this);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SnapLine.prototype.translate = function (node, translate) {
+        if (!node || !(node === null || node === void 0 ? void 0 : node.parent))
+            return;
+        var parent = node.parent;
+        var dragNodeRect = node.getValidElementOffsetRect();
+        var parentRect = parent.getValidElementOffsetRect();
+        var edgeOffset = (0, shared_1.calcOffsetOfSnapLineSegmentToEdge)(this, dragNodeRect);
+        if (this.direction === 'h') {
+            translate.y = this.start.y - parentRect.y - edgeOffset.y;
+        }
+        else {
+            translate.x = this.start.x - parentRect.x - edgeOffset.x;
+        }
+    };
+    SnapLine.prototype.resize = function (node, rect) {
+        if (!node || !(node === null || node === void 0 ? void 0 : node.parent))
+            return;
+        var parent = node.parent;
+        var dragNodeRect = node.getValidElementOffsetRect();
+        var parentRect = parent.getValidElementOffsetRect();
+        var edgeOffset = (0, shared_1.calcOffsetOfSnapLineSegmentToEdge)(this, dragNodeRect);
+        var cursorRect = this.helper.cursorDragNodesRect;
+        var snapEdge = this.snapEdge(rect);
+        if (this.direction === 'h') {
+            var y = this.start.y - parentRect.y - edgeOffset.y;
+            switch (this.helper.direction) {
+                case 'left-top':
+                case 'center-top':
+                case 'right-top':
+                    if (snapEdge !== 'ht')
+                        return;
+                    rect.y = y;
+                    rect.height = cursorRect.bottom - y;
+                    break;
+                case 'left-bottom':
+                case 'center-bottom':
+                case 'right-bottom':
+                    if (snapEdge !== 'hb')
+                        return;
+                    rect.height = this.start.y - cursorRect.top;
+                    break;
+            }
+        }
+        else {
+            var x = this.start.x - parentRect.x - edgeOffset.x;
+            switch (this.helper.direction) {
+                case 'left-top':
+                case 'left-bottom':
+                case 'left-center':
+                    if (snapEdge !== 'vl')
+                        return;
+                    rect.x = x;
+                    rect.width = cursorRect.right - x;
+                    break;
+                case 'right-center':
+                case 'right-top':
+                case 'right-bottom':
+                    if (snapEdge !== 'vr')
+                        return;
+                    rect.width = this.start.x - cursorRect.left;
+                    break;
+            }
+        }
+    };
+    SnapLine.prototype.snapEdge = function (rect) {
+        var threshold = TransformHelper_1.TransformHelper.threshold;
+        if (this.direction === 'h') {
+            if (Math.abs(this.start.y - rect.top) < threshold)
+                return 'ht';
+            if (Math.abs(this.start.y - (rect.top + rect.height / 2)) < threshold)
+                return 'hc';
+            if (Math.abs(this.start.y - rect.bottom) < threshold)
+                return 'hb';
+        }
+        else {
+            if (Math.abs(this.start.x - rect.left) < threshold)
+                return 'vl';
+            if (Math.abs(this.start.x - (rect.left + rect.width / 2)) < threshold)
+                return 'vc';
+            if (Math.abs(this.start.x - rect.right) < threshold)
+                return 'vr';
+        }
+    };
+    return SnapLine;
+}());
+exports.SnapLine = SnapLine;

package/lib/models/SpaceBlock.d.ts

@@ -0,0 +1,40 @@
+import { Rect } from '@mdesignable/shared';
+import { SnapLine } from './SnapLine';
+import { TransformHelper } from './TransformHelper';
+import { TreeNode } from './TreeNode';
+export type ISpaceBlockType = 'top' | 'right' | 'bottom' | 'left' | (string & {});
+export interface ISpaceBlock {
+    id?: string;
+    refer?: TreeNode;
+    rect?: Rect;
+    distance?: number;
+    type?: ISpaceBlockType;
+}
+export type AroundSpaceBlock = Record<ISpaceBlockType, SpaceBlock>;
+export declare class SpaceBlock {
+    _id: string;
+    distance: number;
+    refer: TreeNode;
+    helper: TransformHelper;
+    rect: Rect;
+    type: ISpaceBlockType;
+    constructor(helper: TransformHelper, box: ISpaceBlock);
+    get referRect(): Rect;
+    get id(): string;
+    get next(): SpaceBlock;
+    get extendsLine(): {
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    };
+    get needExtendsLine(): boolean;
+    get crossReferRect(): Rect;
+    get crossDragNodesRect(): Rect;
+    get isometrics(): SpaceBlock[];
+    get snapLine(): SnapLine;
+}

package/lib/models/SpaceBlock.js

@@ -0,0 +1,174 @@
+"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.SpaceBlock = void 0;
+var shared_1 = require("@mdesignable/shared");
+var SnapLine_1 = require("./SnapLine");
+var TransformHelper_1 = require("./TransformHelper");
+var SpaceBlock = /** @class */ (function () {
+    function SpaceBlock(helper, box) {
+        this.helper = helper;
+        this.distance = box.distance;
+        this.refer = box.refer;
+        this.rect = box.rect;
+        this.type = box.type;
+    }
+    Object.defineProperty(SpaceBlock.prototype, "referRect", {
+        get: function () {
+            if (!this.refer)
+                return;
+            return this.helper.getNodeRect(this.refer);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "id", {
+        get: function () {
+            var _a;
+            return ((_a = this._id) !== null && _a !== void 0 ? _a : "".concat(this.rect.x, "-").concat(this.rect.y, "-").concat(this.rect.width, "-").concat(this.rect.height));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "next", {
+        get: function () {
+            var spaceBlock = this.helper.calcAroundSpaceBlocks(this.referRect);
+            return spaceBlock[this.type];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "extendsLine", {
+        get: function () {
+            if (!this.needExtendsLine)
+                return;
+            var dragNodesRect = this.helper.dragNodesRect;
+            return (0, shared_1.calcExtendsLineSegmentOfRect)(dragNodesRect, this.referRect);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "needExtendsLine", {
+        get: function () {
+            var targetRect = this.crossDragNodesRect;
+            var referRect = this.crossReferRect;
+            if (this.type === 'top' || this.type === 'bottom') {
+                var rightDelta = referRect.right - targetRect.left;
+                var leftDelta = targetRect.right - referRect.left;
+                return (rightDelta < targetRect.width / 2 || leftDelta < targetRect.width / 2);
+            }
+            else {
+                var topDelta = targetRect.bottom - referRect.top;
+                var bottomDelta = referRect.bottom - targetRect.top;
+                return (topDelta < targetRect.height / 2 || bottomDelta < targetRect.height / 2);
+            }
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "crossReferRect", {
+        get: function () {
+            var referRect = this.referRect;
+            if (this.type === 'top' || this.type === 'bottom') {
+                return new shared_1.Rect(referRect.x, this.rect.y, referRect.width, this.rect.height);
+            }
+            else {
+                return new shared_1.Rect(this.rect.x, referRect.y, this.rect.width, referRect.height);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "crossDragNodesRect", {
+        get: function () {
+            var dragNodesRect = this.helper.dragNodesRect;
+            if (this.type === 'top' || this.type === 'bottom') {
+                return new shared_1.Rect(dragNodesRect.x, this.rect.y, dragNodesRect.width, this.rect.height);
+            }
+            else {
+                return new shared_1.Rect(this.rect.x, dragNodesRect.y, this.rect.width, dragNodesRect.height);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "isometrics", {
+        get: function () {
+            var results = [];
+            var spaceBlock = this;
+            while ((spaceBlock = spaceBlock.next)) {
+                if (Math.abs(spaceBlock.distance - this.distance) <
+                    TransformHelper_1.TransformHelper.threshold) {
+                    if (results.some(function (box) { return box.distance !== spaceBlock.distance; }))
+                        continue;
+                    results.push(spaceBlock);
+                }
+            }
+            return results;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SpaceBlock.prototype, "snapLine", {
+        get: function () {
+            if (!this.isometrics.length)
+                return;
+            var nextRect = this.next.rect;
+            var referRect = this.referRect;
+            var line;
+            if (this.type === 'top') {
+                line = new shared_1.LineSegment({
+                    x: nextRect.left,
+                    y: referRect.bottom + nextRect.height,
+                }, {
+                    x: nextRect.right,
+                    y: referRect.bottom + nextRect.height,
+                });
+            }
+            else if (this.type === 'bottom') {
+                line = new shared_1.LineSegment({
+                    x: nextRect.left,
+                    y: referRect.top - nextRect.height,
+                }, {
+                    x: nextRect.right,
+                    y: referRect.top - nextRect.height,
+                });
+            }
+            else if (this.type === 'left') {
+                line = new shared_1.LineSegment({
+                    x: referRect.right + nextRect.width,
+                    y: nextRect.top,
+                }, {
+                    x: referRect.right + nextRect.width,
+                    y: nextRect.bottom,
+                });
+            }
+            else {
+                line = new shared_1.LineSegment({
+                    x: referRect.left - nextRect.width,
+                    y: nextRect.top,
+                }, {
+                    x: referRect.left - nextRect.width,
+                    y: nextRect.bottom,
+                });
+            }
+            var distance = (0, shared_1.calcDistanceOfSnapLineToEdges)(line, this.helper.dragNodesEdgeLines);
+            return new SnapLine_1.SnapLine(this.helper, __assign(__assign({}, line), { distance: distance, type: 'space-block' }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SpaceBlock;
+}());
+exports.SpaceBlock = SpaceBlock;