@crystaldesign/web-planner-logic 26.11.0-beta.3 → 26.11.0-beta.31

package/build/esm/{DivaStandardPlanner-a8f0d722.js → DivaStandardPlanner-d9cad991.js}

@@ -1,26 +1,47 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { V as Vector3, c as Vector2, P as PlannerElementData, B as BoundingBox } from './index-358c0a3c.js';
+import { V as Vector3, P as PlannerElementData, B as BoundingBox } from './index-024475bf.js';
 import DivaUtils, { DivaError, md5 } from '@crystaldesign/diva-utils';
-import { d as dockingPointHandlerInst, h as handler2D } from './PlannerHandler2D-f8657005.js';
+import { computeDockedTransform } from '@crystaldesign/planner-2d-core';
+import { d as dockingPointHandlerInst, h as handler2D } from './PlannerHandler2D-2fc26200.js';
 import '@babel/runtime/helpers/slicedToArray';
 import '@babel/runtime/helpers/objectWithoutProperties';
-import '@babel/runtime/helpers/toConsumableArray';
 import 'axios';
 import '@crystaldesign/basket-model';
 import '@babel/runtime/helpers/typeof';
+import 'fast-xml-parser';
 import '@babel/runtime/helpers/possibleConstructorReturn';
 import '@babel/runtime/helpers/getPrototypeOf';
 import '@babel/runtime/helpers/inherits';
 import '@babel/runtime/helpers/wrapNativeSuper';
 import '@crystaldesign/basket-handler';
 import 'socket.io-client';
-import 'fabric';
-import 'w3c-xmlserializer';
+import '@babel/runtime/helpers/get';
 
+/** Configurator 2.0 set planner payload (`SetPlanData` after base64 decode). */
+
+/** Legacy planner 1.x payload (no `v: 2` wrapper). */
+
+function parseSetPlanData(setPlanData) {
+  var planDataString = DivaUtils.decodeBase64(setPlanData);
+  return JSON.parse(planDataString);
+}
+function isSavePlannerV2(planData) {
+  return planData.v === 2;
+}
+
+/** Article codex from a V2 or legacy element record. */
+function saveElementArticleCodex(element) {
+  return element.articleCodex || element.Codex;
+}
+
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 var LOG = DivaUtils.initLog('Planner', 'WEB-PLANNER-LOGIC');
 var ACC_DOCK_TYPES = ['AVO', 'AVU', 'AVC', 'AVS', 'AVN'];
 var DivaStandardPlanner = /*#__PURE__*/function () {
@@ -50,7 +71,13 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
     _defineProperty(this, "nextElementId", 1);
     _defineProperty(this, "collisionHandler", void 0);
     _defineProperty(this, "dockToAVUorAVOororAVNorAVSorAVC", function (plannerElement, targetElements) {
-      if (plannerElement.HasAVU) {
+      // Capability comes from the SVG-parsed docking points, not the catalog metadata counts
+      // (countAV*): the parsed SVG is the same source the targeted dock (tryDockElementToDP) uses, so
+      // auto-dock stays consistent with it even when the catalog's SVG detail info misses the counts.
+      var hasFreeDP = function hasFreeDP(type) {
+        return plannerElement.getFreeDockingPointsByType(type).length > 0;
+      };
+      if (hasFreeDP('AVU')) {
         //Try to dock Element to free AVR
         var successDP = dockingPointHandlerInst.tryDockElement(plannerElement, 'AVU', targetElements);
         if (successDP) {
@@ -66,28 +93,28 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           if (_successDP) return true;
         }
       }
-      if (plannerElement.HasAVO) {
+      if (hasFreeDP('AVO')) {
         var _successDP2 = dockingPointHandlerInst.tryDockElement(plannerElement, 'AVO', targetElements);
         if (_successDP2) {
           _this.updateWorldPos(plannerElement, _successDP2);
           return true;
         }
       }
-      if (plannerElement.HasAVN) {
+      if (hasFreeDP('AVN')) {
         var _successDP3 = dockingPointHandlerInst.tryDockElement(plannerElement, 'AVN', targetElements);
         if (_successDP3) {
           _this.updateWorldPos(plannerElement, _successDP3);
           return true;
         }
       }
-      if (plannerElement.HasAVS) {
+      if (hasFreeDP('AVS')) {
         var _successDP4 = dockingPointHandlerInst.tryDockElement(plannerElement, 'AVS', targetElements);
         if (_successDP4) {
           _this.updateWorldPos(plannerElement, _successDP4);
           return true;
         }
       }
-      if (plannerElement.HasAVC) {
+      if (hasFreeDP('AVC')) {
         var _successDP5 = dockingPointHandlerInst.tryDockElement(plannerElement, 'AVC', targetElements);
         if (_successDP5) {
           _this.updateWorldPos(plannerElement, _successDP5);
@@ -220,30 +247,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
       var refElement = this.plannerElements.get(dockingPoint.OnElementId);
       var refDockingPoint = refElement.getDockingPointById(dockingPoint.OnDP.DpId);
       if (refDockingPoint == undefined) return updateConfig;
-      var worldPosNewElement = new Vector3(0, 0, 0);
-      var worldPosNewElementIgnoreOLF = new Vector3(0, 0, 0);
-
-      // DP LocalWorldPos is OLF-corner-relative when HasOLFPolygon (from SVG). Convert to OLT-corner-relative for WorldPosCornerIgnoreOLF.
-      var refDPLocalOlt = refElement.HasOLFPolygon ? new Vector2(refDockingPoint.LocalWorldPos.x - refElement.getOltLeft(), refDockingPoint.LocalWorldPos.z - refElement.getOltTop()) : new Vector2(refDockingPoint.LocalWorldPos.x, refDockingPoint.LocalWorldPos.z);
-      var newDPLocalOlt = plannerElement.HasOLFPolygon ? new Vector2(dockingPoint.LocalWorldPos.x - plannerElement.getOltLeft(), dockingPoint.LocalWorldPos.z - plannerElement.getOltTop()) : new Vector2(dockingPoint.LocalWorldPos.x, dockingPoint.LocalWorldPos.z);
-      var rotatedLocalRefDP = new Vector2(refDockingPoint.LocalWorldPos.x, refDockingPoint.LocalWorldPos.z);
-      rotatedLocalRefDP = Vector2.rotateOrigin(rotatedLocalRefDP, refElement.RotDeg);
-      var angleToRot = refElement.RotDeg + refDockingPoint.RotDeg - dockingPoint.RotDeg;
-      plannerElement.RotDeg = angleToRot;
-      var refWorldPosCor = refElement.WorldPosCorner;
-      // For ref without OLF: use same corner for both alignments (no OLF/OLT split; WorldPosCornerIgnoreOLF getter also does this).
-      var refWorldPosCorIgnoreOLF = refElement.HasOLFPolygon ? refElement.WorldPosCornerIgnoreOLF : refWorldPosCor;
-      var rotatedLocalDP2D = Vector2.rotateOrigin(new Vector2(dockingPoint.LocalWorldPos.x, dockingPoint.LocalWorldPos.z), angleToRot);
-      worldPosNewElement.x = refWorldPosCor.x + rotatedLocalRefDP.x - rotatedLocalDP2D.x;
-      worldPosNewElement.y = refWorldPosCor.y + refDockingPoint.LocalWorldPos.y - dockingPoint.LocalWorldPos.y;
-      worldPosNewElement.z = refWorldPosCor.z + rotatedLocalRefDP.y - rotatedLocalDP2D.y;
-      var rotatedRefDPOlt = Vector2.rotateOrigin(refDPLocalOlt, refElement.RotDeg);
-      var rotatedNewDPOlt = Vector2.rotateOrigin(newDPLocalOlt, angleToRot);
-      worldPosNewElementIgnoreOLF.x = refWorldPosCorIgnoreOLF.x + rotatedRefDPOlt.x - rotatedNewDPOlt.x;
-      worldPosNewElementIgnoreOLF.z = refWorldPosCorIgnoreOLF.z + rotatedRefDPOlt.y - rotatedNewDPOlt.y;
-      worldPosNewElementIgnoreOLF.y = refWorldPosCorIgnoreOLF.y + refDockingPoint.LocalWorldPos.y - dockingPoint.LocalWorldPos.y;
-      plannerElement.WorldPosCorner = worldPosNewElement;
-      plannerElement.WorldPosCornerIgnoreOLF = worldPosNewElementIgnoreOLF;
+      this.applyDockTransform(plannerElement, refElement, dockingPoint, refDockingPoint);
       updateConfig = this.set.onDockingChanged(plannerElement.ElementId, refElement.ElementId, 'DOCK', dockingPoint.Type);
       var data = this.set.getPlannerData(plannerElement.ElementId);
       plannerElement.updatePlannerData(data);
@@ -252,15 +256,81 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
       return updateConfig;
     }
 
+    /**
+     * Positions `plannerElement` so its `dockingPoint` aligns to `refElement`'s `refDockingPoint`
+     * (rotation + OLF/OLT-aware translation). Mutates only the element's world position and rotation —
+     * NOT the docking relations — so it is reusable for a non-committing snap preview
+     * ({@link getDockSnapPreview}) as well as the real dock ({@link updateWorldPos}).
+     */
+  }, {
+    key: "applyDockTransform",
+    value: function applyDockTransform(plannerElement, refElement, dockingPoint, refDockingPoint) {
+      var dockedTransform = computeDockedTransform(refElement, refDockingPoint, plannerElement, dockingPoint);
+      plannerElement.RotDeg = dockedTransform.rotDeg;
+      plannerElement.WorldPosCorner = new Vector3(dockedTransform.worldPosCorner.x, dockedTransform.worldPosCorner.y, dockedTransform.worldPosCorner.z);
+      plannerElement.WorldPosCornerIgnoreOLF = new Vector3(dockedTransform.worldPosCornerIgnoreOLF.x, dockedTransform.worldPosCornerIgnoreOLF.y, dockedTransform.worldPosCornerIgnoreOLF.z);
+    }
+
+    /**
+     * Non-committing preview of where `elementId` would auto-snap if released now: runs the same
+     * dockable-pair search as END, and for the closest pair computes the docked transform via
+     * {@link applyDockTransform} (apply → read → restore, no docking relations touched). Returns the
+     * delta from the element's current transform (cm / deg), or null if nothing is in snapping range.
+     * `excludeElementIds` skips the element's own move-group so it doesn't "snap" to siblings that
+     * are translating with it.
+     */
+  }, {
+    key: "getDockSnapPreview",
+    value: function getDockSnapPreview(elementId, autoDockingDistance) {
+      var excludeElementIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      var element = this.plannerElements.get(elementId);
+      if (!element) return null;
+      var targets = this.getAllPlannerElements().filter(function (e) {
+        return e.getElementId() !== elementId && !excludeElementIds.includes(e.getElementId());
+      });
+      var pairs = dockingPointHandlerInst.searchDockableElementsInArea(element, targets, autoDockingDistance);
+      if (!pairs || pairs.size === 0) return null;
+      var best;
+      pairs.forEach(function (p) {
+        if (best == undefined || p.distance < best.distance) best = p;
+      });
+      if (best == undefined) return null;
+      var targetElement = this.plannerElements.get(best.targetDP.ElementId);
+      if (!targetElement) return null;
+      var savedRot = element.RotDeg;
+      var savedCenter = element.WorldPosCenter;
+      var savedX = savedCenter.x,
+        savedY = savedCenter.y,
+        savedZ = savedCenter.z;
+      this.applyDockTransform(element, targetElement, best.sourceDP, best.targetDP);
+      var snapped = element.WorldPosCenter;
+      var result = {
+        dx: snapped.x - savedX,
+        dz: snapped.z - savedZ,
+        dRotDeg: element.RotDeg - savedRot
+      };
+      // Restore — the preview must leave the planner state untouched.
+      element.RotDeg = savedRot;
+      element.WorldPosCenter = new Vector3(savedX, savedY, savedZ);
+      return result;
+    }
+
     /**
      * This function updates the position information of all elements. It is called after updating the SVG of 1 element.
      * The position is updated based on the posNr.
      * At the end - the collision is calculated
+     * @param changedElementIds elements whose SVG was reloaded this cycle (their docking geometry may
+     * have moved, e.g. an AVC shifted by stretch areas). Elements docked - directly or transitively -
+     * to one of them are re-anchored to the moved partner after the PosNr walk, which on its own only
+     * propagates forward in PosNr order and prefers AVL over AVC anchors.
      */
   }, {
     key: "updateAllElementsWorldPos",
-    value: function updateAllElementsWorldPos(checkCollisionSingleElementId) {
+    value: function updateAllElementsWorldPos(checkCollisionSingleElementId, changedElementIds) {
       if (this.doDisablePlanner2D) return false;
+      var getDockedDPsInPriorityOrder = function getDockedDPsInPriorityOrder(element) {
+        return element.getDockingDockingPointsByType('AVL').concat(element.getDockingDockingPointsByType('AVR')).concat(element.getDockingDockingPointsByType('AVU')).concat(element.getDockingDockingPointsByType('AVO')).concat(element.getDockingDockingPointsByType('AVN')).concat(element.getDockingDockingPointsByType('AVS')).concat(element.getDockingDockingPointsByType('AVC'));
+      };
       var updateConfig = false;
       var sortedPlannerElementsbyPosNr = [];
       var accElems = [];
@@ -281,7 +351,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           var element = sortedPlannerElementsbyPosNr[i];
           alreadyCorrectedId.push(element.ElementId);
           if (i > firstI) {
-            var dockingPoints = element.getDockingDockingPointsByType('AVL').concat(element.getDockingDockingPointsByType('AVR')).concat(element.getDockingDockingPointsByType('AVU')).concat(element.getDockingDockingPointsByType('AVO')).concat(element.getDockingDockingPointsByType('AVN')).concat(element.getDockingDockingPointsByType('AVS')).concat(element.getDockingDockingPointsByType('AVC'));
+            var dockingPoints = getDockedDPsInPriorityOrder(element);
             for (var j = 0; j < dockingPoints.length; j++) {
               //Nur wenn er auf ein element schaut das schon gedockt ist korrigieren
               if (alreadyCorrectedId.indexOf(dockingPoints[j].OnElementId) >= 0) {
@@ -292,6 +362,38 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           }
         }
       }
+
+      // The walk above anchors each element to its FIRST docked partner in AVL-first priority and
+      // only propagates forward in PosNr order - both hide a geometry change in a reloaded partner
+      // (e.g. an AVC line shifted by stretch areas). Sweep outward from the reloaded elements:
+      // re-anchor every element docked - directly or transitively - to a moved partner, until stable.
+      if (changedElementIds && changedElementIds.length > 0) {
+        var moved = new Set(changedElementIds);
+        var progressed = true;
+        while (progressed) {
+          progressed = false;
+          var _iterator = _createForOfIteratorHelper(sortedPlannerElementsbyPosNr),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _element = _step.value;
+              if (!_element || moved.has(_element.ElementId)) continue;
+              var dpToMovedPartner = getDockedDPsInPriorityOrder(_element).find(function (dp) {
+                return moved.has(dp.OnElementId);
+              });
+              if (dpToMovedPartner) {
+                updateConfig = this.updateWorldPos(_element, dpToMovedPartner) || updateConfig;
+                moved.add(_element.ElementId);
+                progressed = true;
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+      }
       this.checkCollision(false, checkCollisionSingleElementId);
       return updateConfig;
     }
@@ -334,39 +436,39 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               plannerElement.WorldPosCenter = setToTransform.transform.worldPosCenter;
               plannerElement.RotDeg = setToTransform.transform.rotDeg;
               this.set.onDockingChanged(plannerElement.ElementId, -1, 'NOT_DOCKED');
-              _context.next = 47;
+              _context.next = 48;
               break;
             case 8:
               //Nun unterscheidet man, ob man das Element zu einem bestimmten vorselektierten Element Docken will , zu einem vorselektierten DockingPoint oder an eine Freie Planung.
               dockingFound = false;
               if (!dockingPointInfos) {
-                _context.next = 46;
+                _context.next = 47;
                 break;
               }
               i = 0;
             case 11:
               if (!(i < dockingPointInfos.length)) {
-                _context.next = 46;
+                _context.next = 47;
                 break;
               }
               targetElemIdToDock = dockingPointInfos[i].targetElemIdToDock;
               targetDockingPointId = dockingPointInfos[i].targetDockingPointId;
               if (!(targetElemIdToDock && targetElemIdToDock > -1 && this.plannerElements.has(targetElemIdToDock))) {
-                _context.next = 43;
+                _context.next = 44;
                 break;
               }
               if (!(targetDockingPointId && targetDockingPointId != '')) {
-                _context.next = 31;
+                _context.next = 32;
                 break;
               }
               targetElem = this.plannerElements.get(targetElemIdToDock);
               if (!targetElem) {
-                _context.next = 29;
+                _context.next = 30;
                 break;
               }
               targetDP = targetElem.getDockingPointById(targetDockingPointId);
               if (!targetDP) {
-                _context.next = 29;
+                _context.next = 30;
                 break;
               }
               successDP = dockingPointHandlerInst.tryDockElementToDP(plannerElement, targetElem, targetDP);
@@ -376,17 +478,21 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               }
               this.updateWorldPos(plannerElement, successDP);
               dockingFound = true;
-              _context.next = 29;
+              _context.next = 30;
               break;
             case 26:
               _context.next = 28;
               return this.tryToDockWithDifferentSVGWithFormula(plannerElement, targetElemIdToDock);
             case 28:
-              success = _context.sent;
-            case 29:
-              _context.next = 43;
+              if (!_context.sent) {
+                _context.next = 30;
+                break;
+              }
+              dockingFound = true;
+            case 30:
+              _context.next = 44;
               break;
-            case 31:
+            case 32:
               success = false;
               if (plannerElement.HasAVL || plannerElement.HasAVR) {
                 success = this.dockToAVLorAVR(plannerElement, [this.plannerElements.get(targetElemIdToDock)]);
@@ -395,28 +501,28 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 success = this.dockToAVUorAVOororAVNorAVSorAVC(plannerElement, [this.plannerElements.get(targetElemIdToDock)]);
               }
               if (success) {
-                _context.next = 42;
+                _context.next = 43;
                 break;
               }
-              _context.next = 37;
+              _context.next = 38;
               return this.tryToDockWithDifferentSVGWithFormula(plannerElement, targetElemIdToDock);
-            case 37:
+            case 38:
               success = _context.sent;
               if (success) {
-                _context.next = 42;
+                _context.next = 43;
                 break;
               }
-              _context.next = 41;
+              _context.next = 42;
               return this.addElementToWorld(plannerElement, undefined, undefined, undefined, 50);
-            case 41:
-              return _context.abrupt("return");
             case 42:
-              if (success) dockingFound = true;
+              return _context.abrupt("return");
             case 43:
+              if (success) dockingFound = true;
+            case 44:
               i++;
               _context.next = 11;
               break;
-            case 46:
+            case 47:
               if (!dockingFound) {
                 allPlannerElements = this.getAllPlannerElements();
                 _success = this.dockToAVLorAVR(plannerElement, allPlannerElements);
@@ -437,13 +543,13 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                   }
                 }
               }
-            case 47:
+            case 48:
               this.updatePlannerPosNr();
               this.updateAllElementsWorldPos();
               this.updatePlannerPosNr();
               this.checkCollision(false, plannerElement.getElementId());
               this.updatePlannerBoundingBox();
-            case 52:
+            case 53:
             case "end":
               return _context.stop();
           }
@@ -458,7 +564,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
     key: "tryToDockWithDifferentSVGWithFormula",
     value: function () {
       var _tryToDockWithDifferentSVGWithFormula = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(plannerElement, targetElemIdToDock) {
-        var success, article, origVariantValues, svgsWithFormula, i, elements, variantValues, vv, key, v, _i2, _vv, _elements, _variantValues, _key, _elements2, _variantValues2, _key2;
+        var success, article, origVariantValues, svgsWithFormula, i, vv, targetFilterCandidates, _i2, v, _i3, elements, variantValues, key;
         return _regeneratorRuntime.wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -468,92 +574,107 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               origVariantValues = article === null || article === void 0 ? void 0 : article.VariantValues;
               svgsWithFormula = plannerElement.getSVGsWithFormula();
               if (!(plannerElement.FilterAVL.length || plannerElement.FilterAVR.length)) {
-                _context2.next = 47;
+                _context2.next = 52;
                 break;
               }
               if (!(svgsWithFormula !== null && svgsWithFormula !== void 0 && svgsWithFormula.length)) {
-                _context2.next = 22;
+                _context2.next = 18;
                 break;
               }
               i = 0;
             case 7:
               if (!(i < svgsWithFormula.length)) {
-                _context2.next = 22;
+                _context2.next = 18;
                 break;
               }
-              elements = new Map();
-              variantValues = new Map();
               vv = DivaUtils.getVariantValuesFromRule(svgsWithFormula[i].JsFormula, {});
-              for (key in vv) {
-                variantValues.set(key, vv[key]);
-              }
-              elements.set(plannerElement.ElementId, variantValues);
-              _context2.next = 15;
-              return this.set.updateCfgValuesByPlanner(elements, true);
-            case 15:
-              success = this.dockToAVLorAVR(plannerElement, [this.plannerElements.get(targetElemIdToDock)]);
+              _context2.next = 11;
+              return this.applyVariantValuesAndTryDock(plannerElement, targetElemIdToDock, vv);
+            case 11:
+              success = _context2.sent;
               if (!success) {
-                _context2.next = 19;
+                _context2.next = 15;
                 break;
               }
               //svg did match
               LOG.debug('svgWithFormula nr: ' + i + ' did dock: ' + svgsWithFormula[i].SVG);
-              return _context2.abrupt("break", 22);
-            case 19:
+              return _context2.abrupt("break", 18);
+            case 15:
               i++;
               _context2.next = 7;
               break;
-            case 22:
+            case 18:
+              if (!(!success && article)) {
+                _context2.next = 31;
+                break;
+              }
+              targetFilterCandidates = this.getVariantValuesMatchingTargetFilters(article, this.plannerElements.get(targetElemIdToDock));
+              _i2 = 0;
+            case 21:
+              if (!(_i2 < targetFilterCandidates.length && _i2 < 20)) {
+                _context2.next = 31;
+                break;
+              }
+              _context2.next = 24;
+              return this.applyVariantValuesAndTryDock(plannerElement, targetElemIdToDock, targetFilterCandidates[_i2]);
+            case 24:
+              success = _context2.sent;
+              if (!success) {
+                _context2.next = 28;
+                break;
+              }
+              LOG.debug('following variantValues matching the target avl/avr filter did dock: ', targetFilterCandidates[_i2]);
+              return _context2.abrupt("break", 31);
+            case 28:
+              _i2++;
+              _context2.next = 21;
+              break;
+            case 31:
               //other logic. look for decisions with featrue 90 or 89 and try change the options that influence 90 - 89
               v = plannerElement.getVaraintValuesInfluencingAVLAVRFilter();
               if (!(v !== null && v !== void 0 && v.length && !success)) {
-                _context2.next = 40;
+                _context2.next = 44;
                 break;
               }
-              _i2 = 0;
-            case 25:
-              if (!(_i2 < v.length && _i2 < 20)) {
-                _context2.next = 40;
+              _i3 = 0;
+            case 34:
+              if (!(_i3 < v.length && _i3 < 20)) {
+                _context2.next = 44;
                 break;
               }
-              _vv = v[_i2];
-              _elements = new Map();
-              _variantValues = new Map();
-              for (_key in _vv) {
-                _variantValues.set(_key, _vv[_key]);
-              }
-              _elements.set(plannerElement.ElementId, _variantValues);
-              _context2.next = 33;
-              return this.set.updateCfgValuesByPlanner(_elements, true);
-            case 33:
-              success = this.dockToAVLorAVR(plannerElement, [this.plannerElements.get(targetElemIdToDock)]);
+              _context2.next = 37;
+              return this.applyVariantValuesAndTryDock(plannerElement, targetElemIdToDock, v[_i3]);
+            case 37:
+              success = _context2.sent;
               if (!success) {
-                _context2.next = 37;
+                _context2.next = 41;
                 break;
               }
               //variantValues did match
-              LOG.debug('following variantValues did dock: ', _variantValues);
-              return _context2.abrupt("break", 40);
-            case 37:
-              _i2++;
-              _context2.next = 25;
+              LOG.debug('following variantValues did dock: ', v[_i3]);
+              return _context2.abrupt("break", 44);
+            case 41:
+              _i3++;
+              _context2.next = 34;
               break;
-            case 40:
+            case 44:
               if (success) {
-                _context2.next = 47;
+                _context2.next = 52;
                 break;
               }
-              _elements2 = new Map();
-              _variantValues2 = new Map();
-              for (_key2 in origVariantValues) {
-                _variantValues2.set(_key2, origVariantValues[_key2]);
+              elements = new Map();
+              variantValues = new Map();
+              for (key in origVariantValues) {
+                variantValues.set(key, origVariantValues[key]);
               }
-              _elements2.set(plannerElement.ElementId, _variantValues2);
-              _context2.next = 47;
-              return this.set.updateCfgValuesByPlanner(_elements2, true);
-            case 47:
+              elements.set(plannerElement.ElementId, variantValues);
+              _context2.next = 51;
+              return this.set.updateCfgValuesByPlanner(elements, true);
+            case 51:
+              if (article) this.commitPendingConnectorFilters(article);
+            case 52:
               return _context2.abrupt("return", success);
-            case 48:
+            case 53:
             case "end":
               return _context2.stop();
           }
@@ -564,6 +685,91 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
       }
       return tryToDockWithDifferentSVGWithFormula;
     }()
+  }, {
+    key: "applyVariantValuesAndTryDock",
+    value: function () {
+      var _applyVariantValuesAndTryDock = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(plannerElement, targetElemIdToDock, variantValuesToApply) {
+        var elements, variantValues, key, article;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              elements = new Map();
+              variantValues = new Map();
+              for (key in variantValuesToApply) {
+                variantValues.set(key, variantValuesToApply[key]);
+              }
+              elements.set(plannerElement.ElementId, variantValues);
+              _context3.next = 6;
+              return this.set.updateCfgValuesByPlanner(elements, true);
+            case 6:
+              article = this.set.getArticleByElementId(plannerElement.ElementId);
+              if (article) this.commitPendingConnectorFilters(article);
+              return _context3.abrupt("return", this.dockToAVLorAVR(plannerElement, [this.plannerElements.get(targetElemIdToDock)]));
+            case 9:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function applyVariantValuesAndTryDock(_x7, _x8, _x9) {
+        return _applyVariantValuesAndTryDock.apply(this, arguments);
+      }
+      return applyVariantValuesAndTryDock;
+    }() //the engines only commit option-derived connector filters when the svg swaps, but while probing dock configurations the filters must follow the configuration even without a swap
+  }, {
+    key: "commitPendingConnectorFilters",
+    value: function commitPendingConnectorFilters(article) {
+      if (article.newPossibleAVRFilters) {
+        article.avr = article.newPossibleAVRFilters;
+        article.newPossibleAVRFilters = undefined;
+      }
+      if (article.newPossibleAVLFilters) {
+        article.avl = article.newPossibleAVLFilters;
+        article.newPossibleAVLFilters = undefined;
+      }
+    }
+  }, {
+    key: "getVariantValuesMatchingTargetFilters",
+    value: function getVariantValuesMatchingTargetFilters(article, targetElement) {
+      if (!targetElement) return [];
+      var optPrefix = !article.CatalogData.isIDMFormat ? 'OPT' : '';
+      var opvPrefix = !article.CatalogData.isIDMFormat ? 'OPV' : '';
+      var candidates = [];
+      var seen = new Set();
+      var collect = function collect(connectorFeature, targetFilters) {
+        var _iterator2 = _createForOfIteratorHelper(targetFilters),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var filter = _step2.value;
+            var _iterator3 = _createForOfIteratorHelper(article.getVariantValuesInfluencingOptions([optPrefix + connectorFeature], opvPrefix + filter)),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var vv = _step3.value;
+                var key = JSON.stringify(vv);
+                if (!seen.has(key)) {
+                  seen.add(key);
+                  candidates.push(vv);
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      };
+      //this article's AVL side (feature 89) docks against the target's AVR side and vice versa
+      collect('89', targetElement.FilterAVR);
+      collect('90', targetElement.FilterAVL);
+      return candidates;
+    }
   }, {
     key: "dockToAVLorAVR",
     value: function dockToAVLorAVR(plannerElement, targetElements) {
@@ -741,31 +947,31 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "updatePlanner",
     value: function () {
-      var _updatePlanner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var _updatePlanner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
         var allPlannerElements, elemtsWhereSomethingChanged, i, elem, doReload, elementsToDelete, elementsLostDockingRelation;
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
             case 0:
               allPlannerElements = this.getAllPlannerElements();
               elemtsWhereSomethingChanged = [];
               i = 0;
             case 3:
               if (!(i < allPlannerElements.length)) {
-                _context3.next = 13;
+                _context4.next = 13;
                 break;
               }
               elem = allPlannerElements[i];
               doReload = elem.updatePlannerData(this.set.getPlannerData(elem.getElementId()));
               if (!doReload) {
-                _context3.next = 10;
+                _context4.next = 10;
                 break;
               }
               elemtsWhereSomethingChanged.push(elem.ElementId);
-              _context3.next = 10;
+              _context4.next = 10;
               return handler2D.loadSVG(elem, this.set);
             case 10:
               i++;
-              _context3.next = 3;
+              _context4.next = 3;
               break;
             case 13:
               elementsToDelete = [];
@@ -778,11 +984,11 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                     elementsToDelete.push(elementsLostDockingRelation[i].ElementId);
                   }
                 }
-                this.updateAllElementsWorldPos();
+                this.updateAllElementsWorldPos(undefined, elemtsWhereSomethingChanged);
                 this.updatePlannerPosNr();
                 this.updatePlannerBoundingBox();
               }
-              return _context3.abrupt("return", {
+              return _context4.abrupt("return", {
                 doDeleteBackGrid: false,
                 elemIdsToDelete: elementsToDelete,
                 elementIdsToUpdateSelection: elemtsWhereSomethingChanged,
@@ -790,9 +996,9 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               });
             case 16:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
-        }, _callee3, this);
+        }, _callee4, this);
       }));
       function updatePlanner() {
         return _updatePlanner.apply(this, arguments);
@@ -807,15 +1013,14 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "extendPlanner",
     value: (function () {
-      var _extendPlanner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(setPlanData, globalBoundingBox) {
-        var planDataString, planData, jsonElements, elementsSortedbyPosNr, accElements, oldElementidMapping, i, _jsonElement$Accessoi, jsonElement, catalogArticle, plannerElement, data, curElement, DPsInfo, j, dpInfo, sourceDP, targetElement, targetDP;
-        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
+      var _extendPlanner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(setPlanData, globalBoundingBox) {
+        var planData, jsonElements, elementsSortedbyPosNr, accElements, oldElementidMapping, i, _saveElementArticleCo, _jsonElement$Accessoi, jsonElement, catalogArticle, plannerElement, data, elementsForDockingExtend, row, curElement, DPsInfo, j, dpInfo, sourceDP, targetElement, targetDP;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
             case 0:
-              planDataString = DivaUtils.decodeBase64(setPlanData);
-              planData = JSON.parse(planDataString);
-              if (!(planData.v != null && planData.v == 2)) {
-                _context4.next = 40;
+              planData = parseSetPlanData(setPlanData);
+              if (!isSavePlannerV2(planData)) {
+                _context5.next = 39;
                 break;
               }
               jsonElements = planData.set.elements;
@@ -823,70 +1028,70 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               accElements = [];
               oldElementidMapping = new Map(); //First reset planner element values in jsonElement so that every set is planned to be set to origin
               i = 0;
-            case 8:
+            case 7:
               if (!(i < jsonElements.length)) {
-                _context4.next = 36;
+                _context5.next = 35;
                 break;
               }
-              _context4.prev = 9;
+              _context5.prev = 8;
               jsonElement = jsonElements[i];
-              catalogArticle = this.set.CatalogData.getCatalogArticleByArticleCodex(jsonElement.articleCodex || jsonElement.Codex);
+              catalogArticle = this.set.CatalogData.getCatalogArticleByArticleCodex((_saveElementArticleCo = saveElementArticleCodex(jsonElement)) !== null && _saveElementArticleCo !== void 0 ? _saveElementArticleCo : '');
               if (!(!catalogArticle && (_jsonElement$Accessoi = jsonElement.AccessoireInitParams) !== null && _jsonElement$Accessoi !== void 0 && _jsonElement$Accessoi.RelatedToBasketID && !this.set.getSetState.onlyRunLogic)) {
-                _context4.next = 15;
+                _context5.next = 14;
                 break;
               }
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
                 code: 'WC_0012'
               }));
-              return _context4.abrupt("continue", 33);
-            case 15:
+              return _context5.abrupt("continue", 32);
+            case 14:
               plannerElement = new PlannerElementData(this.set.getSetId(), jsonElement.basketID, this.nextElementId, DivaStandardPlanner.plannerType);
-              oldElementidMapping.set(parseInt(jsonElement.elementID), plannerElement);
+              oldElementidMapping.set(jsonElement.elementID, plannerElement);
               this.nextElementId = plannerElement.getElementId() + 1;
               this.plannerElements.set(plannerElement.ElementId, plannerElement);
               this.set.setElementId(jsonElement.basketID, plannerElement.ElementId);
               data = this.set.getPlannerData(plannerElement.ElementId);
               plannerElement.updatePlannerData(data);
               if (this.doDisablePlanner2D) {
-                _context4.next = 25;
+                _context5.next = 24;
                 break;
               }
-              _context4.next = 25;
+              _context5.next = 24;
               return handler2D.loadSVG(plannerElement, this.set);
-            case 25:
+            case 24:
               plannerElement.WorldPosCenter = new Vector3(globalBoundingBox.WorldPos.x + globalBoundingBox.Size.x + jsonElement.x + 100, globalBoundingBox.WorldPos.y + jsonElement.y, globalBoundingBox.WorldPos.z + jsonElement.z);
               plannerElement.RotDeg = jsonElement.rot;
               if (plannerElement.IsDockedAccessoire) {
                 accElements.push(jsonElement);
                 plannerElement.PosNr = jsonElement.posNr;
-                plannerElement.AccessoirePosNr = jsonElement.accNr;
+                if (jsonElement.accNr != null) plannerElement.AccessoirePosNr = jsonElement.accNr;
               } else {
                 elementsSortedbyPosNr[jsonElement.posNr - 1] = jsonElement;
                 plannerElement.PosNr = jsonElement.posNr;
               }
-              _context4.next = 33;
+              _context5.next = 32;
               break;
-            case 30:
-              _context4.prev = 30;
-              _context4.t0 = _context4["catch"](9);
+            case 29:
+              _context5.prev = 29;
+              _context5.t0 = _context5["catch"](8);
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
-                cause: _context4.t0,
+                cause: _context5.t0,
                 code: 'WC_0012'
               }));
-            case 33:
+            case 32:
               i++;
-              _context4.next = 8;
+              _context5.next = 7;
               break;
-            case 36:
-              elementsSortedbyPosNr = elementsSortedbyPosNr.concat(accElements);
-              for (i = 0; i < elementsSortedbyPosNr.length; i++) {
-                curElement = oldElementidMapping.get(elementsSortedbyPosNr[i].elementID);
-                if (elementsSortedbyPosNr.length > 1) {
-                  //This is the case when a complex product is loaded
-                  //First element is already positioned correctly not docket
+            case 35:
+              elementsForDockingExtend = [].concat(_toConsumableArray(elementsSortedbyPosNr.filter(function (e) {
+                return e != null;
+              })), accElements);
+              for (i = 0; i < elementsForDockingExtend.length; i++) {
+                row = elementsForDockingExtend[i];
+                curElement = oldElementidMapping.get(row.elementID);
+                if (elementsForDockingExtend.length > 1) {
                   if (i > 0) {
-                    //The other elements are docked to the First element.
-                    DPsInfo = elementsSortedbyPosNr[i].DP;
+                    DPsInfo = row.DP;
                     for (j = 0; j < DPsInfo.length; j++) {
                       dpInfo = DPsInfo[j];
                       sourceDP = curElement === null || curElement === void 0 ? void 0 : curElement.getDockingPointById(dpInfo.id);
@@ -899,19 +1104,19 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                   }
                 }
               }
-              _context4.next = 41;
+              _context5.next = 40;
               break;
-            case 40:
+            case 39:
               LOG.error(new DivaError('The function extend Planner works only with products that are saved in the configurator 2.0', {
                 code: 'WC_0012'
               }));
-            case 41:
+            case 40:
             case "end":
-              return _context4.stop();
+              return _context5.stop();
           }
-        }, _callee4, this, [[9, 30]]);
+        }, _callee5, this, [[8, 29]]);
       }));
-      function extendPlanner(_x7, _x8) {
+      function extendPlanner(_x10, _x11) {
         return _extendPlanner.apply(this, arguments);
       }
       return extendPlanner;
@@ -919,47 +1124,45 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "initPlanner",
     value: function () {
-      var _initPlanner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(setPlanData) {
-        var planDataString, planData, jsonElements, elementsSortedbyPosNr, accElements, i, _jsonElement$Accessoi2, jsonElement, catalogArticle, elementID, plannerElement, data, onlyOneBaseElement, _jsonElement, hasSavedPos, element, DPsInfo, j, dpInfo, sourceElement, sourceDP, targetElement, targetDP, _jsonElements, _elementsSortedbyPosNr, _accElements, _jsonElement2$Accesso, _jsonElement2, _catalogArticle, basketID, elementId, _plannerElement, _data, centerWorldPos, parentPosNr, accPosNr, _DPsInfo, _dpInfo, _this$plannerElements, targetElementId, dpType, curElement, _targetElement;
-        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+      var _initPlanner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(setPlanData) {
+        var planData, _planData$set, jsonElements, elementsSortedbyPosNr, accElements, i, _saveElementArticleCo2, _jsonElement$Accessoi2, jsonElement, catalogArticle, elementID, plannerElement, data, onlyOneBaseElement, elementsForDocking, row, _jsonElement, hasSavedPos, element, DPsInfo, j, dpInfo, sourceElement, sourceDP, targetElement, targetDP, alreadyDocked, docked, _elementsForDocking$i, elementId, _planData$Sets, _legacySet$Elements, legacySet, _jsonElements, _elementsSortedbyPosNr, _accElements, _saveElementArticleCo3, _jsonElement2$Accesso, _jsonElement2, _catalogArticle, basketID, _elementId, _plannerElement, _data, centerWorldPos, parentPosNr, accPosNr, elementsForDockingV1, _row, _DPsInfo, _dpInfo, _this$plannerElements, targetElementId, dpType, curElement, _targetElement, anchorElement;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
-              planDataString = DivaUtils.decodeBase64(setPlanData);
-              planData = JSON.parse(planDataString);
-              if (!(planData.v != null && planData.v == 2)) {
-                _context5.next = 62;
+              planData = parseSetPlanData(setPlanData);
+              if (!isSavePlannerV2(planData)) {
+                _context6.next = 63;
                 break;
               }
               LOG.debug('Initialize set Plan Data - V2\n' + planData, 'DivaStandardPlanner initPlanner');
-              if (!(!planData.set || !planData.set.elements || planData.set.elements.length == 0)) {
-                _context5.next = 6;
+              if ((_planData$set = planData.set) !== null && _planData$set !== void 0 && (_planData$set = _planData$set.elements) !== null && _planData$set !== void 0 && _planData$set.length) {
+                _context6.next = 5;
                 break;
               }
-              return _context5.abrupt("return");
-            case 6:
-              //Init new saved Plannings
+              return _context6.abrupt("return");
+            case 5:
               jsonElements = planData.set.elements;
               elementsSortedbyPosNr = [];
               accElements = [];
               i = 0;
-            case 10:
+            case 9:
               if (!(i < jsonElements.length)) {
-                _context5.next = 38;
+                _context6.next = 37;
                 break;
               }
-              _context5.prev = 11;
+              _context6.prev = 10;
               jsonElement = jsonElements[i];
-              catalogArticle = this.set.CatalogData.getCatalogArticleByArticleCodex(jsonElement.articleCodex || jsonElement.Codex);
+              catalogArticle = this.set.CatalogData.getCatalogArticleByArticleCodex((_saveElementArticleCo2 = saveElementArticleCodex(jsonElement)) !== null && _saveElementArticleCo2 !== void 0 ? _saveElementArticleCo2 : '');
               if (!(!catalogArticle && (_jsonElement$Accessoi2 = jsonElement.AccessoireInitParams) !== null && _jsonElement$Accessoi2 !== void 0 && _jsonElement$Accessoi2.RelatedToBasketID && !this.set.getSetState.onlyRunLogic)) {
-                _context5.next = 17;
+                _context6.next = 16;
                 break;
               }
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
                 code: 'WC_0012'
               }));
-              return _context5.abrupt("continue", 35);
-            case 17:
-              elementID = parseInt(jsonElement.elementID);
+              return _context6.abrupt("continue", 34);
+            case 16:
+              elementID = jsonElement.elementID;
               plannerElement = new PlannerElementData(this.set.getSetId(), jsonElement.basketID, elementID, DivaStandardPlanner.plannerType);
               this.nextElementId = elementID + 1;
               this.plannerElements.set(plannerElement.ElementId, plannerElement);
@@ -967,12 +1170,12 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               data = this.set.getPlannerData(plannerElement.ElementId);
               plannerElement.updatePlannerData(data);
               if (this.doDisablePlanner2D) {
-                _context5.next = 27;
+                _context6.next = 26;
                 break;
               }
-              _context5.next = 27;
+              _context6.next = 26;
               return handler2D.loadSVG(plannerElement, this.set);
-            case 27:
+            case 26:
               //Im neuen speichern ist die Position hinten link - nicht mehr im Centrum wie im alten Planer
               //plannerElement.WorldPosCenter = new Vector3(jsonElement.x, jsonElement.y, jsonElement.z);
               plannerElement.WorldPosCenter = new Vector3(this.plannerBoundingBox.WorldPos.x + jsonElement.x, this.plannerBoundingBox.WorldPos.y + jsonElement.y, this.plannerBoundingBox.WorldPos.z + jsonElement.z);
@@ -980,141 +1183,151 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               if (plannerElement.IsDockedAccessoire) {
                 accElements.push(jsonElement);
                 plannerElement.PosNr = jsonElement.posNr;
-                plannerElement.AccessoirePosNr = jsonElement.accNr;
+                if (jsonElement.accNr != null) plannerElement.AccessoirePosNr = jsonElement.accNr;
               } else {
                 elementsSortedbyPosNr[jsonElement.posNr - 1] = jsonElement;
                 plannerElement.PosNr = jsonElement.posNr;
               }
-              _context5.next = 35;
+              _context6.next = 34;
               break;
-            case 32:
-              _context5.prev = 32;
-              _context5.t0 = _context5["catch"](11);
+            case 31:
+              _context6.prev = 31;
+              _context6.t0 = _context6["catch"](10);
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
-                cause: _context5.t0,
+                cause: _context6.t0,
                 code: 'WC_0012'
               }));
-            case 35:
+            case 34:
               i++;
-              _context5.next = 10;
+              _context6.next = 9;
               break;
-            case 38:
-              onlyOneBaseElement = elementsSortedbyPosNr.length == 1; //Saves if only one base element is in the planning. All the others are only accessoires
-              elementsSortedbyPosNr = elementsSortedbyPosNr.concat(accElements);
+            case 37:
+              onlyOneBaseElement = elementsSortedbyPosNr.filter(Boolean).length == 1; //Saves if only one base element is in the planning. All the others are only accessoires
+              elementsForDocking = [].concat(_toConsumableArray(elementsSortedbyPosNr.filter(function (e) {
+                return e != null;
+              })), accElements);
               i = 0;
-            case 41:
-              if (!(i < elementsSortedbyPosNr.length)) {
-                _context5.next = 60;
+            case 40:
+              if (!(i < elementsForDocking.length)) {
+                _context6.next = 61;
                 break;
               }
-              _context5.prev = 42;
+              _context6.prev = 41;
+              row = elementsForDocking[i];
               if (!(i == 0 && onlyOneBaseElement && this.plannerHasStaticBackground)) {
-                _context5.next = 48;
+                _context6.next = 48;
                 break;
               }
               //if the planner has a static background room and there is only one base element (ignore docked ACCs) then it should be forced positioned in the center of the room.
               //Only do this for fresh plannings - if the saved planData already contains a position, keep it.
+              //if the planner has a static background room and there is only one base element (ignore docked ACCs) then it should be forced positioned in the center of the room
               _jsonElement = elementsSortedbyPosNr[i];
-              hasSavedPos = _jsonElement.x != null || _jsonElement.y != null || _jsonElement.z != null;
+              hasSavedPos = (_jsonElement === null || _jsonElement === void 0 ? void 0 : _jsonElement.x) != null || (_jsonElement === null || _jsonElement === void 0 ? void 0 : _jsonElement.y) != null || (_jsonElement === null || _jsonElement === void 0 ? void 0 : _jsonElement.z) != null;
               if (!hasSavedPos) {
-                element = this.plannerElements.get(_jsonElement.elementID);
+                element = this.plannerElements.get(row.elementID);
                 if (element) element.WorldPosCenter = new Vector3(0, element.Height / 2, element.Depth / 2);
               }
-              return _context5.abrupt("continue", 57);
+              return _context6.abrupt("continue", 58);
             case 48:
-              if (!(elementsSortedbyPosNr[i].DP == null || elementsSortedbyPosNr[i].DP.length == 0)) {
-                _context5.next = 50;
+              if (!(row.DP == null || row.DP.length == 0)) {
+                _context6.next = 50;
                 break;
               }
-              return _context5.abrupt("continue", 57);
+              return _context6.abrupt("continue", 58);
             case 50:
-              DPsInfo = elementsSortedbyPosNr[i].DP;
+              DPsInfo = row.DP;
               for (j = 0; j < DPsInfo.length; j++) {
                 dpInfo = DPsInfo[j];
-                if (dpInfo.id && dpInfo.id != '' && dpInfo.onID && dpInfo.onID != '' && dpInfo.onDPID && dpInfo.onDPID != '') {
-                  sourceElement = this.plannerElements.get(elementsSortedbyPosNr[i].elementID);
+                if (dpInfo.id && dpInfo.onID != null && dpInfo.onDPID) {
+                  sourceElement = this.plannerElements.get(row.elementID);
                   sourceDP = sourceElement === null || sourceElement === void 0 ? void 0 : sourceElement.getDockingPointById(dpInfo.id);
                   targetElement = this.plannerElements.get(dpInfo.onID);
                   targetDP = targetElement === null || targetElement === void 0 ? void 0 : targetElement.getDockingPointById(dpInfo.onDPID);
                   if (sourceDP && targetDP) {
-                    dockingPointHandlerInst.tryDockElementDPToDP(sourceElement, targetElement, sourceDP, targetDP);
+                    // Saved plans store each relation on both sides - skip the mirror entry of an already established pair.
+                    alreadyDocked = sourceDP.IsDocking && sourceDP.OnDP == targetDP;
+                    docked = alreadyDocked || dockingPointHandlerInst.tryDockElementDPToDP(sourceElement, targetElement, sourceDP, targetDP);
+                    if (!docked && !this.doDisablePlanner2D) LOG.error(new DivaError('Saved docking relation rejected on init: ' + dpInfo.id + ' (elem ' + (sourceElement === null || sourceElement === void 0 ? void 0 : sourceElement.ElementId) + ') -> ' + dpInfo.onDPID + ' (elem ' + (targetElement === null || targetElement === void 0 ? void 0 : targetElement.ElementId) + ')', {
+                      code: 'WC_0012'
+                    }));
                   } else {
                     if (!this.doDisablePlanner2D) LOG.error(new DivaError('Error initializing docking point between source element with id: ' + (sourceElement === null || sourceElement === void 0 ? void 0 : sourceElement.ElementId) + ' and target Element with id: ' + (targetElement === null || targetElement === void 0 ? void 0 : targetElement.ElementId) + '. SourceDPID: ' + dpInfo.id + '; targetDPID: ' + dpInfo.onDPID));
                   }
                 }
               }
-              _context5.next = 57;
+              _context6.next = 58;
               break;
             case 54:
-              _context5.prev = 54;
-              _context5.t1 = _context5["catch"](42);
-              LOG.error(new DivaError('Error initializing dockingPoints of element with elementID ' + elementsSortedbyPosNr[i].elementID, {
-                cause: _context5.t1,
+              _context6.prev = 54;
+              _context6.t1 = _context6["catch"](41);
+              elementId = (_elementsForDocking$i = elementsForDocking[i]) === null || _elementsForDocking$i === void 0 ? void 0 : _elementsForDocking$i.elementID;
+              LOG.error(new DivaError('Error initializing dockingPoints of element with elementID ' + elementId, {
+                cause: _context6.t1,
                 code: 'WC_0012'
               }));
-            case 57:
+            case 58:
               i++;
-              _context5.next = 41;
+              _context6.next = 40;
               break;
-            case 60:
-              _context5.next = 113;
+            case 61:
+              _context6.next = 116;
               break;
-            case 62:
+            case 63:
               LOG.debug('Initialize set Plan Data - old V1\n' + planData, 'DivaStandardPlanner initPlanner');
-              if (!(!planData.Sets || planData.Sets.length == 0 || !planData.Sets[0].Elements || planData.Sets[0].Elements.length == 0)) {
-                _context5.next = 65;
+              legacySet = (_planData$Sets = planData.Sets) === null || _planData$Sets === void 0 ? void 0 : _planData$Sets[0];
+              if (legacySet !== null && legacySet !== void 0 && (_legacySet$Elements = legacySet.Elements) !== null && _legacySet$Elements !== void 0 && _legacySet$Elements.length) {
+                _context6.next = 67;
                 break;
               }
-              return _context5.abrupt("return");
-            case 65:
-              //Init old Plannings - saved with the old planner
-              _jsonElements = planData.Sets[0].Elements;
+              return _context6.abrupt("return");
+            case 67:
+              _jsonElements = legacySet.Elements;
               _elementsSortedbyPosNr = [];
               _accElements = []; //Zuerst initialisiere alle Elemente
               //Dann positioniere sie richtig
               i = 0;
-            case 69:
+            case 71:
               if (!(i < _jsonElements.length)) {
-                _context5.next = 103;
+                _context6.next = 105;
                 break;
               }
-              _context5.prev = 70;
+              _context6.prev = 72;
               _jsonElement2 = _jsonElements[i];
-              _catalogArticle = this.set.CatalogData.getCatalogArticleByArticleCodex(_jsonElement2.articleCodex || _jsonElement2.Codex);
+              _catalogArticle = this.set.CatalogData.getCatalogArticleByArticleCodex((_saveElementArticleCo3 = saveElementArticleCodex(_jsonElement2)) !== null && _saveElementArticleCo3 !== void 0 ? _saveElementArticleCo3 : '');
               if (!(!_catalogArticle && (_jsonElement2$Accesso = _jsonElement2.AccessoireInitParams) !== null && _jsonElement2$Accesso !== void 0 && _jsonElement2$Accesso.RelatedToBasketID && !this.set.getSetState.onlyRunLogic)) {
-                _context5.next = 76;
+                _context6.next = 78;
                 break;
               }
-              LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
+              LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V1', {
                 code: 'WC_0012'
               }));
-              return _context5.abrupt("continue", 100);
-            case 76:
+              return _context6.abrupt("continue", 102);
+            case 78:
               basketID = _jsonElement2.BasketID;
               if (this.set.getElementId(basketID) == -1) this.set.setElementId(basketID, Number(_jsonElement2.ID));
-              elementId = this.set.getElementId(basketID);
-              _jsonElement2.elementId = elementId;
-              if (!(elementId == -1)) {
-                _context5.next = 83;
+              _elementId = this.set.getElementId(basketID);
+              _jsonElement2.elementId = _elementId;
+              if (!(_elementId == -1)) {
+                _context6.next = 85;
                 break;
               }
               LOG.error(new DivaError('Error when initializing planner. The elementID Was not saved in the article. ', {
                 code: 'WC_0012'
               }));
-              return _context5.abrupt("continue", 100);
-            case 83:
-              _plannerElement = new PlannerElementData(this.set.getSetId(), basketID, elementId, DivaStandardPlanner.plannerType);
-              this.nextElementId = elementId + 1;
+              return _context6.abrupt("continue", 102);
+            case 85:
+              _plannerElement = new PlannerElementData(this.set.getSetId(), basketID, _elementId, DivaStandardPlanner.plannerType);
+              this.nextElementId = _elementId + 1;
               this.plannerElements.set(_plannerElement.ElementId, _plannerElement);
               _data = this.set.getPlannerData(_plannerElement.ElementId);
               _plannerElement.updatePlannerData(_data);
               if (this.doDisablePlanner2D) {
-                _context5.next = 91;
+                _context6.next = 93;
                 break;
               }
-              _context5.next = 91;
+              _context6.next = 93;
               return handler2D.loadSVG(_plannerElement, this.set);
-            case 91:
+            case 93:
               //Achtung die Pos Infos im alten Planer waren Zentrumskoordinaten!!! Nicht hinten oben.
               centerWorldPos = new Vector3(_jsonElement2.PosX, _jsonElement2.PosZ, _jsonElement2.PosY);
               _plannerElement.WorldPosCenter = new Vector3(this.plannerBoundingBox.WorldPos.x + centerWorldPos.x, this.plannerBoundingBox.WorldPos.y + centerWorldPos.y, this.plannerBoundingBox.WorldPos.z + centerWorldPos.z);
@@ -1124,72 +1337,77 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 if (_jsonElement2.PosNum.toString().indexOf('.') > 0) {
                   parentPosNr = _jsonElement2.PosNum.toString().split('.')[0];
                   accPosNr = _jsonElement2.PosNum.toString().split('.')[1];
-                  _plannerElement.PosNr = parentPosNr;
-                  _plannerElement.AccessoirePosNr = accPosNr;
+                  _plannerElement.PosNr = Number(parentPosNr);
+                  _plannerElement.AccessoirePosNr = Number(accPosNr);
                 }
               } else {
                 _elementsSortedbyPosNr[_jsonElement2.PosNum - 1] = _jsonElement2;
                 _plannerElement.PosNr = _jsonElement2.PosNum;
               }
-              _context5.next = 100;
+              _context6.next = 102;
               break;
-            case 97:
-              _context5.prev = 97;
-              _context5.t2 = _context5["catch"](70);
+            case 99:
+              _context6.prev = 99;
+              _context6.t2 = _context6["catch"](72);
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner - Plan Data old Planner', {
-                cause: _context5.t2,
+                cause: _context6.t2,
                 code: 'WC_0012'
               }));
-            case 100:
+            case 102:
               i++;
-              _context5.next = 69;
+              _context6.next = 71;
               break;
-            case 103:
-              _elementsSortedbyPosNr = _elementsSortedbyPosNr.concat(_accElements);
-              //Dann werden die DockingPoints durchgegangen und die jeweils richtigen müssen gesucht werden.
-              i = 0;
             case 105:
-              if (!(i < _elementsSortedbyPosNr.length)) {
-                _context5.next = 113;
+              elementsForDockingV1 = [].concat(_toConsumableArray(_elementsSortedbyPosNr.filter(function (e) {
+                return e != null;
+              })), _accElements);
+              i = 0;
+            case 107:
+              if (!(i < elementsForDockingV1.length)) {
+                _context6.next = 116;
                 break;
               }
-              if (!(_elementsSortedbyPosNr[i].DP == null || _elementsSortedbyPosNr[i].DP.length == 0)) {
-                _context5.next = 108;
+              _row = elementsForDockingV1[i];
+              if (!(_row.DP == null || _row.DP.length == 0)) {
+                _context6.next = 111;
                 break;
               }
-              return _context5.abrupt("continue", 110);
-            case 108:
-              _DPsInfo = _elementsSortedbyPosNr[i].DP;
+              return _context6.abrupt("continue", 113);
+            case 111:
+              _DPsInfo = _row.DP;
               for (j = 0; j < _DPsInfo.length; j++) {
                 _dpInfo = _DPsInfo[j];
                 if (_dpInfo.DP && _dpInfo.DP != '' && _dpInfo.onID && _dpInfo.onID != '') {
-                  targetElementId = parseInt(_dpInfo.onID);
+                  targetElementId = parseInt(String(_dpInfo.onID));
                   dpType = _dpInfo.DP;
-                  curElement = this.plannerElements.get(_elementsSortedbyPosNr[i].elementId);
+                  curElement = _row.elementId != null ? this.plannerElements.get(_row.elementId) : undefined;
                   _targetElement = (_this$plannerElements = this.plannerElements.get(targetElementId)) !== null && _this$plannerElements !== void 0 ? _this$plannerElements : this.getPlannerElementByIndex(targetElementId - 1);
                   if (curElement && _targetElement) {
                     dockingPointHandlerInst.initDockingPointRelationByArea(curElement, _targetElement, dpType);
                   } else {
-                    LOG.error(new DivaError('Error initializing dockingPoints of element with elementID ' + _elementsSortedbyPosNr[i].elementId, {
+                    LOG.error(new DivaError('Error initializing dockingPoints of element with elementID ' + _row.elementId, {
                       code: 'WC_0012'
                     }));
                   }
                 }
               }
-            case 110:
+            case 113:
               i++;
-              _context5.next = 105;
+              _context6.next = 107;
               break;
-            case 113:
-              this.updateAllElementsWorldPos();
+            case 116:
+              this.plannerElements.forEach(function (el) {
+                if (!el.IsDockedAccessoire && (anchorElement == undefined || el.PosNr < anchorElement.PosNr)) anchorElement = el;
+              });
+              this.updateAllElementsWorldPos(undefined, anchorElement ? [anchorElement.ElementId] : undefined);
               this.updatePlannerPosNr();
-            case 115:
+            case 119:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
-        }, _callee5, this, [[11, 32], [42, 54], [70, 97]]);
+        }, _callee6, this, [[10, 31], [41, 54], [72, 99]]);
       }));
-      function initPlanner(_x9) {
+      function initPlanner(_x12) {
         return _initPlanner.apply(this, arguments);
       }
       return initPlanner;
@@ -1208,11 +1426,11 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "addPlannerElement",
     value: function () {
-      var _addPlannerElement = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(basketID, params) {
+      var _addPlannerElement = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(basketID, params) {
         var _params$dockingPointI, _t$, _t$2, _t$3;
         var plannerElement, data, t;
-        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
               // _elementId: number, _setId: string, _basketId: string, elementInitProp: any, catalogElement: CatalogPlannerArticleData
               plannerElement = new PlannerElementData(this.set.getSetId(), basketID, this.nextElementId, DivaStandardPlanner.plannerType /*, this.set.getSetId(), basketID, elementInitProp, catalogElement*/);
@@ -1223,10 +1441,10 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               plannerElement.updatePlannerData(data);
               //Do load the svg
               if (this.doDisablePlanner2D) {
-                _context6.next = 9;
+                _context7.next = 9;
                 break;
               }
-              _context6.next = 9;
+              _context7.next = 9;
               return handler2D.loadSVG(plannerElement, this.set);
             case 9:
               t = (_params$dockingPointI = params.dockingPointInfos) !== null && _params$dockingPointI !== void 0 ? _params$dockingPointI : [{
@@ -1234,49 +1452,49 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 targetElemIdToDock: params.targetElemIdToDock
               }];
               if (!(t !== null && t !== void 0 && (_t$ = t[0]) !== null && _t$ !== void 0 && _t$.targetElemIdToDock && t !== null && t !== void 0 && (_t$2 = t[0]) !== null && _t$2 !== void 0 && _t$2.targetDockingPointId)) {
-                _context6.next = 15;
+                _context7.next = 15;
                 break;
               }
-              _context6.next = 13;
+              _context7.next = 13;
               return this.addElementToWorld(plannerElement, t);
             case 13:
-              _context6.next = 27;
+              _context7.next = 27;
               break;
             case 15:
               if (!(t !== null && t !== void 0 && (_t$3 = t[0]) !== null && _t$3 !== void 0 && _t$3.targetElemIdToDock)) {
-                _context6.next = 20;
+                _context7.next = 20;
                 break;
               }
-              _context6.next = 18;
+              _context7.next = 18;
               return this.addElementToWorld(plannerElement, t);
             case 18:
-              _context6.next = 27;
+              _context7.next = 27;
               break;
             case 20:
               if (!params.oldPlannerTransform) {
-                _context6.next = 25;
+                _context7.next = 25;
                 break;
               }
-              _context6.next = 23;
+              _context7.next = 23;
               return this.addElementToWorld(plannerElement, undefined, undefined, undefined, undefined, {
                 forceSetToTrans: true,
                 transform: params.oldPlannerTransform
               });
             case 23:
-              _context6.next = 27;
+              _context7.next = 27;
               break;
             case 25:
-              _context6.next = 27;
+              _context7.next = 27;
               return this.addElementToWorld(plannerElement);
             case 27:
               this.updatePlannerBoundingBox();
             case 28:
             case "end":
-              return _context6.stop();
+              return _context7.stop();
           }
-        }, _callee6, this);
+        }, _callee7, this);
       }));
-      function addPlannerElement(_x10, _x11) {
+      function addPlannerElement(_x13, _x14) {
         return _addPlannerElement.apply(this, arguments);
       }
       return addPlannerElement;
@@ -1295,34 +1513,68 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "copyPlannerElement",
     value: (function () {
-      var _copyPlannerElement = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(articleCopyRelation, copyInfo) {
-        var articlesToLoad, i;
-        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
+      var _copyPlannerElement = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(articleCopyRelation, copyInfo) {
+        var i, _copyInfo$copyIndex, rel, dirX, sourceElement, targetDP;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
             case 0:
-              articlesToLoad = [];
-              articleCopyRelation.forEach(function (rel) {
-                if (copyInfo == undefined) articlesToLoad.push(rel.value);
-              });
               i = 0;
-            case 3:
-              if (!(i < articlesToLoad.length)) {
-                _context7.next = 9;
+            case 1:
+              if (!(i < articleCopyRelation.length)) {
+                _context8.next = 24;
                 break;
               }
-              _context7.next = 6;
-              return this.addPlannerElement(articlesToLoad[i], {});
+              rel = articleCopyRelation[i];
+              if (!(copyInfo == undefined)) {
+                _context8.next = 7;
+                break;
+              }
+              _context8.next = 6;
+              return this.addPlannerElement(rel.value, {});
             case 6:
+              return _context8.abrupt("continue", 21);
+            case 7:
+              //Directional copy (copyIndex.x = -1 left / 1 right): dock the copy at the source element's free AVL/AVR
+              dirX = (_copyInfo$copyIndex = copyInfo.copyIndex) === null || _copyInfo$copyIndex === void 0 ? void 0 : _copyInfo$copyIndex.x;
+              if (!(dirX != -1 && dirX != 1)) {
+                _context8.next = 12;
+                break;
+              }
+              _context8.next = 11;
+              return this.addPlannerElement(rel.value, {});
+            case 11:
+              return _context8.abrupt("continue", 21);
+            case 12:
+              sourceElement = this.plannerElements.get(rel.key);
+              targetDP = sourceElement === null || sourceElement === void 0 ? void 0 : sourceElement.getFreeDockingPointsByType(dirX == -1 ? 'AVL' : 'AVR').find(function (dp) {
+                return !dp.IsDisabled;
+              });
+              if (!(sourceElement && targetDP)) {
+                _context8.next = 19;
+                break;
+              }
+              _context8.next = 17;
+              return this.addPlannerElement(rel.value, {
+                targetElemIdToDock: sourceElement.ElementId,
+                targetDockingPointId: targetDP.DpId
+              });
+            case 17:
+              _context8.next = 21;
+              break;
+            case 19:
+              _context8.next = 21;
+              return this.addPlannerElement(rel.value, {});
+            case 21:
               i++;
-              _context7.next = 3;
+              _context8.next = 1;
               break;
-            case 9:
+            case 24:
             case "end":
-              return _context7.stop();
+              return _context8.stop();
           }
-        }, _callee7, this);
+        }, _callee8, this);
       }));
-      function copyPlannerElement(_x12, _x13) {
+      function copyPlannerElement(_x15, _x16) {
         return _copyPlannerElement.apply(this, arguments);
       }
       return copyPlannerElement;
@@ -1341,7 +1593,8 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "getPlannerElementsInfluencedByCopy",
     value: function getPlannerElementsInfluencedByCopy(elementId, copyInfo) {
-      if (!copyInfo || copyInfo.copyType != 'BoxPlanner_backside') throw new Error('copyType needs to be BoxPlanner_backside here');
+      //STD = directional AVL/AVR copy of a single element; only the element itself is influenced
+      if (!copyInfo || copyInfo.copyType != 'BoxPlanner_backside' && copyInfo.copyType != 'STD') throw new Error('copyType needs to be BoxPlanner_backside or STD here');
       if (this.plannerElements.has(elementId)) return [elementId];
       return [];
     }
@@ -1354,19 +1607,19 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "deletePlannerElement",
     value: (function () {
-      var _deletePlannerElement = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(elementId, autoCorrectAVL_AVR) {
+      var _deletePlannerElement = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9(elementId, autoCorrectAVL_AVR) {
         var plannerElement, parent, prevPosNum, nextPosNum, newSelElemIdPrev, newSelElemIdNext, endForEach, removeDockingRelation, avlVec, avrVec, elementLeft, elementRight, avrElementLeft, avlElementRight, transform;
-        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
             case 0:
-              _context8.next = 2;
+              _context9.next = 2;
               return DivaUtils.Sleep(1);
             case 2:
               if (this.plannerElements.has(elementId)) {
-                _context8.next = 4;
+                _context9.next = 4;
                 break;
               }
-              return _context8.abrupt("return", {});
+              return _context9.abrupt("return", {});
             case 4:
               plannerElement = this.plannerElements.get(elementId);
               parent = this.getParentElement(plannerElement);
@@ -1423,17 +1676,17 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               this.updatePlannerPosNr();
               this.checkCollision(false, plannerElement.getElementId());
               this.updatePlannerBoundingBox();
-              return _context8.abrupt("return", {
+              return _context9.abrupt("return", {
                 newElementToSelect: newSelElemIdPrev >= 0 ? newSelElemIdPrev : newSelElemIdNext >= 0 ? newSelElemIdNext : undefined,
                 transform: transform
               });
             case 24:
             case "end":
-              return _context8.stop();
+              return _context9.stop();
           }
-        }, _callee8, this);
+        }, _callee9, this);
       }));
-      function deletePlannerElement(_x14, _x15) {
+      function deletePlannerElement(_x17, _x18) {
         return _deletePlannerElement.apply(this, arguments);
       }
       return deletePlannerElement;
@@ -1525,8 +1778,8 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
         element.SetPosNr = startSetPosNr + element.PosNr - 1;
         this.set.setPosNr(element.ElementId, element.getPosNr());
       }
-      for (var _i3 = 0; _i3 < elements.length; _i3++) {
-        if (!elements[_i3].IsAccessoire) this.set.giveAccNewPosNrByBasketId(elements[_i3].getBasketId());
+      for (var _i4 = 0; _i4 < elements.length; _i4++) {
+        if (!elements[_i4].IsAccessoire) this.set.giveAccNewPosNrByBasketId(elements[_i4].getBasketId());
       }
       return elements.length;
     }
@@ -1543,12 +1796,12 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
      */
   }, {
     key: "updatePlannerTrans",
-    value: function updatePlannerTrans(elementId, deltaMove, deltaAngleDeg, rotCorrection, transState, autoDockingDistance) {
+    value: function updatePlannerTrans(elementId, deltaMove, deltaAngleDeg, rotCorrection, transState, autoDockingDistance, turningPoint) {
       var _this3 = this;
       var updateConfig = false;
       if (this.plannerElements.has(elementId)) {
         var plannerElement = this.plannerElements.get(elementId);
-        plannerElement === null || plannerElement === void 0 || plannerElement.updateDeltaTrans(deltaMove, deltaAngleDeg, rotCorrection, transState == 'END');
+        plannerElement === null || plannerElement === void 0 || plannerElement.updateDeltaTrans(deltaMove, deltaAngleDeg, rotCorrection, transState == 'END', turningPoint);
         if (transState == 'START') {
           if (plannerElement) {
             var dpsToUndock = ['AVR', 'AVL'];
@@ -1731,8 +1984,8 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
         }
         var shelfPlannerElements = _this5.set.getShelfPlannerData(elemId);
         if (shelfPlannerElements) {
-          for (var _i4 = 0; _i4 < shelfPlannerElements.length; _i4++) {
-            var accessorire = shelfPlannerElements[_i4];
+          for (var _i5 = 0; _i5 < shelfPlannerElements.length; _i5++) {
+            var accessorire = shelfPlannerElements[_i5];
             var shelfConfig = _this5.set.getShelfPlannerConfigData(accessorire.basketId).config;
             var _accElements2 = [];
             if (shelfConfig.accs && shelfConfig.accs.length > 0) {