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

package/dist/components/ortholine.js

@@ -1,763 +0,0 @@
-"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