@hatiolab/things-scene 3.4.39 → 3.4.42

package/dist/components/ortholine.js

@@ -1,814 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- */
-import Component from './component';
-import Line, { SOUTH, NORTH, EAST, WEST } from './line';
-const FROM = 0;
-const TO = 1;
-const NATURE = {
-    mutable: false,
-    resizable: false,
-    rotatable: false,
-    properties: [
-        {
-            type: 'number',
-            label: 'round',
-            name: 'round',
-            property: {
-                min: 0,
-                max: 100,
-                step: 1
-            }
-        }
-    ],
-    help: 'scene/component/ortholine'
-};
-export default class OrthoLine extends Line {
-    get pathExtendable() {
-        return false;
-    }
-    get drawPath() {
-        const fromPosition = this.path[0];
-        const toPosition = this.path[1];
-        const { component: fromComponent, direction: fromDirection, boundaryPosition: fromBoundaryPosition = fromPosition } = this.fromEnd || {};
-        const { component: toComponent, direction: toDirection, boundaryPosition: toBoundaryPosition = toPosition } = this.toEnd || {};
-        var boundaryPositions = [fromBoundaryPosition, toBoundaryPosition];
-        var path = [];
-        if (fromBoundaryPosition) {
-            path.push(fromBoundaryPosition);
-        }
-        /* 두 컴포넌트의 확장된 바운드를 구한다. */
-        var fromOriginBounds = fromComponent === null || fromComponent === void 0 ? void 0 : fromComponent.bounds;
-        if (fromOriginBounds) {
-            var transcoorded = fromComponent.transcoordS2T(fromOriginBounds.left, fromOriginBounds.top);
-            transcoorded = this.transcoordT2P(transcoorded.x, transcoorded.y);
-            fromOriginBounds = {
-                ...fromOriginBounds,
-                left: transcoorded.x,
-                top: transcoorded.y
-            };
-        }
-        var fromBounds = fromOriginBounds
-            ? {
-                left: fromOriginBounds.left - 20,
-                top: fromOriginBounds.top - 20,
-                width: fromOriginBounds.width + 40,
-                height: fromOriginBounds.height + 40
-            }
-            : {
-                left: fromBoundaryPosition.x,
-                top: fromBoundaryPosition.y,
-                width: 0,
-                height: 0
-            };
-        fromOriginBounds = fromOriginBounds || fromBounds;
-        var toOriginBounds = toComponent === null || toComponent === void 0 ? void 0 : toComponent.bounds;
-        if (toOriginBounds) {
-            var transcoorded = toComponent.transcoordS2T(toOriginBounds.left, toOriginBounds.top);
-            transcoorded = this.transcoordT2P(transcoorded.x, transcoorded.y);
-            toOriginBounds = {
-                ...toOriginBounds,
-                left: transcoorded.x,
-                top: transcoorded.y
-            };
-        }
-        var toBounds = toOriginBounds
-            ? {
-                left: toOriginBounds.left - 20,
-                top: toOriginBounds.top - 20,
-                width: toOriginBounds.width + 40,
-                height: toOriginBounds.height + 40
-            }
-            : {
-                left: toBoundaryPosition.x,
-                top: toBoundaryPosition.y,
-                width: 0,
-                height: 0
-            };
-        toOriginBounds = toOriginBounds || toBounds;
-        var fromToBounds = [fromBounds, toBounds];
-        const leftMost = fromBounds.left > toBounds.left ? toBounds.left : fromBounds.left;
-        const topMost = fromBounds.top > toBounds.top ? toBounds.top : fromBounds.top;
-        var unionBounds = {
-            left: leftMost,
-            top: topMost,
-            width: fromBounds.left + fromBounds.width > toBounds.left + toBounds.width
-                ? fromBounds.left + fromBounds.width - leftMost
-                : toBounds.left + toBounds.width - leftMost,
-            height: fromBounds.top + fromBounds.height > toBounds.top + toBounds.height
-                ? fromBounds.top + fromBounds.height - topMost
-                : toBounds.top + toBounds.height - topMost
-        };
-        /* 두 컴포넌트 바운드의 센터를 찾는다. */
-        var centerX, centerY, centerWidth = 0, centerHeight = 0;
-        var upperComponent, leftComponent, rightComponent, lowerComponent;
-        var upperComponentDirection, lowerComponentDirection;
-        var leftComponentDirection, rightComponentDirection;
-        if (fromOriginBounds.left + fromOriginBounds.width < toOriginBounds.left) {
-            leftComponent = FROM;
-            rightComponent = TO;
-            leftComponentDirection = fromDirection;
-            rightComponentDirection = toDirection;
-            centerX = (fromOriginBounds.left + fromOriginBounds.width + toOriginBounds.left) / 2;
-            centerWidth = toOriginBounds.left - centerX;
-        }
-        else if (toOriginBounds.left + toOriginBounds.width < fromOriginBounds.left) {
-            leftComponent = TO;
-            rightComponent = FROM;
-            leftComponentDirection = toDirection;
-            rightComponentDirection = fromDirection;
-            centerX = (fromOriginBounds.left + toOriginBounds.width + toOriginBounds.left) / 2;
-            centerWidth = fromOriginBounds.left - centerX;
-        }
-        if (fromOriginBounds.top + fromOriginBounds.height < toOriginBounds.top) {
-            upperComponent = FROM;
-            lowerComponent = TO;
-            upperComponentDirection = fromDirection;
-            lowerComponentDirection = toDirection;
-            centerY = (fromOriginBounds.top + fromOriginBounds.height + toOriginBounds.top) / 2;
-            centerHeight = toOriginBounds.top - centerY;
-        }
-        else if (toOriginBounds.top + toOriginBounds.height < fromOriginBounds.top) {
-            upperComponent = TO;
-            lowerComponent = FROM;
-            upperComponentDirection = toDirection;
-            lowerComponentDirection = fromDirection;
-            centerY = (fromOriginBounds.top + toOriginBounds.height + toOriginBounds.top) / 2;
-            centerHeight = fromOriginBounds.top - centerY;
-        }
-        /* 각 LinkEnd의 방향별 패스 구하기 */
-        var lpath = [];
-        if (centerX && centerWidth > centerHeight) {
-            switch (rightComponentDirection) {
-                case WEST:
-                    switch (leftComponentDirection) {
-                        case EAST:
-                            lpath.push({
-                                x: centerX,
-                                y: boundaryPositions[leftComponent].y
-                            });
-                            lpath.push({
-                                x: centerX,
-                                y: boundaryPositions[rightComponent].y
-                            });
-                            break;
-                        case WEST:
-                            var leftComponentCenterY = fromToBounds[leftComponent].top + fromToBounds[leftComponent].height / 2;
-                            var leftY = leftComponentCenterY > boundaryPositions[rightComponent].y
-                                ? Math.min(fromToBounds[leftComponent].top, boundaryPositions[rightComponent].y)
-                                : Math.max(fromToBounds[leftComponent].top + fromToBounds[leftComponent].height, boundaryPositions[rightComponent].y);
-                            lpath.push({
-                                x: boundaryPositions[leftComponent].x,
-                                y: leftY
-                            });
-                            lpath.push({
-                                x: centerX,
-                                y: leftY
-                            });
-                            lpath.push({
-                                x: centerX,
-                                y: boundaryPositions[rightComponent].y
-                            });
-                            break;
-                        case NORTH:
-                        case SOUTH:
-                            var leftY = leftComponentDirection === SOUTH
-                                ? Math.max(boundaryPositions[leftComponent].y, boundaryPositions[rightComponent].y)
-                                : Math.min(boundaryPositions[leftComponent].y, boundaryPositions[rightComponent].y);
-                            lpath.push({
-                                x: boundaryPositions[leftComponent].x,
-                                y: leftY
-                            });
-                            lpath.push({
-                                x: centerX,
-                                y: leftY
-                            });
-                            lpath.push({
-                                x: centerX,
-                                y: boundaryPositions[rightComponent].y
-                            });
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    break;
-                case EAST:
-                    switch (leftComponentDirection) {
-                        case EAST:
-                            var leftY = boundaryPositions[leftComponent].y < boundaryPositions[rightComponent].y
-                                ? Math.min(fromToBounds[rightComponent].top, boundaryPositions[leftComponent].y)
-                                : Math.max(fromToBounds[rightComponent].top + fromToBounds[rightComponent].height, boundaryPositions[leftComponent].y);
-                            var rightY = leftY;
-                            break;
-                        case WEST:
-                            var leftY = centerY !== undefined
-                                ? centerY
-                                : boundaryPositions[leftComponent].y < boundaryPositions[rightComponent].y
-                                    ? unionBounds.top - centerWidth * 0.5
-                                    : unionBounds.top + unionBounds.height + centerWidth * 0.5;
-                            var rightY = leftY;
-                            break;
-                        case SOUTH:
-                            var leftY = centerY !== undefined
-                                ? Math.max(centerY, boundaryPositions[leftComponent].y)
-                                : unionBounds.top + unionBounds.height;
-                            var rightY = leftY;
-                            break;
-                        case NORTH:
-                            var leftY = centerY ? Math.min(centerY, fromToBounds[leftComponent].top) : unionBounds.top;
-                            var rightY = leftY;
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    lpath.push({
-                        x: boundaryPositions[leftComponent].x,
-                        y: leftY
-                    });
-                    lpath.push({
-                        x: centerX,
-                        y: leftY
-                    });
-                    lpath.push({
-                        x: centerX,
-                        y: rightY
-                    });
-                    lpath.push({
-                        x: boundaryPositions[rightComponent].x,
-                        y: rightY
-                    });
-                    break;
-                case SOUTH:
-                    switch (leftComponentDirection) {
-                        case EAST:
-                            var leftY = boundaryPositions[leftComponent].y;
-                            var rightY = boundaryPositions[leftComponent].y > boundaryPositions[rightComponent].y
-                                ? boundaryPositions[leftComponent].y
-                                : fromToBounds[rightComponent].top + fromToBounds[rightComponent].height;
-                            break;
-                        case WEST:
-                            var leftY = centerY
-                                ? Math.max(centerY, fromToBounds[rightComponent].top + fromToBounds[rightComponent].height)
-                                : unionBounds.top + unionBounds.height;
-                            var rightY = leftY;
-                            break;
-                        case SOUTH:
-                            var leftY = unionBounds.top + unionBounds.height;
-                            var rightY = leftY;
-                            break;
-                        case NORTH:
-                            var leftY = centerY ? Math.min(centerY, fromToBounds[leftComponent].top) : fromToBounds[leftComponent].top;
-                            var rightY = centerY
-                                ? Math.max(centerY, fromToBounds[rightComponent].top + fromToBounds[rightComponent].height)
-                                : fromToBounds[rightComponent].top + fromToBounds[rightComponent].height;
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    lpath.push({
-                        x: boundaryPositions[leftComponent].x,
-                        y: leftY
-                    });
-                    lpath.push({
-                        x: centerX,
-                        y: leftY
-                    });
-                    lpath.push({
-                        x: centerX,
-                        y: rightY
-                    });
-                    lpath.push({
-                        x: boundaryPositions[rightComponent].x,
-                        y: rightY
-                    });
-                    break;
-                case NORTH:
-                    switch (leftComponentDirection) {
-                        case EAST:
-                            var leftY = boundaryPositions[leftComponent].y;
-                            var rightY = boundaryPositions[leftComponent].y < boundaryPositions[rightComponent].y
-                                ? boundaryPositions[leftComponent].y
-                                : fromToBounds[rightComponent].top;
-                            break;
-                        case WEST:
-                            var leftY = centerY ? Math.min(centerY, fromToBounds[rightComponent].top) : unionBounds.top;
-                            var rightY = leftY;
-                            break;
-                        case SOUTH:
-                            var leftY = centerY !== undefined
-                                ? Math.max(centerY, boundaryPositions[leftComponent].y)
-                                : boundaryPositions[leftComponent].y;
-                            var rightY = centerY !== undefined
-                                ? Math.min(centerY, boundaryPositions[rightComponent].y)
-                                : boundaryPositions[rightComponent].y;
-                            break;
-                        case NORTH:
-                            var leftY = unionBounds.top;
-                            var rightY = leftY;
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    lpath.push({
-                        x: boundaryPositions[leftComponent].x,
-                        y: leftY
-                    });
-                    lpath.push({
-                        x: centerX,
-                        y: leftY
-                    });
-                    lpath.push({
-                        x: centerX,
-                        y: rightY
-                    });
-                    lpath.push({
-                        x: boundaryPositions[rightComponent].x,
-                        y: rightY
-                    });
-                    break;
-                default:
-                    return this.path;
-            }
-            path.push(...(leftComponent === FROM ? lpath : lpath.reverse()));
-        }
-        else if (centerY) {
-            switch (lowerComponentDirection) {
-                case NORTH:
-                    switch (upperComponentDirection) {
-                        case SOUTH:
-                            lpath.push({
-                                x: boundaryPositions[upperComponent].x,
-                                y: centerY
-                            });
-                            lpath.push({
-                                x: boundaryPositions[lowerComponent].x,
-                                y: centerY
-                            });
-                            break;
-                        case NORTH:
-                            var upperComponentCenterX = fromToBounds[upperComponent].left + fromToBounds[upperComponent].width / 2;
-                            var upperX = upperComponentCenterX > boundaryPositions[lowerComponent].x
-                                ? Math.min(fromToBounds[upperComponent].left, boundaryPositions[lowerComponent].x)
-                                : Math.max(fromToBounds[upperComponent].left + fromToBounds[upperComponent].width, boundaryPositions[lowerComponent].x);
-                            lpath.push({
-                                x: upperX,
-                                y: boundaryPositions[upperComponent].y
-                            });
-                            lpath.push({
-                                x: upperX,
-                                y: centerY
-                            });
-                            lpath.push({
-                                x: boundaryPositions[lowerComponent].x,
-                                y: centerY
-                            });
-                            break;
-                        case WEST:
-                            var upperX = Math.min(boundaryPositions[upperComponent].x, boundaryPositions[lowerComponent].x);
-                            lpath.push({
-                                x: upperX,
-                                y: boundaryPositions[upperComponent].y
-                            });
-                            lpath.push({
-                                x: upperX,
-                                y: centerY
-                            });
-                            lpath.push({
-                                x: boundaryPositions[lowerComponent].x,
-                                y: centerY
-                            });
-                            break;
-                        case EAST:
-                            var upperX = Math.max(boundaryPositions[upperComponent].x, boundaryPositions[lowerComponent].x);
-                            lpath.push({
-                                x: upperX,
-                                y: boundaryPositions[upperComponent].y
-                            });
-                            lpath.push({
-                                x: upperX,
-                                y: centerY
-                            });
-                            lpath.push({
-                                x: boundaryPositions[lowerComponent].x,
-                                y: centerY
-                            });
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    break;
-                case SOUTH:
-                    switch (upperComponentDirection) {
-                        case WEST:
-                            var upperX = unionBounds.left;
-                            var lowerX = upperX;
-                            break;
-                        case EAST:
-                            var upperX = centerX !== undefined
-                                ? Math.max(centerX, boundaryPositions[upperComponent].x)
-                                : unionBounds.left + unionBounds.width;
-                            var lowerX = upperX;
-                            break;
-                        case NORTH:
-                            var upperX = centerX !== undefined
-                                ? centerX
-                                : boundaryPositions[upperComponent].x < boundaryPositions[lowerComponent].x
-                                    ? unionBounds.left - centerHeight * 0.5
-                                    : unionBounds.left + unionBounds.width + centerHeight * 0.5;
-                            var lowerX = upperX;
-                            break;
-                        case SOUTH:
-                            var upperX = boundaryPositions[upperComponent].x;
-                            var lowerX = boundaryPositions[upperComponent].x < boundaryPositions[lowerComponent].x
-                                ? Math.min(fromToBounds[lowerComponent].left, boundaryPositions[upperComponent].x)
-                                : Math.max(fromToBounds[lowerComponent].left + fromToBounds[lowerComponent].width, boundaryPositions[upperComponent].x);
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    lpath.push({
-                        x: upperX,
-                        y: boundaryPositions[upperComponent].y
-                    });
-                    lpath.push({
-                        x: upperX,
-                        y: centerY
-                    });
-                    lpath.push({
-                        x: lowerX,
-                        y: centerY
-                    });
-                    lpath.push({
-                        x: lowerX,
-                        y: boundaryPositions[lowerComponent].y
-                    });
-                    break;
-                case EAST:
-                    switch (upperComponentDirection) {
-                        case WEST:
-                            var upperX = centerX !== undefined
-                                ? Math.min(centerX, boundaryPositions[upperComponent].x)
-                                : boundaryPositions[upperComponent].x;
-                            var lowerX = centerX !== undefined
-                                ? Math.max(centerX, boundaryPositions[lowerComponent].x)
-                                : boundaryPositions[lowerComponent].x;
-                            break;
-                        case EAST:
-                            var upperX = unionBounds.left + unionBounds.width;
-                            var lowerX = upperX;
-                            break;
-                        case NORTH:
-                            var upperX = centerX !== undefined
-                                ? Math.max(centerX, boundaryPositions[lowerComponent].x)
-                                : unionBounds.left + unionBounds.width;
-                            var lowerX = upperX;
-                            break;
-                        case SOUTH:
-                            var upperX = boundaryPositions[upperComponent].x;
-                            var lowerX = Math.max(fromToBounds[lowerComponent].left + fromToBounds[lowerComponent].width, boundaryPositions[upperComponent].x);
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    lpath.push({
-                        x: upperX,
-                        y: boundaryPositions[upperComponent].y
-                    });
-                    lpath.push({
-                        x: upperX,
-                        y: centerY
-                    });
-                    lpath.push({
-                        x: lowerX,
-                        y: centerY
-                    });
-                    lpath.push({
-                        x: lowerX,
-                        y: boundaryPositions[lowerComponent].y
-                    });
-                    break;
-                case WEST:
-                    switch (upperComponentDirection) {
-                        case WEST:
-                            var upperX = unionBounds.left;
-                            var lowerX = upperX;
-                            break;
-                        case EAST:
-                            var upperX = centerX !== undefined
-                                ? Math.max(centerX, boundaryPositions[upperComponent].x)
-                                : boundaryPositions[upperComponent].x;
-                            var lowerX = centerX !== undefined
-                                ? Math.min(centerX, boundaryPositions[lowerComponent].x)
-                                : boundaryPositions[lowerComponent].x;
-                            break;
-                        case NORTH:
-                            var upperX = unionBounds.left;
-                            var lowerX = upperX;
-                            break;
-                        case SOUTH:
-                            var upperX = boundaryPositions[upperComponent].x < boundaryPositions[lowerComponent].x
-                                ? Math.min(fromToBounds[lowerComponent].left, boundaryPositions[upperComponent].x)
-                                : boundaryPositions[upperComponent].x;
-                            var lowerX = Math.min(upperX, boundaryPositions[lowerComponent].x);
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    lpath.push({
-                        x: upperX,
-                        y: boundaryPositions[upperComponent].y
-                    });
-                    lpath.push({
-                        x: upperX,
-                        y: centerY
-                    });
-                    lpath.push({
-                        x: lowerX,
-                        y: centerY
-                    });
-                    lpath.push({
-                        x: lowerX,
-                        y: boundaryPositions[lowerComponent].y
-                    });
-                    break;
-                default:
-                    return this.path;
-            }
-            path.push(...(upperComponent === FROM ? lpath : lpath.reverse()));
-        }
-        else {
-            switch (fromDirection) {
-                case NORTH:
-                    switch (toDirection) {
-                        case NORTH:
-                            var y = unionBounds.top;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case SOUTH:
-                            var x = unionBounds.left + unionBounds.width;
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y: unionBounds.top + unionBounds.height
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y: unionBounds.top + unionBounds.height
-                            });
-                            break;
-                        case EAST:
-                            var x = boundaryPositions[TO].y < boundaryPositions[FROM].y &&
-                                boundaryPositions[TO].x < boundaryPositions[FROM].x
-                                ? boundaryPositions[FROM].x
-                                : unionBounds.left + unionBounds.width;
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y: boundaryPositions[TO].y
-                            });
-                            break;
-                        case WEST:
-                            var x = unionBounds.left;
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y: boundaryPositions[TO].y
-                            });
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    break;
-                case SOUTH:
-                    switch (toDirection) {
-                        case NORTH:
-                            var x = unionBounds.left + unionBounds.width;
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y: unionBounds.top
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y: unionBounds.top
-                            });
-                            break;
-                        case SOUTH:
-                            var y = unionBounds.top + unionBounds.height;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case EAST:
-                            var y = unionBounds.top + unionBounds.height;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case WEST:
-                            var y = unionBounds.top + unionBounds.height;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    break;
-                case WEST:
-                    switch (toDirection) {
-                        case NORTH:
-                            var x = boundaryPositions[FROM].x > boundaryPositions[TO].x &&
-                                boundaryPositions[FROM].y < boundaryPositions[TO].y
-                                ? boundaryPositions[TO].x
-                                : unionBounds.left;
-                            var y = boundaryPositions[FROM].x > boundaryPositions[TO].x &&
-                                boundaryPositions[FROM].y < boundaryPositions[TO].y
-                                ? boundaryPositions[TO].y
-                                : Math.min(unionBounds.top, boundaryPositions[FROM].y);
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case SOUTH:
-                            var x = unionBounds.left;
-                            var y = Math.max(unionBounds.top + unionBounds.height, boundaryPositions[FROM].y);
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case EAST:
-                            var x = unionBounds.left + unionBounds.width;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y: unionBounds.top
-                            });
-                            path.push({
-                                x,
-                                y: unionBounds.top
-                            });
-                            path.push({
-                                x,
-                                y: boundaryPositions[TO].y
-                            });
-                            break;
-                        case WEST:
-                            var x = unionBounds.left;
-                            path.push({
-                                x,
-                                y: boundaryPositions[FROM].y
-                            });
-                            path.push({
-                                x,
-                                y: boundaryPositions[TO].y
-                            });
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    break;
-                case EAST:
-                    switch (toDirection) {
-                        case NORTH:
-                            var y = boundaryPositions[FROM].y < boundaryPositions[TO].y &&
-                                boundaryPositions[FROM].x < boundaryPositions[TO].x
-                                ? boundaryPositions[FROM].y
-                                : unionBounds.top;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case SOUTH:
-                            var y = boundaryPositions[FROM].y > boundaryPositions[TO].y &&
-                                boundaryPositions[FROM].x < boundaryPositions[TO].x
-                                ? boundaryPositions[FROM].y
-                                : unionBounds.top + unionBounds.height;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case EAST:
-                            var y = unionBounds.top + unionBounds.height;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        case WEST:
-                            var y = unionBounds.top + unionBounds.height;
-                            path.push({
-                                x: boundaryPositions[FROM].x,
-                                y
-                            });
-                            path.push({
-                                x: boundaryPositions[TO].x,
-                                y
-                            });
-                            break;
-                        default:
-                            return this.path;
-                    }
-                    break;
-                default:
-                    return this.path;
-            }
-        }
-        if (toBoundaryPosition) {
-            path.push(toBoundaryPosition);
-        }
-        /* following 2 filters not to be merged */
-        return [fromPosition, ...path, toPosition]
-            .filter((p, idx, path) => {
-            if (idx === 0) {
-                return true;
-            }
-            const prev = path[idx - 1];
-            if (p.x === prev.x && p.y === prev.y) {
-                return false;
-            }
-            return true;
-        })
-            .filter((p, idx, path) => {
-            if (idx === 0 || idx >= path.length - 1) {
-                return true;
-            }
-            const prev = path[idx - 1];
-            const next = path[idx + 1];
-            if ((p.x === prev.x && p.x === next.x) || (p.y === prev.y && p.y === next.y)) {
-                return false;
-            }
-            return true;
-        });
-    }
-    get nature() {
-        return NATURE;
-    }
-}
-Component.register('ortholine', OrthoLine);
-//# sourceMappingURL=ortholine.js.map