@hatiolab/things-scene 9.0.0-beta.35 → 9.0.0-beta.36

package/dist/components/ortholine.js

@@ -0,0 +1,763 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _component = _interopRequireDefault(require("./component.js"));
+var _line = _interopRequireWildcard(require("./line.js"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ */
+
+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'
+};
+class OrthoLine extends _line.default {
+  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?.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?.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 _line.WEST:
+          switch (leftComponentDirection) {
+            case _line.EAST:
+              lpath.push({
+                x: centerX,
+                y: boundaryPositions[leftComponent].y
+              });
+              lpath.push({
+                x: centerX,
+                y: boundaryPositions[rightComponent].y
+              });
+              break;
+            case _line.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 _line.NORTH:
+            case _line.SOUTH:
+              var leftY = leftComponentDirection === _line.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 _line.EAST:
+          switch (leftComponentDirection) {
+            case _line.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 _line.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 _line.SOUTH:
+              var leftY = centerY !== undefined ? Math.max(centerY, boundaryPositions[leftComponent].y) : unionBounds.top + unionBounds.height;
+              var rightY = leftY;
+              break;
+            case _line.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 _line.SOUTH:
+          switch (leftComponentDirection) {
+            case _line.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 _line.WEST:
+              var leftY = centerY ? Math.max(centerY, fromToBounds[rightComponent].top + fromToBounds[rightComponent].height) : unionBounds.top + unionBounds.height;
+              var rightY = leftY;
+              break;
+            case _line.SOUTH:
+              var leftY = unionBounds.top + unionBounds.height;
+              var rightY = leftY;
+              break;
+            case _line.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 _line.NORTH:
+          switch (leftComponentDirection) {
+            case _line.EAST:
+              var leftY = boundaryPositions[leftComponent].y;
+              var rightY = boundaryPositions[leftComponent].y < boundaryPositions[rightComponent].y ? boundaryPositions[leftComponent].y : fromToBounds[rightComponent].top;
+              break;
+            case _line.WEST:
+              var leftY = centerY ? Math.min(centerY, fromToBounds[rightComponent].top) : unionBounds.top;
+              var rightY = leftY;
+              break;
+            case _line.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 _line.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 _line.NORTH:
+          switch (upperComponentDirection) {
+            case _line.SOUTH:
+              lpath.push({
+                x: boundaryPositions[upperComponent].x,
+                y: centerY
+              });
+              lpath.push({
+                x: boundaryPositions[lowerComponent].x,
+                y: centerY
+              });
+              break;
+            case _line.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 _line.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 _line.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 _line.SOUTH:
+          switch (upperComponentDirection) {
+            case _line.WEST:
+              var upperX = unionBounds.left;
+              var lowerX = upperX;
+              break;
+            case _line.EAST:
+              var upperX = centerX !== undefined ? Math.max(centerX, boundaryPositions[upperComponent].x) : unionBounds.left + unionBounds.width;
+              var lowerX = upperX;
+              break;
+            case _line.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 _line.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 _line.EAST:
+          switch (upperComponentDirection) {
+            case _line.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 _line.EAST:
+              var upperX = unionBounds.left + unionBounds.width;
+              var lowerX = upperX;
+              break;
+            case _line.NORTH:
+              var upperX = centerX !== undefined ? Math.max(centerX, boundaryPositions[lowerComponent].x) : unionBounds.left + unionBounds.width;
+              var lowerX = upperX;
+              break;
+            case _line.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 _line.WEST:
+          switch (upperComponentDirection) {
+            case _line.WEST:
+              var upperX = unionBounds.left;
+              var lowerX = upperX;
+              break;
+            case _line.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 _line.NORTH:
+              var upperX = unionBounds.left;
+              var lowerX = upperX;
+              break;
+            case _line.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 _line.NORTH:
+          switch (toDirection) {
+            case _line.NORTH:
+              var y = unionBounds.top;
+              path.push({
+                x: boundaryPositions[FROM].x,
+                y
+              });
+              path.push({
+                x: boundaryPositions[TO].x,
+                y
+              });
+              break;
+            case _line.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 _line.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 _line.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 _line.SOUTH:
+          switch (toDirection) {
+            case _line.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 _line.SOUTH:
+              var y = unionBounds.top + unionBounds.height;
+              path.push({
+                x: boundaryPositions[FROM].x,
+                y
+              });
+              path.push({
+                x: boundaryPositions[TO].x,
+                y
+              });
+              break;
+            case _line.EAST:
+              var y = unionBounds.top + unionBounds.height;
+              path.push({
+                x: boundaryPositions[FROM].x,
+                y
+              });
+              path.push({
+                x: boundaryPositions[TO].x,
+                y
+              });
+              break;
+            case _line.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 _line.WEST:
+          switch (toDirection) {
+            case _line.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 _line.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 _line.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 _line.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 _line.EAST:
+          switch (toDirection) {
+            case _line.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 _line.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 _line.EAST:
+              var y = unionBounds.top + unionBounds.height;
+              path.push({
+                x: boundaryPositions[FROM].x,
+                y
+              });
+              path.push({
+                x: boundaryPositions[TO].x,
+                y
+              });
+              break;
+            case _line.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;
+  }
+}
+exports.default = OrthoLine;
+_component.default.register('ortholine', OrthoLine);
+//# sourceMappingURL=ortholine.js.map