@hatiolab/things-scene 9.0.0-beta.2 → 9.0.0-beta.21

package/dist/components/ortholine.js

@@ -0,0 +1,814 @@
+/*
+ * 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