@mdesignable/core 1.0.0-beta.64

package/esm/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/esm/models/SpaceBlock.js

@@ -0,0 +1,171 @@
+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 { calcExtendsLineSegmentOfRect, calcDistanceOfSnapLineToEdges, LineSegment, Rect, } from '@mdesignable/shared';
+import { SnapLine } from './SnapLine';
+import { TransformHelper } from './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 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 Rect(referRect.x, this.rect.y, referRect.width, this.rect.height);
+            }
+            else {
+                return new 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 Rect(dragNodesRect.x, this.rect.y, dragNodesRect.width, this.rect.height);
+            }
+            else {
+                return new 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.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 LineSegment({
+                    x: nextRect.left,
+                    y: referRect.bottom + nextRect.height,
+                }, {
+                    x: nextRect.right,
+                    y: referRect.bottom + nextRect.height,
+                });
+            }
+            else if (this.type === 'bottom') {
+                line = new LineSegment({
+                    x: nextRect.left,
+                    y: referRect.top - nextRect.height,
+                }, {
+                    x: nextRect.right,
+                    y: referRect.top - nextRect.height,
+                });
+            }
+            else if (this.type === 'left') {
+                line = new LineSegment({
+                    x: referRect.right + nextRect.width,
+                    y: nextRect.top,
+                }, {
+                    x: referRect.right + nextRect.width,
+                    y: nextRect.bottom,
+                });
+            }
+            else {
+                line = new LineSegment({
+                    x: referRect.left - nextRect.width,
+                    y: nextRect.top,
+                }, {
+                    x: referRect.left - nextRect.width,
+                    y: nextRect.bottom,
+                });
+            }
+            var distance = calcDistanceOfSnapLineToEdges(line, this.helper.dragNodesEdgeLines);
+            return new SnapLine(this.helper, __assign(__assign({}, line), { distance: distance, type: 'space-block' }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SpaceBlock;
+}());
+export { SpaceBlock };

package/esm/models/TransformHelper.d.ts

@@ -0,0 +1,80 @@
+import { Point, IPoint, ISize, IRect, Rect } from '@mdesignable/shared';
+import { SpaceBlock, AroundSpaceBlock } from './SpaceBlock';
+import { Operation } from './Operation';
+import { TreeNode } from './TreeNode';
+import { SnapLine, ISnapLine } from './SnapLine';
+export interface ITransformHelperProps {
+    operation: Operation;
+}
+export type TransformHelperType = 'translate' | 'resize' | 'rotate' | 'scale' | 'round';
+export type ResizeDirection = 'left-top' | 'left-center' | 'left-bottom' | 'center-top' | 'center-bottom' | 'right-top' | 'right-bottom' | 'right-center' | (string & {});
+export interface ITransformHelperDragStartProps {
+    type: TransformHelperType;
+    direction?: ResizeDirection;
+    dragNodes: TreeNode[];
+}
+export declare class TransformHelper {
+    operation: Operation;
+    type: TransformHelperType;
+    direction: ResizeDirection;
+    dragNodes: TreeNode[];
+    rulerSnapLines: SnapLine[];
+    aroundSnapLines: SnapLine[];
+    aroundSpaceBlocks: AroundSpaceBlock;
+    viewportRectsStore: Record<string, Rect>;
+    dragStartTranslateStore: Record<string, IPoint>;
+    dragStartSizeStore: Record<string, ISize>;
+    draggingNodesRect: Rect;
+    cacheDragNodesReact: Rect;
+    dragStartNodesRect: IRect;
+    snapping: boolean;
+    dragging: boolean;
+    snapped: boolean;
+    constructor(props: ITransformHelperProps);
+    get tree(): TreeNode;
+    get cursor(): import("./Cursor").Cursor;
+    get viewport(): import("./Viewport").Viewport;
+    get deltaX(): number;
+    get deltaY(): number;
+    get cursorPosition(): {
+        x: number;
+        y: number;
+    };
+    get cursorDragNodesRect(): Rect;
+    get cursorDragNodesEdgeLines(): import("@mdesignable/shared").IRectEdgeLines;
+    get dragNodesRect(): Rect;
+    get dragNodesEdgeLines(): import("@mdesignable/shared").IRectEdgeLines;
+    get cursorOffset(): Point;
+    get dragStartCursor(): {
+        x: number;
+        y: number;
+    };
+    get dragStartCursorOffset(): Point;
+    get closestSnapLines(): SnapLine[];
+    get closestSpaceBlocks(): SpaceBlock[];
+    get thresholdSnapLines(): SnapLine[];
+    get thresholdSpaceBlocks(): SpaceBlock[];
+    get measurerSpaceBlocks(): SpaceBlock[];
+    calcBaseTranslate(node: TreeNode): {
+        x: number;
+        y: number;
+    };
+    calcBaseResize(node: TreeNode): Rect;
+    calcDragStartStore(nodes?: TreeNode[]): void;
+    calcRulerSnapLines(dragNodesRect: IRect): SnapLine[];
+    calcAroundSnapLines(dragNodesRect: Rect): SnapLine[];
+    calcAroundSpaceBlocks(dragNodesRect: IRect): AroundSpaceBlock;
+    calcViewportNodes(): void;
+    getNodeRect(node: TreeNode): Rect;
+    eachViewportNodes(visitor: (node: TreeNode, rect: Rect) => void): void;
+    translate(node: TreeNode, handler: (translate: IPoint) => void): void;
+    resize(node: TreeNode, handler: (resize: IRect) => void): void;
+    findRulerSnapLine(id: string): SnapLine;
+    addRulerSnapLine(line: ISnapLine): void;
+    removeRulerSnapLine(id: string): void;
+    dragStart(props: ITransformHelperDragStartProps): void;
+    dragMove(): void;
+    dragEnd(): void;
+    makeObservable(): void;
+    static threshold: number;
+}