@crystaldesign/web-planner-logic 26.13.0-beta.32 → 26.13.0-beta.34

package/build/esm/{DivaStandardPlanner-9864a9dd.js → DivaStandardPlanner-abd9609d.js}

@@ -1,14 +1,14 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { V as Vector3, P as PlannerElementData, B as BoundingBox } from './index-8d311c4b.js';
+import { V as Vector3, p as poseOf, g as getSnapPlace, c as getDockingGroups, d as getElementShape, e as getCarrierSlots, h as getSlotPlaces, m as moveGroupRigidly, i as isSamePose, j as getGroupBlock, k as fitsInsideRoom, l as keepInsideRoom, n as bindToWalls, o as sameGeoExtent, q as getCornerEnd, r as getDoorClearanceRects, t as rectCorners, u as Vector2, M as MAX_GUEST_DEPTH, v as slotExempt, w as bodiesOverlap, x as getNearestMember, y as toPlacementOffset, z as getTurnDeg, A as moveSlotMember, B as moveShape, C as layersCollide, D as shapesCollide, P as PlannerElementData, E as parseGuestPlacement, F as saveElementArticleCodex, H as parseSetPlanData, I as isSavePlannerV2, J as BoundingBox, K as movePoints } from './index-88148ccc.js';
 import DivaUtils, { DivaError, md5 } from '@crystaldesign/diva-utils';
-import { computeDockedTransform } from '@crystaldesign/planner-2d-core';
-import { d as dockingPointHandlerInst, h as handler2D } from './PlannerHandler2D-88b9a108.js';
-import '@babel/runtime/helpers/slicedToArray';
+import { computeDockedTransform } from '@crystaldesign/planner-core';
+import { d as dockingPointHandlerInst, h as handler2D } from './PlannerHandler2D-8d963e77.js';
 import '@babel/runtime/helpers/objectWithoutProperties';
 import 'axios';
 import '@babel/runtime/helpers/typeof';
@@ -23,28 +23,76 @@ import '@crystaldesign/basket-handler';
 import 'socket.io-client';
 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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var LOG = DivaUtils.initLog('Planner', 'WEB-PLANNER-LOGIC');
 var ACC_DOCK_TYPES = ['AVO', 'AVU', 'AVC', 'AVS', 'AVN'];
+
+/** An element of the set as a drag checks it: its shape, and its layer for the catalog's layer rule. */
+
+/**
+ * Something a dragged group may not run into: an element of another docking group of this set or of another set (its id,
+ * its layer where the catalog's layer rule applies; of another set its set and that set's rules), or a door's clearance,
+ * its swing or doorway (none).
+ */
+
+/** A pose on the floor moved rigidly from `from` to `to`, as the points it carries (see `movePoints`). */
+function movePose(pose, from, to) {
+  var _movePoints = movePoints([new Vector2(pose.center.x, pose.center.z)], from, to),
+    _movePoints2 = _slicedToArray(_movePoints, 1),
+    center = _movePoints2[0];
+  return {
+    center: {
+      x: center.x,
+      z: center.y
+    },
+    rotDeg: pose.rotDeg + to.rotDeg - from.rotDeg
+  };
+}
+
+/** How close (cm) a 'snap' group's wall pose has to be to the dragged position for it to dock to the wall. */
+var WALL_SNAP_DISTANCE = 30;
+/** The free-pose search around a group that landed on another: ring spacing (cm) and directions per ring. */
+var CLEAR_SEARCH_STEP = 10;
+var CLEAR_SEARCH_DIRECTIONS = 16;
+/** cm a blocked turn's release looks around for a free place at least (farther where the group's longer side is longer). */
+var TURN_PLACE_REACH = 100;
+/** cm the room rule may move a suggested place before it no longer counts as that place. */
+var PLACE_TOLERANCE = 1;
+/** cm the room rule may move a pose a guest snaps to off its place (the float noise of moved outlines). */
+var ROOM_RULE_NOISE = 0.01;
+/** cm between the poses a drag checks on its way: less than the thinnest part (a table leg), so nothing is jumped. */
+var PATH_STEP = 2;
+/** cm a pair that overlapped at the start may vary in depth while it moves along (the float noise of moved outlines). */
+var DEPTH_NOISE = 1e-6;
+/** cm within which a dragged guest snaps into a free place of a slot that takes it. */
+var SLOT_SNAP_DISTANCE = 20;
+/** cm within which a drag counts as back at its start (the float noise of the summed moves). */
+var START_NOISE = 1e-6;
+var toFloorRect = function toFloorRect(block, pose) {
+  return {
+    center: pose.center,
+    halfWidth: block.halfWidth,
+    halfDepth: block.halfDepth,
+    rotDeg: pose.rotDeg
+  };
+};
+
+/** The article codex the room rules read: a main element's; none for an accessory. */
+var mainCodex = function mainCodex(member) {
+  return member.IsAccessoire ? '' : member.ArticleCodex;
+};
+
+/** `pose` moved back inside the room, its rotation kept. */
+var insidePose = function insidePose(block, pose, room) {
+  return {
+    center: keepInsideRoom(toFloorRect(block, pose), room),
+    rotDeg: pose.rotDeg
+  };
+};
 var DivaStandardPlanner = /*#__PURE__*/function () {
   /*
     This function updates te planner data of all Elements if they changed. 
@@ -56,7 +104,13 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
 
   function DivaStandardPlanner(set, updatePlannerMsgContainer, plannerId, globalBoundingBox, doDisablePlanner2D, plannerHasStaticBackground) {
     var _this = this;
+    var getOtherCollisionSets = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : function () {
+      return [];
+    };
+    var findCarrier = arguments.length > 7 ? arguments[7] : undefined;
     _classCallCheck(this, DivaStandardPlanner);
+    this.getOtherCollisionSets = getOtherCollisionSets;
+    this.findCarrier = findCarrier;
     _defineProperty(this, "plannerID", void 0);
     _defineProperty(this, "set", void 0);
     _defineProperty(this, "plannerBoundingBox", void 0);
@@ -70,6 +124,16 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
     _defineProperty(this, "IDM3DCatCodex", '');
     _defineProperty(this, "IDM3DEnvironment", 'diva.ro');
     _defineProperty(this, "nextElementId", 1);
+    _defineProperty(this, "room", void 0);
+    _defineProperty(this, "roomDrag", void 0);
+    /** Elements whose group a room rule placed (insert, resize, drag, scene switch, …): a measurement re-binds them. */
+    _defineProperty(this, "roomPlaced", new WeakSet());
+    /** The elements the current drag moves (ids): the grabbed one, those the viewer moves with it, a room drag's group, their guests. */
+    _defineProperty(this, "dragUnit", void 0);
+    /** Of the current drag's elements, the guests it carries along (ids, see `getFollowers`). */
+    _defineProperty(this, "dragFollowers", new Set());
+    /** The free slot places the grabbed element may snap into (see `findSlotSnap`), found when the drag starts where it stood. */
+    _defineProperty(this, "dragSlots", void 0);
     _defineProperty(this, "collisionHandler", void 0);
     _defineProperty(this, "dockToAVUorAVOororAVNorAVSorAVC", function (plannerElement, targetElements) {
       // Capability comes from the SVG-parsed docking points, not the catalog metadata counts
@@ -167,6 +231,18 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
       if (!this.getCatalogData().dontSetPosNrFromPlanner) startChainElements = startChainElements.sort(function (a, b) {
         return a.WorldPosCenter.x - b.WorldPosCenter.x;
       });
+      // Elements put into a carrier's slot come after the chains, by the numbers they have; a new one last.
+      var keptPosNr = function keptPosNr(element) {
+        return element.PosNr > 0 ? element.PosNr : Infinity;
+      };
+      var atEnd = startChainElements.filter(function (element) {
+        return element.PosNrAtEnd;
+      }).sort(function (a, b) {
+        return keptPosNr(a) - keptPosNr(b);
+      });
+      startChainElements = [].concat(_toConsumableArray(startChainElements.filter(function (element) {
+        return !element.PosNrAtEnd;
+      })), _toConsumableArray(atEnd));
       var posNrAcc;
       var _updateAccessoiresOfElement = function updateAccessoiresOfElement(curElement, posNrParent) {
         //Nun habe ich ein Element und muss überprüfen, ob es Accessoires hat. Das sind Elemente, die über AVO, AVU oder AVC gedockt sind.
@@ -278,16 +354,217 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
      * {@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.
+     * are translating with it. In a room drag it is the room pose instead, with what blocks it at contact.
      */
   }, {
     key: "getDockSnapPreview",
     value: function getDockSnapPreview(elementId, autoDockingDistance) {
+      var _this$roomDrag, _this$findDockSnap;
       var excludeElementIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
       var element = this.plannerElements.get(elementId);
       if (!element) return null;
+      // A room drag that turned into a rotation moves the normal way: its preview only names what the turned group runs into.
+      if (this.room && ((_this$roomDrag = this.roomDrag) === null || _this$roomDrag === void 0 ? void 0 : _this$roomDrag.elementId) === elementId) {
+        return this.roomDrag.rotating ? this.getRoomTurnPreview(element, this.roomDrag) : this.getRoomDragPreview(element, this.roomDrag);
+      }
+      return (_this$findDockSnap = this.findDockSnap(element, autoDockingDistance, [].concat(_toConsumableArray(excludeElementIds), _toConsumableArray(this.dragFollowers)))) !== null && _this$findDockSnap !== void 0 ? _this$findDockSnap : this.findSlotSnap(element);
+    }
+
+    /**
+     * The move (cm / deg, about the element's centre) into the nearest free slot place found when its drag started (see
+     * `findDragSlotPlaces`), within SLOT_SNAP_DISTANCE: lined up and turned as the place says, at its own distance to the
+     * carrier as far as the slot's band allows. Null when no place is that near, the element is not the one dragged or it
+     * is back where the drag started (a cancel ends there exactly).
+     */
+  }, {
+    key: "findSlotSnap",
+    value: function findSlotSnap(element) {
+      var _this$dragSlots;
+      var slots = ((_this$dragSlots = this.dragSlots) === null || _this$dragSlots === void 0 ? void 0 : _this$dragSlots.elementId) === element.ElementId ? this.dragSlots : undefined;
+      var _poseOf = poseOf(element),
+        center = _poseOf.center;
+      var places = slots && Math.hypot(center.x - slots.start.x, center.z - slots.start.z) > START_NOISE ? slots.places : [];
+      var nearest = getSnapPlace(places, center, SLOT_SNAP_DISTANCE);
+      if (!nearest) return null;
+      return {
+        dx: nearest.center.x - center.x,
+        dz: nearest.center.z - center.z,
+        dRotDeg: getTurnDeg(element.RotDeg, places[nearest.index].rotDeg)
+      };
+    }
+
+    // The group's pose where the grabbed element snaps into a free slot place (see findSlotSnap) from where the pointer has
+    // it in a room drag; undefined when no place is near.
+  }, {
+    key: "getSlotSnapPose",
+    value: function getSlotSnapPose(drag) {
+      var _this$dragSlots2;
+      var places = ((_this$dragSlots2 = this.dragSlots) === null || _this$dragSlots2 === void 0 ? void 0 : _this$dragSlots2.elementId) === drag.elementId ? this.dragSlots.places : [];
+      if (places.length === 0) return undefined;
+      var raw = {
+        center: {
+          x: drag.grabbedStart.x + drag.dx,
+          z: drag.grabbedStart.z + drag.dz
+        },
+        rotDeg: drag.grabbedStartRotDeg
+      };
+      var nearest = getSnapPlace(places, raw.center, SLOT_SNAP_DISTANCE);
+      if (!nearest) return undefined;
+      var block = {
+        center: {
+          x: drag.start.center.x + drag.dx,
+          z: drag.start.center.z + drag.dz
+        },
+        rotDeg: drag.start.rotDeg
+      };
+      return movePose(block, raw, {
+        center: nearest.center,
+        rotDeg: places[nearest.index].rotDeg
+      });
+    }
+
+    /**
+     * The free places of the slots that take the grabbed element, at carriers outside the dragged unit in this and the
+     * other sets, for a unit of one main element; free where the element stands clear of every body and zone there (its
+     * carrier's zone and a slot's reach under its carrier allowed). Found once when the drag starts.
+     */
+  }, {
+    key: "findDragSlotPlaces",
+    value: function findDragSlotPlaces(element, unit) {
+      var _this3 = this;
+      var _ref = element.IsAccessoire ? [] : this.getPlacementTypes(element),
+        _ref2 = _slicedToArray(_ref, 1),
+        type = _ref2[0];
+      var group = this.getDockingGroupOf(element);
+      if (!type || group.filter(function (member) {
+        return !member.IsAccessoire;
+      }).length !== 1) return [];
+      var otherSets = this.getOtherCollisionSets(group.map(function (member) {
+        return member.ElementId;
+      }));
+      var own = getDockingGroups(this.getAllPlannerElements().filter(function (other) {
+        return !unit.includes(other);
+      })).filter(function (carrier) {
+        return carrier.some(function (member) {
+          return !member.IsAccessoire;
+        });
+      }).map(function (carrier) {
+        return {
+          rules: _this3.getCatalogData().placementOptions.rules,
+          members: _this3.getSlotMembers(carrier)
+        };
+      });
+      var others = otherSets.flatMap(function (set) {
+        return _toConsumableArray(new Set(set.parts.map(function (part) {
+          return part.group;
+        }))).map(function (members) {
+          return {
+            rules: set.rules,
+            members: members
+          };
+        });
+      });
+      var body = getElementShape(element, false).body[0];
+      var pose = poseOf(element);
+      var outline = function outline(rotDeg) {
+        return movePoints(body, pose, {
+          center: {
+            x: 0,
+            z: 0
+          },
+          rotDeg: rotDeg
+        });
+      };
+      var drag = this.room ? this.createRoomDrag(element.ElementId, false, otherSets) : undefined;
+      return [].concat(_toConsumableArray(own), _toConsumableArray(others)).flatMap(function (_ref3) {
+        var rules = _ref3.rules,
+          members = _ref3.members;
+        return getCarrierSlots(rules, members, type);
+      }).flatMap(function (slot) {
+        return getSlotPlaces(slot, outline);
+      }).filter(function (place) {
+        return _this3.placeIsFree(element, group, place, otherSets);
+      }).map(function (place) {
+        return drag ? _this3.cutBandToRoom(drag, place) : place;
+      });
+    }
+
+    // The free place with its band cut to the offsets at which the room rule leaves the dragged group where it is: a guest
+    // never snaps where the rule would move it.
+  }, {
+    key: "cutBandToRoom",
+    value: function cutBandToRoom(drag, place) {
+      var _this4 = this;
+      var grabbed = {
+        center: drag.grabbedStart,
+        rotDeg: drag.grabbedStartRotDeg
+      };
+      var kept = function kept(offset) {
+        var center = {
+          x: place.center.x + place.normal.x * offset,
+          z: place.center.z + place.normal.z * offset
+        };
+        return !!_this4.getKeptPose(drag, movePose(drag.start, grabbed, {
+          center: center,
+          rotDeg: place.rotDeg
+        }), ROOM_RULE_NOISE);
+      };
+      var cut = function cut(end) {
+        if (kept(end)) return end;
+        var free = 0;
+        var blocked = end;
+        for (var i = 0; i < 12; i++) {
+          var mid = (free + blocked) / 2;
+          if (kept(mid)) free = mid;else blocked = mid;
+        }
+        return free;
+      };
+      return _objectSpread(_objectSpread({}, place), {}, {
+        band: [cut(place.band[0]), cut(place.band[1])]
+      });
+    }
+
+    // Whether the element's group, moved so the element stands at `place`, stands there by the room rule and collides with
+    // nothing (see fitsAt); it is put back where it stood.
+  }, {
+    key: "placeIsFree",
+    value: function placeIsFree(element, group, place, otherSets) {
+      var saved = group.map(function (member) {
+        return {
+          member: member,
+          center: member.WorldPosCenter,
+          rotDeg: member.RotDeg
+        };
+      });
+      moveGroupRigidly(group, poseOf(element), place);
+      var drag = this.createRoomDrag(element.ElementId, false, otherSets);
+      var free = !!drag && !!this.getKeptPose(drag) && !this.isBlocked(drag, drag.start);
+      var _iterator = _createForOfIteratorHelper(saved),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+            member = _step$value.member,
+            center = _step$value.center,
+            rotDeg = _step$value.rotDeg;
+          member.WorldPosCenter = center;
+          member.RotDeg = rotDeg;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return free;
+    }
+
+    // The move (cm / deg, about the element's centre) onto the element's nearest dock within `autoDockingDistance`, to an
+    // element not in `excludeElementIds`; null when none is in range. Nothing changes.
+  }, {
+    key: "findDockSnap",
+    value: function findDockSnap(element, autoDockingDistance, excludeElementIds) {
       var targets = this.getAllPlannerElements().filter(function (e) {
-        return e.getElementId() !== elementId && !excludeElementIds.includes(e.getElementId());
+        return e !== element && !excludeElementIds.includes(e.getElementId());
       });
       var pairs = dockingPointHandlerInst.searchDockableElementsInArea(element, targets, autoDockingDistance);
       if (!pairs || pairs.size === 0) return null;
@@ -316,6 +593,1273 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
       return result;
     }
 
+    /**
+     * The rigid move from where the planner holds a dragged element's group to where a viewer shows it with `preview` (see
+     * {@link getDockSnapPreview}): none in a room drag, which holds the group where it shows; else the dock snap, turning
+     * about the element's centre.
+     */
+  }, {
+    key: "getPreviewMove",
+    value: function getPreviewMove(elementId, preview) {
+      var _this$roomDrag2;
+      var element = this.plannerElements.get(elementId);
+      if (!element || !preview || this.room && ((_this$roomDrag2 = this.roomDrag) === null || _this$roomDrag2 === void 0 ? void 0 : _this$roomDrag2.elementId) === elementId) return undefined;
+      return this.snapMove(element, preview);
+    }
+
+    // The rigid move of a dock snap (see findDockSnap): shifted and turned about the element's centre.
+  }, {
+    key: "snapMove",
+    value: function snapMove(element, snap) {
+      var center = {
+        x: element.WorldPosCenter.x,
+        z: element.WorldPosCenter.z
+      };
+      return {
+        from: {
+          center: center,
+          rotDeg: 0
+        },
+        to: {
+          center: {
+            x: center.x + snap.dx,
+            z: center.z + snap.dz
+          },
+          rotDeg: snap.dRotDeg
+        }
+      };
+    }
+
+    /**
+     * Activates (or clears) the room the elements are bound to. With `bindGroups` every docking group of main elements
+     * gets the room rule once: a forced group goes to its nearest wall pose, any other is pushed inside the room. A group
+     * the rules leave on other furniture or in a door's clearance (swing or doorway), where it did not stand so before, then
+     * goes to the nearest free pose (see {@link moveClearOfObstacles}). Returns false when a forced group fits on no wall
+     * (it stays where it is).
+     */
+  }, {
+    key: "setRoom",
+    value: function setRoom(room, bindGroups) {
+      // Measured in the room the elements stood in so far.
+      var blockedBefore = room && bindGroups ? this.getBlockedGroupKeys() : new Set();
+      this.room = room;
+      this.roomDrag = undefined;
+      if (!room || !bindGroups) return true;
+      var allGroupsFit = this.placeGroupsInRoom();
+      this.clearNewlyBlockedGroups(room, blockedBefore);
+      this.updatePlannerPosNr();
+      this.checkCollision(false);
+      this.updatePlannerBoundingBox();
+      return allGroupsFit;
+    }
+
+    // Applies the room rules to every docking group of main elements, or only to the groups holding one of `elements`;
+    // false when a forced group fits on no wall. A group of guests goes with its carrier instead.
+  }, {
+    key: "placeGroupsInRoom",
+    value: function placeGroupsInRoom(elements) {
+      var allGroupsFit = true;
+      var _iterator2 = _createForOfIteratorHelper(getDockingGroups(this.getAllPlannerElements())),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var group = _step2.value;
+          if (elements && !group.some(function (member) {
+            return elements.includes(member);
+          })) continue;
+          if (this.followsCarrier(group)) continue;
+          if (!this.placeGroupInRoom(group)) allGroupsFit = false;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return allGroupsFit;
+    }
+
+    // The first main element of each docking group (not a guest at its carrier) that stands on another group, of this set
+    // or of another set in the room, or in a door's clearance in the active room.
+  }, {
+    key: "getBlockedGroupKeys",
+    value: function getBlockedGroupKeys() {
+      var blocked = new Set();
+      var _iterator3 = _createForOfIteratorHelper(getDockingGroups(this.getAllPlannerElements())),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var group = _step3.value;
+          var main = group.find(function (member) {
+            return !member.IsAccessoire;
+          });
+          if (!main || this.followsCarrier(group)) continue;
+          var drag = this.createRoomDrag(main.ElementId);
+          if (drag && this.isBlocked(drag, drag.start)) blocked.add(main.ElementId);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return blocked;
+    }
+
+    // Every group (but a guest at its carrier) whose first main element is not in `blockedBefore` and that stands on
+    // another group or in a door's clearance goes to the nearest free pose (moveClearOfObstacles).
+  }, {
+    key: "clearNewlyBlockedGroups",
+    value: function clearNewlyBlockedGroups(room, blockedBefore) {
+      var _iterator4 = _createForOfIteratorHelper(getDockingGroups(this.getAllPlannerElements())),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var group = _step4.value;
+          var main = group.find(function (member) {
+            return !member.IsAccessoire;
+          });
+          if (main && !blockedBefore.has(main.ElementId) && !this.followsCarrier(group)) this.moveClearOfObstacles(main.ElementId, room);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    }
+
+    // Elements added in a room: their groups get the room rules, and with `clearOfObstacles` a group standing on another or
+    // in a door's clearance moves to the nearest free pose.
+  }, {
+    key: "placeAddedInRoom",
+    value: function placeAddedInRoom(added, clearOfObstacles) {
+      var room = this.room;
+      if (!room) return;
+      if (!this.placeGroupsInRoom(added)) {
+        this.updateRoomNoFitMsg(true);
+        return;
+      }
+      if (!clearOfObstacles) return;
+      var _iterator5 = _createForOfIteratorHelper(getDockingGroups(this.getAllPlannerElements())),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var group = _step5.value;
+          var main = group.find(function (member) {
+            return !member.IsAccessoire && added.includes(member);
+          });
+          if (main && !this.followsCarrier(group)) this.moveClearOfObstacles(main.ElementId, room);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+    }
+
+    // Placing some groups can only show ROOM_NO_FIT_MSG: whether every set fits is DivaPlannerHandler's to say.
+  }, {
+    key: "updateRoomNoFitMsg",
+    value: function updateRoomNoFitMsg(show) {
+      var _this$collisionHandle, _this$collisionHandle2;
+      (_this$collisionHandle = (_this$collisionHandle2 = this.collisionHandler).updatePlannerMsgContainer) === null || _this$collisionHandle === void 0 || _this$collisionHandle.call(_this$collisionHandle2, 'ROOM_NO_FIT_MSG', show, 'WARNING', 'ROOM_NO_FIT_MSG', false);
+    }
+
+    /**
+     * Whether every docking group of the set has its place in the active room: a forced group stands on its wall pose, any other
+     * (but guests at their carrier) room within the footprint as it stands turned, with its followers (no room: true). Until the
+     * viewer measured its main elements a group that has a wall pose counts as standing on it: an opened one was saved
+     * with their measured extents, which reach at least as far as the outline, a placed one goes there once measured (see
+     * setElementFootprints).
+     */
+  }, {
+    key: "groupsFitInRoom",
+    value: function groupsFitInRoom() {
+      var _this5 = this;
+      var room = this.room;
+      if (!room) return true;
+      return getDockingGroups(this.getAllPlannerElements()).every(function (group) {
+        if (group.every(function (member) {
+          return member.IsAccessoire;
+        })) return true;
+        if (!_this5.isWallBound(group)) return _this5.followsCarrier(group) || _this5.fitsInside(group, room);
+        var _this5$getWallBinding = _this5.getWallBinding(group, room),
+          groupBlock = _this5$getWallBinding.groupBlock,
+          pose = _this5$getWallBinding.pose;
+        if (!pose) return false;
+        return isSamePose(pose, groupBlock) || group.some(function (member) {
+          return !member.IsAccessoire && !member.GeoExtent;
+        });
+      });
+    }
+
+    // Whether the group with its followers, pushed inside the room (see insidePose), lies within it.
+  }, {
+    key: "fitsInside",
+    value: function fitsInside(group, room) {
+      var groupBlock = getGroupBlock([].concat(_toConsumableArray(group), _toConsumableArray(this.getFollowers(group))), this.getRoomFrame(group).RotDeg);
+      return fitsInsideRoom(toFloorRect(groupBlock.block, insidePose(groupBlock.block, groupBlock, room)), room);
+    }
+
+    // A forced group goes to its nearest wall pose (false when it fits on none), any other group is pushed inside the room
+    // with its followers (their bodies too; false when it is wider or deeper than the room). The followers go along
+    // either way.
+  }, {
+    key: "placeGroupInRoom",
+    value: function placeGroupInRoom(group, frameElement) {
+      var _this6 = this;
+      var followers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getFollowers(group);
+      if (!this.room || group.every(function (member) {
+        return member.IsAccessoire;
+      })) return true;
+      group.forEach(function (member) {
+        return _this6.roomPlaced.add(member);
+      });
+      if (this.isWallBound(group)) return this.bindGroupToWalls(group, frameElement, followers);
+      var frame = this.getRoomFrame(group, frameElement);
+      var unit = [].concat(_toConsumableArray(group), _toConsumableArray(followers));
+      var groupBlock = getGroupBlock(unit, frame.RotDeg);
+      var pose = insidePose(groupBlock.block, groupBlock, this.room);
+      moveGroupRigidly(unit, groupBlock, pose);
+      return fitsInsideRoom(toFloorRect(groupBlock.block, pose), this.room);
+    }
+
+    // The element whose rotation frames the group: `preferred` unless it is an accessory, else the oldest main element.
+  }, {
+    key: "getRoomFrame",
+    value: function getRoomFrame(members, preferred) {
+      var _members$find;
+      if (preferred && !preferred.IsAccessoire) return preferred;
+      return (_members$find = members.find(function (member) {
+        return !member.IsAccessoire;
+      })) !== null && _members$find !== void 0 ? _members$find : members[0];
+    }
+  }, {
+    key: "bindGroupToWalls",
+    value: function bindGroupToWalls(members, frameElement) {
+      var followers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      if (!this.room || !members.length) return false;
+      var _this$getWallBinding = this.getWallBinding(members, this.room, frameElement),
+        groupBlock = _this$getWallBinding.groupBlock,
+        pose = _this$getWallBinding.pose;
+      if (!pose) return false;
+      moveGroupRigidly([].concat(_toConsumableArray(members), _toConsumableArray(followers)), groupBlock, pose);
+      return true;
+    }
+
+    /**
+     * The group as one block, and its wall pose (null: it fits on no wall), in the frame it is bound in: `preferred`'s,
+     * else the rotation of a main element in which it already stands on its wall pose (a group released by a turned
+     * element keeps that frame), else the oldest main element's (see getRoomFrame).
+     */
+  }, {
+    key: "getWallBinding",
+    value: function getWallBinding(members, room, preferred) {
+      var _this7 = this;
+      var bindingIn = function bindingIn(frame) {
+        var groupBlock = _this7.getRoomBlock(members, frame);
+        return {
+          groupBlock: groupBlock,
+          pose: bindToWalls(groupBlock.center, groupBlock.block, room)
+        };
+      };
+      var first = bindingIn(this.getRoomFrame(members, preferred));
+      if (preferred && !preferred.IsAccessoire) return first;
+      var standsOn = function standsOn(_ref4) {
+        var groupBlock = _ref4.groupBlock,
+          pose = _ref4.pose;
+        return !!pose && isSamePose(pose, groupBlock);
+      };
+      if (standsOn(first)) return first;
+      var _iterator6 = _createForOfIteratorHelper(members),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var member = _step6.value;
+          if (member.IsAccessoire || member.RotDeg === first.groupBlock.rotDeg) continue;
+          var binding = bindingIn(member);
+          if (standsOn(binding)) return binding;
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      return first;
+    }
+
+    /**
+     * Takes the 3D extents the viewer measured for this set's main elements, so a part reaching beyond the 2D outline
+     * stays out of the walls. A forced group a room rule placed goes to its wall pose with them (it was placed before its
+     * model was measured); a group as the planning was opened moves only with the next user action. Returns whether an
+     * element moved.
+     */
+  }, {
+    key: "setElementFootprints",
+    value: function setElementFootprints(footprints) {
+      var _this8 = this;
+      var changed = [];
+      var _iterator7 = _createForOfIteratorHelper(footprints),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _step7$value = _step7.value,
+            elementId = _step7$value.elementId,
+            minX = _step7$value.minX,
+            maxX = _step7$value.maxX,
+            minZ = _step7$value.minZ,
+            maxZ = _step7$value.maxZ,
+            top = _step7$value.top;
+          var element = this.plannerElements.get(elementId);
+          var extent = {
+            minX: minX,
+            maxX: maxX,
+            minZ: minZ,
+            maxZ: maxZ,
+            top: top
+          };
+          if (!element || element.IsAccessoire || sameGeoExtent(element.GeoExtent, extent)) continue;
+          element.GeoExtent = extent;
+          if (this.roomPlaced.has(element)) changed.push(element);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      if (!this.room || changed.length === 0) return false;
+      var groups = getDockingGroups(this.getAllPlannerElements()).filter(function (group) {
+        return group.some(function (member) {
+          return changed.includes(member);
+        }) && _this8.isWallBound(group) && !_this8.followsCarrier(group);
+      });
+      var members = groups.flat();
+      var before = members.map(function (member) {
+        return [member.WorldPosCenter.x, member.WorldPosCenter.z, member.RotDeg];
+      });
+      groups.forEach(function (group) {
+        return _this8.placeGroupInRoom(group);
+      });
+      var moved = members.some(function (member, i) {
+        var _before$i = _slicedToArray(before[i], 3),
+          x = _before$i[0],
+          z = _before$i[1],
+          rotDeg = _before$i[2];
+        return member.WorldPosCenter.x !== x || member.WorldPosCenter.z !== z || member.RotDeg !== rotDeg;
+      });
+      if (!moved) return false;
+      this.updatePlannerPosNr();
+      this.checkCollision(false);
+      this.updatePlannerBoundingBox();
+      return true;
+    }
+
+    /** Whether the element's docking group is bound to the walls of the active room. */
+  }, {
+    key: "isElementWallBound",
+    value: function isElementWallBound(elementId) {
+      var element = this.plannerElements.get(elementId);
+      return !!this.room && !!element && this.isWallBound(this.getDockingGroupOf(element));
+    }
+
+    /**
+     * A group's wall mode: forced when a main element is forced or a corner element, else snap when one snaps, else free. A
+     * guest's own wall rule rests while it stands at its carrier.
+     */
+  }, {
+    key: "getGroupWallMode",
+    value: function getGroupWallMode(members) {
+      var _this9 = this;
+      var catalogData = this.getCatalogData();
+      var modes = members.flatMap(function (member) {
+        var codex = _this9.getCarrierOf(member) ? '' : mainCodex(member);
+        if (!codex) return [];
+        return [catalogData.getCornerSide(codex) ? 'forced' : catalogData.getWallMode(codex)];
+      });
+      return modes.includes('forced') ? 'forced' : modes.includes('snap') ? 'snap' : 'free';
+    }
+  }, {
+    key: "isWallBound",
+    value: function isWallBound(members) {
+      return this.getGroupWallMode(members) === 'forced';
+    }
+
+    // The group as one block in `frame`'s rotation; a corner element at one of its ends pins that end into a corner.
+  }, {
+    key: "getRoomBlock",
+    value: function getRoomBlock(members, frame) {
+      var groupBlock = getGroupBlock(members, frame.RotDeg);
+      var catalogData = this.getCatalogData();
+      var _iterator8 = _createForOfIteratorHelper(members),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var member = _step8.value;
+          var codex = mainCodex(member);
+          var side = codex ? catalogData.getCornerSide(codex) : undefined;
+          if (!side) continue;
+          var cornerEnd = getCornerEnd(members, frame.RotDeg, member, side);
+          if (cornerEnd) return _objectSpread(_objectSpread({}, groupBlock), {}, {
+            block: _objectSpread(_objectSpread({}, groupBlock.block), {}, {
+              cornerEnd: cornerEnd
+            })
+          });
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+      return groupBlock;
+    }
+
+    /** A group collides unless all its main elements are NO_COLLISION (e.g. rugs). */
+  }, {
+    key: "collides",
+    value: function collides(members) {
+      var _this10 = this;
+      return members.some(function (member) {
+        var codex = mainCodex(member);
+        return !!codex && !_this10.hasNoCollision(codex);
+      });
+    }
+  }, {
+    key: "hasNoCollision",
+    value: function hasNoCollision(codex) {
+      return !!codex && this.getCatalogData().hasNoCollision(codex);
+    }
+
+    /** The article's placement types, primary first (PLACEMENT_TYPE, else palette group); empty without one. */
+  }, {
+    key: "getPlacementTypes",
+    value: function getPlacementTypes(element) {
+      var codex = element.ArticleCodex;
+      return codex && this.getCatalogData().getPlacementType(codex) || [];
+    }
+
+    // The main elements of a group as carriers of placement slots, by their outlines (never the viewer's measures).
+  }, {
+    key: "getSlotMembers",
+    value: function getSlotMembers(group) {
+      var _this11 = this;
+      return group.filter(function (member) {
+        return !member.IsAccessoire;
+      }).map(function (member) {
+        return {
+          types: _this11.getPlacementTypes(member),
+          rotDeg: member.RotDeg,
+          body: getElementShape(member, false).body[0],
+          basketId: member.getBasketId()
+        };
+      });
+    }
+
+    // The member with its shape where it stands (with the viewer's measures when `measured`) and its group as slot carrier.
+  }, {
+    key: "toCollisionShape",
+    value: function toCollisionShape(member, slotMembers, measured) {
+      return {
+        elementId: member.ElementId,
+        shape: getElementShape(member, measured),
+        types: this.getPlacementTypes(member),
+        group: slotMembers,
+        layer: Number(member.Layer)
+      };
+    }
+
+    // The members of `group` that take part in collisions (see toCollisionShape).
+  }, {
+    key: "getCollidingShapes",
+    value: function getCollidingShapes(group, measured) {
+      var _this12 = this;
+      var slotMembers = this.getSlotMembers(group);
+      return group.filter(function (member) {
+        return !_this12.hasNoCollision(member.ArticleCodex);
+      }).map(function (member) {
+        return _this12.toCollisionShape(member, slotMembers, measured);
+      });
+    }
+
+    // Every element of the other colliding groups (not those of `unit`, the group with its followers), the elements of the
+    // other sets (`otherSets`, else those without the guests going with `members`), and in a room the door clearances: the
+    // swings and doorways (getDoorClearanceRects).
+  }, {
+    key: "getObstacles",
+    value: function getObstacles(members, measured) {
+      var _this13 = this;
+      var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : members;
+      var otherSets = arguments.length > 3 ? arguments[3] : undefined;
+      if (!this.collides(members)) return [];
+      var others = getDockingGroups(this.getAllPlannerElements()).filter(function (group) {
+        return !group.some(function (member) {
+          return unit.includes(member);
+        }) && _this13.collides(group);
+      });
+      var _this$getCatalogData = this.getCatalogData(),
+        catalogCodex = _this$getCatalogData.catalogCodex;
+      // Two catalogs always collide; one catalog in two sets by its layer rule.
+      var foreign = (otherSets !== null && otherSets !== void 0 ? otherSets : this.getOtherCollisionSets(members.map(function (member) {
+        return member.ElementId;
+      }))).flatMap(function (set) {
+        return set.parts.map(function (_ref5) {
+          var shape = _ref5.shape,
+            types = _ref5.types,
+            group = _ref5.group,
+            elementId = _ref5.elementId,
+            layer = _ref5.layer;
+          var ownLayerRule = set.catalogCodex === catalogCodex;
+          return {
+            shape: shape,
+            types: types,
+            group: group,
+            elementId: elementId,
+            layer: ownLayerRule ? layer : undefined,
+            setId: set.setId,
+            rules: set.rules
+          };
+        });
+      });
+      var doors = (this.room ? getDoorClearanceRects(this.room) : []).map(function (swing) {
+        var polygon = rectCorners(swing).map(function (corner) {
+          return new Vector2(corner.x, corner.z);
+        });
+        return {
+          shape: {
+            body: [polygon],
+            free: [polygon]
+          },
+          types: [],
+          group: []
+        };
+      });
+      return [].concat(_toConsumableArray(others.flatMap(function (group) {
+        return _this13.getCollidingShapes(group, measured);
+      })), _toConsumableArray(foreign), _toConsumableArray(doors));
+    }
+  }, {
+    key: "getDockingGroupOf",
+    value: function getDockingGroupOf(element) {
+      var _getDockingGroups$fin;
+      return (_getDockingGroups$fin = getDockingGroups(this.getAllPlannerElements()).find(function (group) {
+        return group.includes(element);
+      })) !== null && _getDockingGroups$fin !== void 0 ? _getDockingGroups$fin : [element];
+    }
+
+    /** The element whose article has the basket id; undefined when the set has none. */
+  }, {
+    key: "getElementByBasketId",
+    value: function getElementByBasketId(basketId) {
+      return this.getAllPlannerElements().find(function (element) {
+        return element.getBasketId() === basketId;
+      });
+    }
+
+    // The carrier a guest stands at while its set is loaded; without a resolver only one of this set.
+  }, {
+    key: "getCarrierOf",
+    value: function getCarrierOf(element) {
+      var placement = element.Placement;
+      if (!placement) return undefined;
+      if (this.findCarrier) return this.findCarrier(placement);
+      return this.getElementByBasketId(placement.carrierBasketId);
+    }
+
+    // Whether every main element of the group is a guest at a carrier outside it: the group goes with its carrier.
+  }, {
+    key: "followsCarrier",
+    value: function followsCarrier(group) {
+      var _this14 = this;
+      var mains = group.filter(function (member) {
+        return !member.IsAccessoire;
+      });
+      return mains.length > 0 && mains.every(function (member) {
+        var carrier = _this14.getCarrierOf(member);
+        return !!carrier && !group.includes(carrier);
+      });
+    }
+
+    /**
+     * The guests of this set that go with `members`: those standing at one of them, and the guests of those (at most
+     * MAX_GUEST_DEPTH carriers deep), each with its docking group; never one of `members`.
+     */
+  }, {
+    key: "getFollowers",
+    value: function getFollowers(members) {
+      var _this15 = this;
+      var unit = new Set(members);
+      var followers = [];
+      var carriers = members;
+      for (var depth = 0; depth < MAX_GUEST_DEPTH && carriers.length > 0; depth++) {
+        var guests = this.getAllPlannerElements().filter(function (element) {
+          var carrier = !unit.has(element) && _this15.getCarrierOf(element);
+          return !!carrier && carriers.includes(carrier);
+        });
+        var next = _toConsumableArray(new Set(guests.flatMap(function (guest) {
+          return _this15.getDockingGroupOf(guest);
+        }))).filter(function (element) {
+          return !unit.has(element);
+        });
+        next.forEach(function (element) {
+          return unit.add(element);
+        });
+        followers.push.apply(followers, _toConsumableArray(next));
+        carriers = next;
+      }
+      return followers;
+    }
+
+    /** The ids of the element's docking group, the element included. */
+  }, {
+    key: "getDockingGroupIds",
+    value: function getDockingGroupIds(elementId) {
+      var element = this.plannerElements.get(elementId);
+      return element ? this.getDockingGroupOf(element).map(function (member) {
+        return member.ElementId;
+      }) : [];
+    }
+
+    /** The element's first placement type; undefined for an accessory or an article without one. */
+  }, {
+    key: "getGuestType",
+    value: function getGuestType(elementId) {
+      var element = this.plannerElements.get(elementId);
+      return element && !element.IsAccessoire ? this.getPlacementTypes(element)[0] : undefined;
+    }
+
+    /** The main elements of every docking group as slot carriers (see `getSlotMembers`), but groups holding one of `excludeIds`. */
+  }, {
+    key: "getSlotCarriers",
+    value: function getSlotCarriers(excludeIds) {
+      var _this16 = this;
+      return getDockingGroups(this.getAllPlannerElements()).filter(function (group) {
+        return !group.some(function (member) {
+          return excludeIds.includes(member.ElementId);
+        });
+      }).map(function (group) {
+        return _this16.getSlotMembers(group);
+      }).filter(function (members) {
+        return members.length > 0;
+      });
+    }
+
+    /** Moves the element's docking group rigidly so the element stands at `pose` (a guest following its carrier). */
+  }, {
+    key: "moveGuest",
+    value: function moveGuest(elementId, pose) {
+      var element = this.plannerElements.get(elementId);
+      if (element) moveGroupRigidly(this.getDockingGroupOf(element), poseOf(element), pose);
+    }
+
+    /** After guests moved: position numbers, the collision warning and the bounding box follow. */
+  }, {
+    key: "refreshAfterGuestMoves",
+    value: function refreshAfterGuestMoves() {
+      this.updatePlannerPosNr();
+      this.checkCollision(false);
+      this.updatePlannerBoundingBox();
+    }
+
+    /**
+     * Whether the element's docking group, moved so the element stands at `pose`, runs a body into another body of this set
+     * or of `otherSets` (a zone does not count, a slot guest at its carrier as everywhere); the group stays where it is.
+     */
+  }, {
+    key: "isBodyBlockedAt",
+    value: function isBodyBlockedAt(elementId, pose, otherSets) {
+      var element = this.plannerElements.get(elementId);
+      if (!element) return true;
+      var group = this.getDockingGroupOf(element);
+      var saved = group.map(function (member) {
+        return {
+          member: member,
+          center: member.WorldPosCenter,
+          rotDeg: member.RotDeg
+        };
+      });
+      moveGroupRigidly(group, poseOf(element), pose);
+      var drag = this.createRoomDrag(elementId, false, otherSets);
+      if (drag) drag.zonesBlock = false;
+      var blocked = !!drag && this.isBlocked(drag, drag.start);
+      var _iterator9 = _createForOfIteratorHelper(saved),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _step9$value = _step9.value,
+            member = _step9$value.member,
+            center = _step9$value.center,
+            rotDeg = _step9$value.rotDeg;
+          member.WorldPosCenter = center;
+          member.RotDeg = rotDeg;
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+      return blocked;
+    }
+  }, {
+    key: "startRoomDrag",
+    value: function startRoomDrag(elementId) {
+      this.roomDrag = undefined;
+      var drag = this.createRoomDrag(elementId);
+      if (!drag) return;
+      drag.zonesBlock = false;
+      var moved = this.movedShapes(drag, drag.start);
+      var _iterator10 = _createForOfIteratorHelper(drag.obstacles),
+        _step10;
+      try {
+        var _loop = function _loop() {
+          var obstacle = _step10.value;
+          // A guest standing in its slot as far under its carrier as the slot lets it (a chair at the table) overlaps by right.
+          var depths = moved.map(function (member) {
+            var _obstacle$rules;
+            return slotExempt(drag.rules, member, (_obstacle$rules = obstacle.rules) !== null && _obstacle$rules !== void 0 ? _obstacle$rules : drag.rules, obstacle) ? 0 : bodiesOverlap(member.shape, obstacle.shape);
+          });
+          if (depths.some(function (depth) {
+            return depth > 0;
+          })) drag.startOverlaps.set(obstacle, depths);
+        };
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          _loop();
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+      this.roomDrag = drag;
+    }
+
+    /**
+     * The element's group as one block where it stands, with its followers (see `getFollowers`): the members' and the
+     * followers' shapes and every obstacle but them; not started. A forced group's block is its own, any other group's
+     * takes in the followers, so the room rule keeps them inside too.
+     */
+  }, {
+    key: "createRoomDrag",
+    value: function createRoomDrag(elementId) {
+      var _this17 = this;
+      var measured = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var otherSets = arguments.length > 2 ? arguments[2] : undefined;
+      var element = this.plannerElements.get(elementId);
+      if (!element) return undefined;
+      var members = this.getDockingGroupOf(element);
+      if (members.every(function (member) {
+        return member.IsAccessoire;
+      })) return undefined;
+      var followers = this.getFollowers(members);
+      var wallMode = this.getGroupWallMode(members);
+      var frame = this.getRoomFrame(members, element);
+      var start = wallMode === 'forced' ? this.getRoomBlock(members, frame) : getGroupBlock([].concat(_toConsumableArray(members), _toConsumableArray(followers)), frame.RotDeg);
+      var position = element.WorldPosCenter;
+      var followerShapes = getDockingGroups(followers).filter(function (group) {
+        return _this17.collides(group);
+      }).flatMap(function (group) {
+        return _this17.getCollidingShapes(group, measured);
+      });
+      var memberShapes = this.collides(members) ? this.getCollidingShapes(members, measured) : [];
+      var drag = {
+        elementId: elementId,
+        members: members,
+        followers: followers,
+        start: start,
+        current: start,
+        grabbedStart: {
+          x: position.x,
+          z: position.z
+        },
+        grabbedStartRotDeg: element.RotDeg,
+        dx: 0,
+        dz: 0,
+        wallMode: wallMode,
+        shapes: this.collides(members) ? [].concat(_toConsumableArray(memberShapes), _toConsumableArray(followerShapes)) : [],
+        memberShapes: memberShapes.length,
+        obstacles: this.getObstacles(members, measured, [].concat(_toConsumableArray(members), _toConsumableArray(followers)), otherSets),
+        blockedBy: [],
+        startOverlaps: new Map(),
+        rules: this.getCatalogData().placementOptions.rules,
+        zonesBlock: true,
+        rotating: false,
+        slotSnapped: false
+      };
+      return drag;
+    }
+
+    /**
+     * A group placed beside the planning, or by the room rules, that stands on another group (of this set or another set in
+     * the room) or in a door's clearance goes to the nearest free pose, by the room rule of its wall mode, and slides back
+     * until it touches what it was cleared of. It stays where it is when the room has no free pose for it.
+     */
+  }, {
+    key: "moveClearOfObstacles",
+    value: function moveClearOfObstacles(elementId, room) {
+      var drag = this.createRoomDrag(elementId);
+      if (!drag || !this.isBlocked(drag, drag.start)) return;
+      var _drag$start = drag.start,
+        block = _drag$start.block,
+        rotDeg = _drag$start.rotDeg;
+        _drag$start.center;
+      var poseAt = function poseAt(raw) {
+        return drag.wallMode === 'forced' ? bindToWalls(raw, block, room) : insidePose(block, {
+          center: raw,
+          rotDeg: rotDeg
+        }, room);
+      };
+      var xs = room.footprint.map(function (_ref6) {
+        var _ref7 = _slicedToArray(_ref6, 1),
+          x = _ref7[0];
+        return x;
+      });
+      var zs = room.footprint.map(function (_ref8) {
+        var _ref9 = _slicedToArray(_ref8, 2),
+          z = _ref9[1];
+        return z;
+      });
+      var reach = Math.hypot(Math.max.apply(Math, _toConsumableArray(xs)) - Math.min.apply(Math, _toConsumableArray(xs)), Math.max.apply(Math, _toConsumableArray(zs)) - Math.min.apply(Math, _toConsumableArray(zs)));
+      var target = this.nearestFreePose(drag, drag.start, poseAt, reach);
+      if (target) moveGroupRigidly([].concat(_toConsumableArray(drag.members), _toConsumableArray(drag.followers)), drag.start, target);
+    }
+
+    // Of the free poses on the first ring around `origin` that has one, slid back until they touch, the nearest one.
+  }, {
+    key: "nearestFreePose",
+    value: function nearestFreePose(drag, origin, poseAt, reach) {
+      var center = origin.center;
+      for (var radius = CLEAR_SEARCH_STEP; radius <= reach; radius += CLEAR_SEARCH_STEP) {
+        var nearest = void 0;
+        for (var i = 0; i < CLEAR_SEARCH_DIRECTIONS; i++) {
+          var _this$slideToContact;
+          var angle = i / CLEAR_SEARCH_DIRECTIONS * 2 * Math.PI;
+          var pose = poseAt({
+            x: center.x + radius * Math.cos(angle),
+            z: center.z + radius * Math.sin(angle)
+          });
+          if (!pose || this.isBlocked(drag, pose)) continue;
+          drag.current = pose;
+          var slid = (_this$slideToContact = this.slideToContact(drag, origin)) === null || _this$slideToContact === void 0 ? void 0 : _this$slideToContact.pose;
+          // The way back may cross a notch of the room: the slid pose counts only where the room rule keeps it.
+          var kept = slid && poseAt(slid.center);
+          var target = slid && kept && Math.hypot(kept.center.x - slid.center.x, kept.center.z - slid.center.z) < 0.5 ? slid : pose;
+          var distance = Math.hypot(target.center.x - center.x, target.center.z - center.z);
+          if (!nearest || distance < nearest.distance - START_NOISE) nearest = {
+            pose: target,
+            distance: distance
+          };
+        }
+        if (nearest) return nearest.pose;
+      }
+      return undefined;
+    }
+
+    /**
+     * Puts a new element at the first free place a slot of the `isCarrier` groups suggests (lowest PosNr first, planner
+     * data only), numbers it last (PosNrAtEnd) and makes it a guest of the carrier (see `attachToSlot`); false, the element
+     * unmoved, when no place is free.
+     */
+  }, {
+    key: "placeAtSuggestedPlace",
+    value: function placeAtSuggestedPlace(element, isCarrier) {
+      var _this18 = this;
+      var _ref10 = element.IsAccessoire ? [] : this.getPlacementTypes(element),
+        _ref11 = _slicedToArray(_ref10, 1),
+        type = _ref11[0];
+      if (!type) return false;
+      var rules = this.getCatalogData().placementOptions.rules;
+      var before = {
+        center: {
+          x: element.WorldPosCenter.x,
+          z: element.WorldPosCenter.z
+        },
+        rotDeg: element.RotDeg
+      };
+      var body = getElementShape(element, false).body[0];
+      var outline = function outline(rotDeg) {
+        return movePoints(body, before, {
+          center: {
+            x: 0,
+            z: 0
+          },
+          rotDeg: rotDeg
+        });
+      };
+      var lowestPosNr = function lowestPosNr(group) {
+        return Math.min.apply(Math, _toConsumableArray(group.map(function (member) {
+          return member.PosNr;
+        })));
+      };
+      var carriers = getDockingGroups(this.getAllPlannerElements().filter(function (other) {
+        return other !== element;
+      })).filter(function (group) {
+        return isCarrier(group) && group.some(function (member) {
+          return !member.IsAccessoire;
+        });
+      }).sort(function (a, b) {
+        return lowestPosNr(a) - lowestPosNr(b);
+      });
+      var otherSets = carriers.length > 0 ? this.getOtherCollisionSets() : [];
+      var _iterator11 = _createForOfIteratorHelper(carriers),
+        _step11;
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var group = _step11.value;
+          var _iterator12 = _createForOfIteratorHelper(getCarrierSlots(rules, this.getSlotMembers(group), type)),
+            _step12;
+          try {
+            for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+              var slot = _step12.value;
+              if (!getSlotPlaces(slot, outline).some(function (place) {
+                return _this18.fitsAt(element, place, otherSets);
+              })) continue;
+              element.PosNrAtEnd = true;
+              this.attachToSlot(element, slot);
+              return true;
+            }
+          } catch (err) {
+            _iterator12.e(err);
+          } finally {
+            _iterator12.f();
+          }
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+      element.WorldPosCenter = new Vector3(before.center.x, element.WorldPosCenter.y, before.center.z);
+      element.RotDeg = before.rotDeg;
+      return false;
+    }
+
+    // Makes the element a guest of the member of `slot` nearest to it: it goes with that carrier from now on. Not when the
+    // carrier is a guest MAX_GUEST_DEPTH deep itself.
+  }, {
+    key: "attachToSlot",
+    value: function attachToSlot(element, slot) {
+      var _getNearestMember;
+      var basketId = (_getNearestMember = getNearestMember(slot, poseOf(element).center)) === null || _getNearestMember === void 0 ? void 0 : _getNearestMember.basketId;
+      var carrier = basketId ? this.getElementByBasketId(basketId) : undefined;
+      if (!basketId || !carrier || this.getGuestDepth(carrier) >= MAX_GUEST_DEPTH) return;
+      var offset = toPlacementOffset(poseOf(carrier), poseOf(element));
+      element.Placement = {
+        carrierBasketId: basketId,
+        slotId: slot.id,
+        offset: offset
+      };
+    }
+
+    // How many carriers stand above the element: 0 on its own, 1 at a carrier on its own, …
+  }, {
+    key: "getGuestDepth",
+    value: function getGuestDepth(element) {
+      var depth = 0;
+      for (var carrier = this.getCarrierOf(element); carrier && depth <= MAX_GUEST_DEPTH; carrier = this.getCarrierOf(carrier)) depth++;
+      return depth;
+    }
+
+    // Moves the element to `pose` as the room rule keeps it; whether it fits there: the rule moves it no further than the
+    // tolerance and it collides with nothing of this set or of `otherSets`.
+  }, {
+    key: "fitsAt",
+    value: function fitsAt(element, pose, otherSets) {
+      element.WorldPosCenter = new Vector3(pose.center.x, this.plannerBoundingBox.WorldPos.y, pose.center.z);
+      element.RotDeg = pose.rotDeg;
+      var drag = this.createRoomDrag(element.ElementId, false, otherSets);
+      var kept = drag && this.getKeptPose(drag);
+      if (!drag || !kept) return false;
+      moveGroupRigidly(drag.members, drag.start, kept);
+      return !this.isBlocked(drag, kept);
+    }
+
+    // Where the room rule of its wall mode keeps the drag's group standing at `pose` (no room: the pose); undefined when it
+    // would move the group further than `tolerance`, turn it, or fit it on no wall.
+  }, {
+    key: "getKeptPose",
+    value: function getKeptPose(drag) {
+      var pose = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : drag.start;
+      var tolerance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : PLACE_TOLERANCE;
+      var room = this.room;
+      if (!room) return pose;
+      var block = drag.start.block;
+      var center = pose.center,
+        rotDeg = pose.rotDeg;
+      var kept = drag.wallMode === 'forced' ? bindToWalls(center, block, room) : insidePose(block, pose, room);
+      if (!kept || Math.hypot(kept.center.x - center.x, kept.center.z - center.z) > tolerance) return undefined;
+      return Math.abs(getTurnDeg(rotDeg, kept.rotDeg)) > 0.01 ? undefined : kept;
+    }
+
+    // The colliding members and followers of the dragged group, moved with it to `pose`, each group's carrier outlines too.
+  }, {
+    key: "movedShapes",
+    value: function movedShapes(drag, pose) {
+      var movedGroups = new Map();
+      return drag.shapes.map(function (member) {
+        var _movedGroups$get;
+        var group = (_movedGroups$get = movedGroups.get(member.group)) !== null && _movedGroups$get !== void 0 ? _movedGroups$get : member.group.map(function (slotMember) {
+          return moveSlotMember(slotMember, drag.start, pose);
+        });
+        movedGroups.set(member.group, group);
+        return _objectSpread(_objectSpread({}, member), {}, {
+          shape: moveShape(member.shape, drag.start, pose),
+          group: group
+        });
+      });
+    }
+
+    // Whether a member collides with an obstacle: body against body (a pair that overlapped at the start once it gets
+    // deeper), and where zones block, a body in the other's free area. A guest standing in a slot of its carrier's group may
+    // stand in the carrier's free area (a hocker in front of the sofa), and reach under its body as far as the slot lets it
+    // (a chair's seat under the table top). Two layers only as the catalog lets them collide, as in the collision warning.
+  }, {
+    key: "overlapsAny",
+    value: function overlapsAny(moved, obstacle, drag) {
+      var startDepths = drag.startOverlaps.get(obstacle);
+      var collidingLayers = this.getCatalogData().checkCollisionForDifferentLayers;
+      return moved.some(function (member, i) {
+        var _obstacle$rules2;
+        if (obstacle.layer !== undefined && !layersCollide(collidingLayers, member.layer, obstacle.layer)) return false;
+        if (startDepths) return bodiesOverlap(member.shape, obstacle.shape) > startDepths[i] + DEPTH_NOISE;
+        return shapesCollide(member.shape, obstacle.shape, !drag.zonesBlock) && !slotExempt(drag.rules, member, (_obstacle$rules2 = obstacle.rules) !== null && _obstacle$rules2 !== void 0 ? _obstacle$rules2 : drag.rules, obstacle);
+      });
+    }
+  }, {
+    key: "isBlocked",
+    value: function isBlocked(drag, pose) {
+      var _this19 = this;
+      var moved = this.movedShapes(drag, pose);
+      return drag.obstacles.some(function (obstacle) {
+        return _this19.overlapsAny(moved, obstacle, drag);
+      });
+    }
+
+    // The obstacles the group runs into at `pose`.
+  }, {
+    key: "blockersAt",
+    value: function blockersAt(drag, pose) {
+      var _this20 = this;
+      var moved = this.movedShapes(drag, pose);
+      return drag.obstacles.filter(function (obstacle) {
+        return _this20.overlapsAny(moved, obstacle, drag);
+      });
+    }
+
+    // The straight way from the current pose to `target`, checked every PATH_STEP and cut at the first contact: the
+    // furthest free pose before it (none when the group cannot move at all), so a blocked group ends up touching, and the
+    // obstacles it runs into just beyond; `target` and none when the whole way is free. Undefined when the way turns the group.
+  }, {
+    key: "slideToContact",
+    value: function slideToContact(drag, target) {
+      if (Math.abs(getTurnDeg(drag.current.rotDeg, target.rotDeg)) > 0.01) return undefined;
+      var from = drag.current.center;
+      var at = function at(s) {
+        return {
+          center: {
+            x: from.x + (target.center.x - from.x) * s,
+            z: from.z + (target.center.z - from.z) * s
+          },
+          rotDeg: target.rotDeg
+        };
+      };
+      var steps = Math.max(1, Math.ceil(Math.hypot(target.center.x - from.x, target.center.z - from.z) / PATH_STEP));
+      var free = 0;
+      for (var step = 1; step <= steps; step++) {
+        var blocked = step / steps;
+        if (!this.isBlocked(drag, at(blocked))) {
+          free = blocked;
+          continue;
+        }
+        for (var i = 0; i < 12; i++) {
+          var mid = (free + blocked) / 2;
+          if (this.isBlocked(drag, at(mid))) blocked = mid;else free = mid;
+        }
+        return {
+          pose: free > 0 ? at(free) : undefined,
+          blockers: this.blockersAt(drag, at(blocked))
+        };
+      }
+      return {
+        pose: target,
+        blockers: []
+      };
+    }
+
+    // The group follows the grabbed element rigidly to the wall or inside-room pose of the raw centre, also where it runs
+    // into an obstacle: what it runs into there is kept as `blockedBy` (the viewer shows the drag blocked, a release there
+    // goes back to the start). A forced group that fits on no wall is kept inside the room like a free one. Back at the
+    // start (a cancel, a blocked release) it stands exactly where it started, nothing snaps.
+  }, {
+    key: "updateRoomDrag",
+    value: function updateRoomDrag(room, drag, deltaMove) {
+      drag.dx += deltaMove.x;
+      drag.dz += deltaMove.z;
+      var _drag$start2 = drag.start,
+        block = _drag$start2.block,
+        rotDeg = _drag$start2.rotDeg;
+      var rawCenter = {
+        x: drag.start.center.x + drag.dx,
+        z: drag.start.center.z + drag.dz
+      };
+      var atStart = Math.hypot(drag.dx, drag.dz) <= START_NOISE;
+      // A free slot place near the pointer comes before the wall.
+      var slotPose = atStart ? undefined : this.getSlotSnapPose(drag);
+      var wallPose = atStart || slotPose || drag.wallMode === 'free' ? null : bindToWalls(rawCenter, block, room);
+      var snapsToWall = !!wallPose && Math.hypot(wallPose.center.x - rawCenter.x, wallPose.center.z - rawCenter.z) <= WALL_SNAP_DISTANCE;
+      var startPose = {
+        center: drag.start.center,
+        rotDeg: rotDeg
+      };
+      var wanted = atStart ? startPose : slotPose !== null && slotPose !== void 0 ? slotPose : wallPose && (drag.wallMode === 'forced' || snapsToWall) ? wallPose : insidePose(block, {
+        center: rawCenter,
+        rotDeg: rotDeg
+      }, room);
+      drag.blockedBy = this.blockersAt(drag, wanted);
+      moveGroupRigidly([].concat(_toConsumableArray(drag.members), _toConsumableArray(drag.followers)), drag.current, wanted);
+      drag.current = wanted;
+      drag.slotSnapped = !!slotPose;
+      // A pair that overlapped at the start may only come apart, never go back in.
+      if (drag.startOverlaps.size === 0) return;
+      var moved = this.movedShapes(drag, wanted);
+      drag.startOverlaps.forEach(function (depths, obstacle) {
+        return drag.startOverlaps.set(obstacle, depths.map(function (depth, i) {
+          return Math.min(depth, bodiesOverlap(moved[i].shape, obstacle.shape));
+        }));
+      });
+    }
+
+    // The unit moved rigidly onto the nearest dock of `element` outside it (see findDockSnap), else with `slots` into the
+    // nearest free slot place (see findSlotSnap).
+  }, {
+    key: "snapToDock",
+    value: function snapToDock(element, unit, autoDockingDistance, slots) {
+      var _this$findDockSnap2;
+      var unitIds = unit.map(function (member) {
+        return member.ElementId;
+      });
+      var snap = (_this$findDockSnap2 = this.findDockSnap(element, autoDockingDistance, unitIds)) !== null && _this$findDockSnap2 !== void 0 ? _this$findDockSnap2 : slots ? this.findSlotSnap(element) : null;
+      if (!snap) return;
+      var move = this.snapMove(element, snap);
+      moveGroupRigidly(unit, move.from, move.to);
+    }
+
+    // The unit of a drag starting at the element: in a room the drag's group, else the element (the viewer's UPDATEs add the
+    // rest of its group), with the guests that go along; and the free slot places it may snap into.
+  }, {
+    key: "startDragUnit",
+    value: function startDragUnit(elementId, roomDrag) {
+      var _roomDrag$followers, _roomDrag$members$map;
+      var element = this.plannerElements.get(elementId);
+      var followers = (_roomDrag$followers = roomDrag === null || roomDrag === void 0 ? void 0 : roomDrag.followers) !== null && _roomDrag$followers !== void 0 ? _roomDrag$followers : element ? this.getFollowers(this.getDockingGroupOf(element)) : [];
+      this.dragFollowers = new Set(followers.map(function (follower) {
+        return follower.ElementId;
+      }));
+      this.dragUnit = new Set([elementId].concat(_toConsumableArray((_roomDrag$members$map = roomDrag === null || roomDrag === void 0 ? void 0 : roomDrag.members.map(function (member) {
+        return member.ElementId;
+      })) !== null && _roomDrag$members$map !== void 0 ? _roomDrag$members$map : []), _toConsumableArray(this.dragFollowers)));
+      var unit = element ? [].concat(_toConsumableArray(this.getDockingGroupOf(element)), _toConsumableArray(followers)) : [];
+      this.dragSlots = element ? {
+        elementId: elementId,
+        start: poseOf(element).center,
+        places: this.findDragSlotPlaces(element, unit)
+      } : undefined;
+    }
+
+    // Where the group shows against where the pointer put the grabbed element, and what it runs into there.
+  }, {
+    key: "getRoomDragPreview",
+    value: function getRoomDragPreview(element, drag) {
+      var position = element.WorldPosCenter;
+      var preview = {
+        dx: position.x - (drag.grabbedStart.x + drag.dx),
+        dz: position.z - (drag.grabbedStart.z + drag.dz),
+        dRotDeg: getTurnDeg(drag.start.rotDeg, element.RotDeg)
+      };
+      return this.withDragBlock(preview, drag);
+    }
+
+    // What a free group being turned runs into where it is turned now (it moves no further than the turn: no offset). Only
+    // its members count: a guest swung into a body leaves its carrier on release instead (see DivaPlannerHandler).
+  }, {
+    key: "getRoomTurnPreview",
+    value: function getRoomTurnPreview(element, drag) {
+      var members = _objectSpread(_objectSpread({}, drag), {}, {
+        shapes: drag.shapes.slice(0, drag.memberShapes)
+      });
+      drag.blockedBy = this.blockersAt(members, this.getTurnedPose(element, drag));
+      return this.withDragBlock({
+        dx: 0,
+        dz: 0,
+        dRotDeg: 0
+      }, drag);
+    }
+
+    // A blocked turn's release: at its angle, the nearest free place inside the room within reach; undefined when none.
+  }, {
+    key: "findTurnPlace",
+    value: function findTurnPlace(element, drag, room) {
+      var turned = this.getTurnedPose(element, drag);
+      var block = drag.start.block;
+      var members = _objectSpread(_objectSpread({}, drag), {}, {
+        shapes: drag.shapes.slice(0, drag.memberShapes),
+        current: turned
+      });
+      if (!this.isBlocked(members, turned)) return turned;
+      var poseAt = function poseAt(raw) {
+        return insidePose(block, {
+          center: raw,
+          rotDeg: turned.rotDeg
+        }, room);
+      };
+      return this.nearestFreePose(members, turned, poseAt, Math.max(TURN_PLACE_REACH, 2 * Math.max(block.halfWidth, block.halfDepth)));
+    }
+
+    // The pose of the group's block where the grabbed element stands now, moved with it rigidly from the start.
+  }, {
+    key: "getTurnedPose",
+    value: function getTurnedPose(element, drag) {
+      return movePose(drag.start, {
+        center: drag.grabbedStart,
+        rotDeg: drag.grabbedStartRotDeg
+      }, poseOf(element));
+    }
+
+    // `preview` with what the group runs into (`blockedBy`): the elements, and whether a door's clearance; as it is while free.
+  }, {
+    key: "withDragBlock",
+    value: function withDragBlock(preview, drag) {
+      if (drag.blockedBy.length === 0) return preview;
+      var ownSetId = this.set.getSetId();
+      var elements = [];
+      var _iterator13 = _createForOfIteratorHelper(drag.blockedBy),
+        _step13;
+      try {
+        var _loop2 = function _loop2() {
+          var _step13$value = _step13.value,
+            _step13$value$setId = _step13$value.setId,
+            setId = _step13$value$setId === void 0 ? ownSetId : _step13$value$setId,
+            elementId = _step13$value.elementId;
+          if (elementId !== undefined && !elements.some(function (element) {
+            return element.setId === setId && element.elementId === elementId;
+          })) elements.push({
+            setId: setId,
+            elementId: elementId
+          });
+        };
+        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+          _loop2();
+        }
+      } catch (err) {
+        _iterator13.e(err);
+      } finally {
+        _iterator13.f();
+      }
+      return _objectSpread(_objectSpread({}, preview), {}, {
+        blockedBy: {
+          elements: elements,
+          door: drag.blockedBy.some(function (obstacle) {
+            return obstacle.elementId === undefined;
+          })
+        }
+      });
+    }
+
     /**
      * 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.
@@ -373,11 +1917,11 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
         var progressed = true;
         while (progressed) {
           progressed = false;
-          var _iterator = _createForOfIteratorHelper(sortedPlannerElementsbyPosNr),
-            _step;
+          var _iterator14 = _createForOfIteratorHelper(sortedPlannerElementsbyPosNr),
+            _step14;
           try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var _element = _step.value;
+            for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+              var _element = _step14.value;
               if (!_element || moved.has(_element.ElementId)) continue;
               var dpToMovedPartner = getDockedDPsInPriorityOrder(_element).find(function (dp) {
                 return moved.has(dp.OnElementId);
@@ -389,9 +1933,9 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               }
             }
           } catch (err) {
-            _iterator.e(err);
+            _iterator14.e(err);
           } finally {
-            _iterator.f();
+            _iterator14.f();
           }
         }
       }
@@ -412,8 +1956,10 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
     key: "addElementToWorld",
     value: (function () {
       var _addElementToWorld = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(plannerElement, dockingPointInfos, suppressDock, globalBoundingBox) {
+        var _this21 = this;
         var xOffset,
           setToTransform,
+          placedBeside,
           _setToTransform$trans,
           worldPosCenter,
           height,
@@ -426,16 +1972,22 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           targetDP,
           successDP,
           success,
-          allPlannerElements,
+          selectedId,
+          atSelected,
+          mayPlace,
+          placed,
           _success,
+          allPlannerElements,
           _args = arguments;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               xOffset = _args.length > 4 && _args[4] !== undefined ? _args[4] : 100;
               setToTransform = _args.length > 5 ? _args[5] : undefined;
+              // Docked to nothing: put beside the planning, where it may land on another group in the room.
+              placedBeside = false;
               if (!(setToTransform && setToTransform.forceSetToTrans)) {
-                _context.next = 10;
+                _context.next = 13;
                 break;
               }
               // A switched element keeps the place of the old one; if that stood on the floor, the new one stands there too.
@@ -443,64 +1995,66 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               stoodOnFloor = PlannerElementData.standsOnFloor(worldPosCenter.y, height);
               plannerElement.WorldPosCenter = stoodOnFloor && Number.isFinite(plannerElement.Height) ? new Vector3(worldPosCenter.x, plannerElement.Height / 2, worldPosCenter.z) : worldPosCenter;
               plannerElement.RotDeg = setToTransform.transform.rotDeg;
+              plannerElement.PosNrAtEnd = !!setToTransform.transform.posNrAtEnd;
+              plannerElement.Placement = setToTransform.transform.placement;
               this.set.onDockingChanged(plannerElement.ElementId, -1, 'NOT_DOCKED');
-              _context.next = 50;
+              _context.next = 52;
               break;
-            case 10:
+            case 13:
               //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 = 49;
+                _context.next = 51;
                 break;
               }
               i = 0;
-            case 13:
+            case 16:
               if (!(i < dockingPointInfos.length)) {
-                _context.next = 49;
+                _context.next = 51;
                 break;
               }
               targetElemIdToDock = dockingPointInfos[i].targetElemIdToDock;
               targetDockingPointId = dockingPointInfos[i].targetDockingPointId;
               if (!(targetElemIdToDock && targetElemIdToDock > -1 && this.plannerElements.has(targetElemIdToDock))) {
-                _context.next = 46;
+                _context.next = 48;
                 break;
               }
               if (!(targetDockingPointId && targetDockingPointId != '')) {
-                _context.next = 34;
+                _context.next = 37;
                 break;
               }
               targetElem = this.plannerElements.get(targetElemIdToDock);
               if (!targetElem) {
-                _context.next = 32;
+                _context.next = 35;
                 break;
               }
               targetDP = targetElem.getDockingPointById(targetDockingPointId);
               if (!targetDP) {
-                _context.next = 32;
+                _context.next = 35;
                 break;
               }
               successDP = dockingPointHandlerInst.tryDockElementToDP(plannerElement, targetElem, targetDP);
               if (!successDP) {
-                _context.next = 28;
+                _context.next = 31;
                 break;
               }
               this.updateWorldPos(plannerElement, successDP);
               dockingFound = true;
-              _context.next = 32;
+              _context.next = 35;
               break;
-            case 28:
-              _context.next = 30;
+            case 31:
+              _context.next = 33;
               return this.tryToDockWithDifferentSVGWithFormula(plannerElement, targetElemIdToDock);
-            case 30:
+            case 33:
               if (!_context.sent) {
-                _context.next = 32;
+                _context.next = 35;
                 break;
               }
               dockingFound = true;
-            case 32:
-              _context.next = 46;
+            case 35:
+              _context.next = 48;
               break;
-            case 34:
+            case 37:
               success = false;
               if (plannerElement.HasAVL || plannerElement.HasAVR) {
                 success = this.dockToAVLorAVR(plannerElement, [this.plannerElements.get(targetElemIdToDock)]);
@@ -509,55 +2063,72 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 success = this.dockToAVUorAVOororAVNorAVSorAVC(plannerElement, [this.plannerElements.get(targetElemIdToDock)]);
               }
               if (success) {
-                _context.next = 45;
+                _context.next = 47;
                 break;
               }
-              _context.next = 40;
+              _context.next = 43;
               return this.tryToDockWithDifferentSVGWithFormula(plannerElement, targetElemIdToDock);
-            case 40:
+            case 43:
               success = _context.sent;
               if (success) {
-                _context.next = 45;
+                _context.next = 47;
                 break;
               }
-              _context.next = 44;
-              return this.addElementToWorld(plannerElement, undefined, undefined, undefined, 50);
-            case 44:
-              return _context.abrupt("return");
-            case 45:
+              xOffset = 50;
+              return _context.abrupt("break", 51);
+            case 47:
               if (success) dockingFound = true;
-            case 46:
+            case 48:
               i++;
-              _context.next = 13;
+              _context.next = 16;
               break;
-            case 49:
+            case 51:
               if (!dockingFound) {
-                allPlannerElements = this.getAllPlannerElements();
-                _success = this.dockToAVLorAVR(plannerElement, allPlannerElements);
-                if (suppressDock) _success = false;
-                if (!_success) {
-                  //No free AVR or AVL Docking Point
-                  _success = this.dockToAVUorAVOororAVNorAVSorAVC(plannerElement, allPlannerElements);
+                selectedId = dockingPointInfos === null || dockingPointInfos === void 0 ? void 0 : dockingPointInfos.map(function (info) {
+                  return info.targetElemIdToDock;
+                }).find(function (id) {
+                  return id != null && _this21.plannerElements.has(id);
+                });
+                atSelected = function atSelected(group) {
+                  return selectedId === undefined || group.some(function (member) {
+                    return member.ElementId === selectedId;
+                  });
+                };
+                mayPlace = globalBoundingBox == undefined; // The places the rules suggest at the selected group (without a selection: at any group) come before docking anywhere.
+                placed = mayPlace && this.placeAtSuggestedPlace(plannerElement, atSelected);
+                _success = false;
+                if (!placed) {
+                  allPlannerElements = this.getAllPlannerElements();
+                  _success = this.dockToAVLorAVR(plannerElement, allPlannerElements);
                   if (suppressDock) _success = false;
                   if (!_success) {
-                    //This is the center position of the element - This is needed in order to set the static room layout correctly
-
-                    if (globalBoundingBox == undefined) {
-                      plannerElement.WorldPosCenter = new Vector3(this.plannerBoundingBox.WorldPos.x + this.plannerBoundingBox.Size.x + (this.plannerBoundingBox.Size.x == 0 ? 0 : plannerElement.Width / 2 + xOffset), this.plannerBoundingBox.WorldPos.y, this.plannerBoundingBox.WorldPos.z + plannerElement.Depth / 2);
-                    }
-
-                    //Tell the set this the element was not docked
-                    this.set.onDockingChanged(plannerElement.ElementId, -1, 'NOT_DOCKED');
+                    //No free AVR or AVL Docking Point
+                    _success = this.dockToAVUorAVOororAVNorAVSorAVC(plannerElement, allPlannerElements);
+                    if (suppressDock) _success = false;
                   }
+                  if (!_success && mayPlace && selectedId !== undefined) placed = this.placeAtSuggestedPlace(plannerElement, function (group) {
+                    return !atSelected(group);
+                  });
+                }
+                if (!_success) {
+                  //This is the center position of the element - This is needed in order to set the static room layout correctly
+                  if (mayPlace && !placed) {
+                    placedBeside = true;
+                    plannerElement.WorldPosCenter = new Vector3(this.plannerBoundingBox.WorldPos.x + this.plannerBoundingBox.Size.x + (this.plannerBoundingBox.Size.x == 0 ? 0 : plannerElement.Width / 2 + xOffset), this.plannerBoundingBox.WorldPos.y, this.plannerBoundingBox.WorldPos.z + plannerElement.Depth / 2);
+                  }
+
+                  //Tell the set this the element was not docked
+                  this.set.onDockingChanged(plannerElement.ElementId, -1, 'NOT_DOCKED');
                 }
               }
-            case 50:
+            case 52:
               this.updatePlannerPosNr();
               this.updateAllElementsWorldPos();
               this.updatePlannerPosNr();
+              if (!plannerElement.IsAccessoire) this.placeAddedInRoom([plannerElement], placedBeside);
               this.checkCollision(false, plannerElement.getElementId());
               this.updatePlannerBoundingBox();
-            case 55:
+            case 58:
             case "end":
               return _context.stop();
           }
@@ -745,16 +2316,16 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
       var candidates = [];
       var seen = new Set();
       var collect = function collect(connectorFeature, targetFilters) {
-        var _iterator2 = _createForOfIteratorHelper(targetFilters),
-          _step2;
+        var _iterator15 = _createForOfIteratorHelper(targetFilters),
+          _step15;
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var filter = _step2.value;
-            var _iterator3 = _createForOfIteratorHelper(article.getVariantValuesInfluencingOptions([optPrefix + connectorFeature], opvPrefix + filter)),
-              _step3;
+          for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+            var filter = _step15.value;
+            var _iterator16 = _createForOfIteratorHelper(article.getVariantValuesInfluencingOptions([optPrefix + connectorFeature], opvPrefix + filter)),
+              _step16;
             try {
-              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                var vv = _step3.value;
+              for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+                var vv = _step16.value;
                 var key = JSON.stringify(vv);
                 if (!seen.has(key)) {
                   seen.add(key);
@@ -762,15 +2333,15 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 }
               }
             } catch (err) {
-              _iterator3.e(err);
+              _iterator16.e(err);
             } finally {
-              _iterator3.f();
+              _iterator16.f();
             }
           }
         } catch (err) {
-          _iterator2.e(err);
+          _iterator15.e(err);
         } finally {
-          _iterator2.f();
+          _iterator15.f();
         }
       };
       //this article's AVL side (feature 89) docks against the target's AVR side and vice versa
@@ -998,6 +2569,11 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                   }
                 }
                 this.updateAllElementsWorldPos(undefined, elemtsWhereSomethingChanged);
+                // A resized group must not reach through a wall; where the room moved it, its collisions are checked again.
+                if (this.room) {
+                  this.placeGroupsInRoom();
+                  this.checkCollision(false);
+                }
                 this.updatePlannerPosNr();
                 this.updatePlannerBoundingBox();
               }
@@ -1033,7 +2609,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
             case 0:
               planData = parseSetPlanData(setPlanData);
               if (!isSavePlannerV2(planData)) {
-                _context5.next = 39;
+                _context5.next = 42;
                 break;
               }
               jsonElements = planData.set.elements;
@@ -1043,7 +2619,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               i = 0;
             case 7:
               if (!(i < jsonElements.length)) {
-                _context5.next = 35;
+                _context5.next = 37;
                 break;
               }
               _context5.prev = 8;
@@ -1056,7 +2632,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
                 code: 'WC_0012'
               }));
-              return _context5.abrupt("continue", 32);
+              return _context5.abrupt("continue", 34);
             case 14:
               plannerElement = new PlannerElementData(this.set.getSetId(), jsonElement.basketID, this.nextElementId, DivaStandardPlanner.plannerType);
               oldElementidMapping.set(jsonElement.elementID, plannerElement);
@@ -1074,6 +2650,8 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
             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;
+              plannerElement.PosNrAtEnd = !!jsonElement.posNrAtEnd;
+              plannerElement.Placement = parseGuestPlacement(jsonElement.placement);
               if (plannerElement.IsDockedAccessoire) {
                 accElements.push(jsonElement);
                 plannerElement.PosNr = jsonElement.posNr;
@@ -1082,20 +2660,20 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 elementsSortedbyPosNr[jsonElement.posNr - 1] = jsonElement;
                 plannerElement.PosNr = jsonElement.posNr;
               }
-              _context5.next = 32;
+              _context5.next = 34;
               break;
-            case 29:
-              _context5.prev = 29;
+            case 31:
+              _context5.prev = 31;
               _context5.t0 = _context5["catch"](8);
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
                 cause: _context5.t0,
                 code: 'WC_0012'
               }));
-            case 32:
+            case 34:
               i++;
               _context5.next = 7;
               break;
-            case 35:
+            case 37:
               elementsForDockingExtend = [].concat(_toConsumableArray(elementsSortedbyPosNr.filter(function (e) {
                 return e != null;
               })), accElements);
@@ -1117,17 +2695,19 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                   }
                 }
               }
-              _context5.next = 40;
+              // Added beside the planning, the new elements can stand outside the room: they get the room rules like an insert.
+              this.placeAddedInRoom(_toConsumableArray(oldElementidMapping.values()), true);
+              _context5.next = 43;
               break;
-            case 39:
+            case 42:
               LOG.error(new DivaError('The function extend Planner works only with products that are saved in the configurator 2.0', {
                 code: 'WC_0012'
               }));
-            case 40:
+            case 43:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[8, 29]]);
+        }, _callee5, this, [[8, 31]]);
       }));
       function extendPlanner(_x10, _x11) {
         return _extendPlanner.apply(this, arguments);
@@ -1144,7 +2724,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
             case 0:
               planData = parseSetPlanData(setPlanData);
               if (!isSavePlannerV2(planData)) {
-                _context6.next = 63;
+                _context6.next = 65;
                 break;
               }
               LOG.debug('Initialize set Plan Data - V2\n' + planData, 'DivaStandardPlanner initPlanner');
@@ -1160,7 +2740,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               i = 0;
             case 9:
               if (!(i < jsonElements.length)) {
-                _context6.next = 37;
+                _context6.next = 39;
                 break;
               }
               _context6.prev = 10;
@@ -1173,7 +2753,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
                 code: 'WC_0012'
               }));
-              return _context6.abrupt("continue", 34);
+              return _context6.abrupt("continue", 36);
             case 16:
               elementID = jsonElement.elementID;
               plannerElement = new PlannerElementData(this.set.getSetId(), jsonElement.basketID, elementID, DivaStandardPlanner.plannerType);
@@ -1193,6 +2773,8 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               //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);
               plannerElement.RotDeg = jsonElement.rot;
+              plannerElement.PosNrAtEnd = !!jsonElement.posNrAtEnd;
+              plannerElement.Placement = parseGuestPlacement(jsonElement.placement);
               if (plannerElement.IsDockedAccessoire) {
                 accElements.push(jsonElement);
                 plannerElement.PosNr = jsonElement.posNr;
@@ -1201,34 +2783,34 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 elementsSortedbyPosNr[jsonElement.posNr - 1] = jsonElement;
                 plannerElement.PosNr = jsonElement.posNr;
               }
-              _context6.next = 34;
+              _context6.next = 36;
               break;
-            case 31:
-              _context6.prev = 31;
+            case 33:
+              _context6.prev = 33;
               _context6.t0 = _context6["catch"](10);
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V2', {
                 cause: _context6.t0,
                 code: 'WC_0012'
               }));
-            case 34:
+            case 36:
               i++;
               _context6.next = 9;
               break;
-            case 37:
+            case 39:
               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 40:
+            case 42:
               if (!(i < elementsForDocking.length)) {
-                _context6.next = 61;
+                _context6.next = 63;
                 break;
               }
-              _context6.prev = 41;
+              _context6.prev = 43;
               row = elementsForDocking[i];
               if (!(i == 0 && onlyOneBaseElement && this.plannerHasStaticBackground)) {
-                _context6.next = 48;
+                _context6.next = 50;
                 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.
@@ -1240,14 +2822,14 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 element = this.plannerElements.get(row.elementID);
                 if (element) element.WorldPosCenter = new Vector3(0, element.Height / 2, element.Depth / 2);
               }
-              return _context6.abrupt("continue", 58);
-            case 48:
+              return _context6.abrupt("continue", 60);
+            case 50:
               if (!(row.DP == null || row.DP.length == 0)) {
-                _context6.next = 50;
+                _context6.next = 52;
                 break;
               }
-              return _context6.abrupt("continue", 58);
-            case 50:
+              return _context6.abrupt("continue", 60);
+            case 52:
               DPsInfo = row.DP;
               for (j = 0; j < DPsInfo.length; j++) {
                 dpInfo = DPsInfo[j];
@@ -1268,79 +2850,79 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                   }
                 }
               }
-              _context6.next = 58;
+              _context6.next = 60;
               break;
-            case 54:
-              _context6.prev = 54;
-              _context6.t1 = _context6["catch"](41);
+            case 56:
+              _context6.prev = 56;
+              _context6.t1 = _context6["catch"](43);
               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 58:
+            case 60:
               i++;
-              _context6.next = 40;
-              break;
-            case 61:
-              _context6.next = 116;
+              _context6.next = 42;
               break;
             case 63:
+              _context6.next = 118;
+              break;
+            case 65:
               LOG.debug('Initialize set Plan Data - old V1\n' + planData, 'DivaStandardPlanner initPlanner');
               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;
+                _context6.next = 69;
                 break;
               }
               return _context6.abrupt("return");
-            case 67:
+            case 69:
               _jsonElements = legacySet.Elements;
               _elementsSortedbyPosNr = [];
               _accElements = []; //Zuerst initialisiere alle Elemente
               //Dann positioniere sie richtig
               i = 0;
-            case 71:
+            case 73:
               if (!(i < _jsonElements.length)) {
-                _context6.next = 105;
+                _context6.next = 107;
                 break;
               }
-              _context6.prev = 72;
+              _context6.prev = 74;
               _jsonElement2 = _jsonElements[i];
               _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)) {
-                _context6.next = 78;
+                _context6.next = 80;
                 break;
               }
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner. PlanData V1', {
                 code: 'WC_0012'
               }));
-              return _context6.abrupt("continue", 102);
-            case 78:
+              return _context6.abrupt("continue", 104);
+            case 80:
               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)) {
-                _context6.next = 85;
+                _context6.next = 87;
                 break;
               }
               LOG.error(new DivaError('Error when initializing planner. The elementID Was not saved in the article. ', {
                 code: 'WC_0012'
               }));
-              return _context6.abrupt("continue", 102);
-            case 85:
+              return _context6.abrupt("continue", 104);
+            case 87:
               _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) {
-                _context6.next = 93;
+                _context6.next = 95;
                 break;
               }
-              _context6.next = 93;
+              _context6.next = 95;
               return handler2D.loadSVG(_plannerElement, this.set);
-            case 93:
+            case 95:
               //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);
@@ -1357,36 +2939,36 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 _elementsSortedbyPosNr[_jsonElement2.PosNum - 1] = _jsonElement2;
                 _plannerElement.PosNr = _jsonElement2.PosNum;
               }
-              _context6.next = 102;
+              _context6.next = 104;
               break;
-            case 99:
-              _context6.prev = 99;
-              _context6.t2 = _context6["catch"](72);
+            case 101:
+              _context6.prev = 101;
+              _context6.t2 = _context6["catch"](74);
               LOG.error(new DivaError('Error initializing element nr ' + i + ' in the Standard Web Planner - Plan Data old Planner', {
                 cause: _context6.t2,
                 code: 'WC_0012'
               }));
-            case 102:
+            case 104:
               i++;
-              _context6.next = 71;
+              _context6.next = 73;
               break;
-            case 105:
+            case 107:
               elementsForDockingV1 = [].concat(_toConsumableArray(_elementsSortedbyPosNr.filter(function (e) {
                 return e != null;
               })), _accElements);
               i = 0;
-            case 107:
+            case 109:
               if (!(i < elementsForDockingV1.length)) {
-                _context6.next = 116;
+                _context6.next = 118;
                 break;
               }
               _row = elementsForDockingV1[i];
               if (!(_row.DP == null || _row.DP.length == 0)) {
-                _context6.next = 111;
+                _context6.next = 113;
                 break;
               }
-              return _context6.abrupt("continue", 113);
-            case 111:
+              return _context6.abrupt("continue", 115);
+            case 113:
               _DPsInfo = _row.DP;
               for (j = 0; j < _DPsInfo.length; j++) {
                 _dpInfo = _DPsInfo[j];
@@ -1404,21 +2986,21 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                   }
                 }
               }
-            case 113:
+            case 115:
               i++;
-              _context6.next = 107;
+              _context6.next = 109;
               break;
-            case 116:
+            case 118:
               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 119:
+            case 121:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this, [[10, 31], [41, 54], [72, 99]]);
+        }, _callee6, this, [[10, 33], [43, 56], [74, 101]]);
       }));
       function initPlanner(_x12) {
         return _initPlanner.apply(this, arguments);
@@ -1678,7 +3260,9 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               transform = {
                 rotDeg: plannerElement.getRotDeg(),
                 worldPosCenter: plannerElement.WorldPosCenter,
-                height: plannerElement.Height
+                height: plannerElement.Height,
+                posNrAtEnd: plannerElement.PosNrAtEnd,
+                placement: plannerElement.Placement
               };
               if (!removeDockingRelation) {
                 dockingPointHandlerInst.removeDockingPointRelations(plannerElement);
@@ -1687,6 +3271,8 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               this.tryToDockForNotDockedAccessoire(parent);
               this.updatePlannerPosNr();
               this.updateAllElementsWorldPos();
+              // A group the deletion lets fit, or splits, takes its place in the room.
+              if (this.room) this.placeGroupsInRoom();
               this.updatePlannerPosNr();
               this.checkCollision(false, plannerElement.getElementId());
               this.updatePlannerBoundingBox();
@@ -1694,7 +3280,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
                 newElementToSelect: newSelElemIdPrev >= 0 ? newSelElemIdPrev : newSelElemIdNext >= 0 ? newSelElemIdNext : undefined,
                 transform: transform
               });
-            case 24:
+            case 25:
             case "end":
               return _context9.stop();
           }
@@ -1737,8 +3323,33 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "checkCollision",
     value: function checkCollision(calcCollisionPairs, checkSingleElementId) {
+      var _this22 = this;
       if (this.doDisablePlanner2D) return;
       var allElements = this.getAllPlannerElements();
+      // A NO_COLLISION article (e.g. a rug) neither collides with anything nor is collided with.
+      var noCollisionIds = new Set(allElements.filter(function (element) {
+        return _this22.hasNoCollision(element.ArticleCodex);
+      }).map(function (element) {
+        return element.ElementId;
+      }));
+      // Each colliding element with its outline and its group as slot carrier, built when a pair collides.
+      var slotted;
+      var slottedOf = function slottedOf(element) {
+        var _slotted;
+        (_slotted = slotted) !== null && _slotted !== void 0 ? _slotted : slotted = new Map(getDockingGroups(allElements).flatMap(function (group) {
+          return _this22.getCollidingShapes(group, false);
+        }).map(function (shape) {
+          return [shape.elementId, shape];
+        }));
+        return slotted.get(element.ElementId);
+      };
+      // A guest in its carrier's slot only warns when the bodies overlap.
+      var inSlotClear = function inSlotClear(a, b) {
+        var shapeA = slottedOf(a);
+        var shapeB = slottedOf(b);
+        var rules = _this22.getCatalogData().placementOptions.rules;
+        return !!shapeA && !!shapeB && slotExempt(rules, shapeA, rules, shapeB);
+      };
       var collisionDetected = false;
       var collisionPairs = [];
       for (var i = 0; i < allElements.length; i++) {
@@ -1749,10 +3360,12 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
             var _this$set$CatalogData, _this$set$CatalogData2;
             var element2 = allElements[j];
             if (element1.getElementId() == element2.getElementId()) continue;
+            if (noCollisionIds.has(element1.ElementId) || noCollisionIds.has(element2.ElementId)) continue;
             if (dockingPointHandlerInst.checkElementsAreDocking(element1, element2)) continue;
             var collision = false;
             if (this.set.CatalogData.doCheckConstructionWarnings || (_this$set$CatalogData = this.set.CatalogData.forceConstructionWarningForArticles) !== null && _this$set$CatalogData !== void 0 && _this$set$CatalogData.includes(element1.ArticleCodex) || (_this$set$CatalogData2 = this.set.CatalogData.forceConstructionWarningForArticles) !== null && _this$set$CatalogData2 !== void 0 && _this$set$CatalogData2.includes(element2.ArticleCodex)) {
               collision = handler2D.checkCollision(element1, element2, this.set.CatalogData.checkCollisionForDifferentLayers);
+              if (collision && inSlotClear(element1, element2)) collision = false;
             }
             if (collision) {
               collisionDetected = true;
@@ -1767,17 +3380,56 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
         }
       }
       if (this.collisionHandler.collisionDetected && !collisionDetected) {
-        var _this$collisionHandle, _this$collisionHandle2;
+        var _this$collisionHandle3, _this$collisionHandle4;
         //Collision has changed
-        (_this$collisionHandle = (_this$collisionHandle2 = this.collisionHandler).updatePlannerMsgContainer) === null || _this$collisionHandle === void 0 || _this$collisionHandle.call(_this$collisionHandle2, 'COLLISION_MSG', false, 'WARNING', 'COLLISION_MSG', false);
+        (_this$collisionHandle3 = (_this$collisionHandle4 = this.collisionHandler).updatePlannerMsgContainer) === null || _this$collisionHandle3 === void 0 || _this$collisionHandle3.call(_this$collisionHandle4, 'COLLISION_MSG', false, 'WARNING', 'COLLISION_MSG', false);
       } else if (!this.collisionHandler.collisionDetected && collisionDetected) {
-        var _this$collisionHandle3, _this$collisionHandle4;
-        (_this$collisionHandle3 = (_this$collisionHandle4 = this.collisionHandler).updatePlannerMsgContainer) === null || _this$collisionHandle3 === void 0 || _this$collisionHandle3.call(_this$collisionHandle4, 'COLLISION_MSG', true, 'WARNING', 'COLLISION_MSG', false /*this.collisionHandler.collisionPairs*/);
+        var _this$collisionHandle5, _this$collisionHandle6;
+        (_this$collisionHandle5 = (_this$collisionHandle6 = this.collisionHandler).updatePlannerMsgContainer) === null || _this$collisionHandle5 === void 0 || _this$collisionHandle5.call(_this$collisionHandle6, 'COLLISION_MSG', true, 'WARNING', 'COLLISION_MSG', false /*this.collisionHandler.collisionPairs*/);
       }
       this.collisionHandler.collisionPairs = collisionPairs;
       this.collisionHandler.collisionDetected = collisionDetected;
     }
 
+    /**
+     * The set's elements for the planning's collision warning (`ROOM_COLLISION_MSG`): every element of a colliding docking
+     * group but the NO_COLLISION ones, with its outline (never the viewer's measures). None while the 2D planner is off.
+     */
+  }, {
+    key: "getCollisionSet",
+    value: function getCollisionSet() {
+      return this.toCollisionSet(this.doDisablePlanner2D ? [] : getDockingGroups(this.getAllPlannerElements()));
+    }
+
+    // The colliding ones of the docking groups `groups` as the planning's collision warning checks them.
+  }, {
+    key: "toCollisionSet",
+    value: function toCollisionSet(groups) {
+      var _this23 = this;
+      var catalogData = this.getCatalogData();
+      var parts = groups.filter(function (group) {
+        return _this23.collides(group);
+      }).flatMap(function (group, groupIndex) {
+        var slotMembers = _this23.getSlotMembers(group);
+        return group.filter(function (member) {
+          return !_this23.hasNoCollision(member.ArticleCodex);
+        }).map(function (member) {
+          var _catalogData$forceCon;
+          return _objectSpread(_objectSpread({}, _this23.toCollisionShape(member, slotMembers, false)), {}, {
+            groupIndex: groupIndex,
+            constructionChecked: catalogData.doCheckConstructionWarnings || !!((_catalogData$forceCon = catalogData.forceConstructionWarningForArticles) !== null && _catalogData$forceCon !== void 0 && _catalogData$forceCon.includes(member.ArticleCodex))
+          });
+        });
+      });
+      return {
+        setId: this.set.getSetId(),
+        catalogCodex: catalogData.catalogCodex,
+        rules: catalogData.placementOptions.rules,
+        collidingLayers: catalogData.checkCollisionForDifferentLayers,
+        parts: parts
+      };
+    }
+
     /**
      * Updates the overall set posNr
      * @param startSetPosNr   Indicates the start PosNr for the planner
@@ -1811,8 +3463,24 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "updatePlannerTrans",
     value: function updatePlannerTrans(elementId, deltaMove, deltaAngleDeg, rotCorrection, transState, autoDockingDistance, turningPoint) {
-      var _this3 = this;
+      var _this$dragUnit,
+        _this24 = this;
       var updateConfig = false;
+      var room = this.room;
+      if (room && transState == 'START') this.startRoomDrag(elementId);
+      var roomDrag = room ? this.roomDrag : undefined;
+      if (transState == 'START') this.startDragUnit(elementId, roomDrag);else if (transState == 'UPDATE') (_this$dragUnit = this.dragUnit) === null || _this$dragUnit === void 0 || _this$dragUnit.add(elementId);
+      // A turn keeps its direction: only a move snaps into a slot place.
+      if (transState == 'UPDATE' && deltaAngleDeg !== 0) this.dragSlots = undefined;
+      // Group members follow the grabbed element rigidly, so their own UPDATE deltas are dropped.
+      // A free group's rotation goes the normal way; only wall-bound groups take their rotation from the wall.
+      if (roomDrag && roomDrag.wallMode !== 'forced' && transState == 'UPDATE' && deltaAngleDeg !== 0) roomDrag.rotating = true;
+      if (room && roomDrag && !roomDrag.rotating && transState == 'UPDATE' && roomDrag.members.some(function (member) {
+        return member.ElementId == elementId;
+      })) {
+        if (elementId == roomDrag.elementId) this.updateRoomDrag(room, roomDrag, deltaMove);
+        return false;
+      }
       if (this.plannerElements.has(elementId)) {
         var plannerElement = this.plannerElements.get(elementId);
         plannerElement === null || plannerElement === void 0 || plannerElement.updateDeltaTrans(deltaMove, deltaAngleDeg, rotCorrection, transState == 'END', turningPoint);
@@ -1825,17 +3493,51 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
               updateConfig = this.set.onDockingChanged(plannerElement.ElementId, undockedElements[i], 'UNDOCK');
             }
           }
-        } else if (transState == 'END') {
+        } else if (transState == 'END' && plannerElement) {
+          // A drag released where its group runs into something goes back to where it started, a turn only where findTurnPlace finds none.
+          if ((roomDrag === null || roomDrag === void 0 ? void 0 : roomDrag.elementId) == elementId && roomDrag.blockedBy.length > 0) {
+            var current = roomDrag.rotating ? this.getTurnedPose(plannerElement, roomDrag) : roomDrag.current;
+            var target = roomDrag.rotating && room && this.findTurnPlace(plannerElement, roomDrag, room) || roomDrag.start;
+            moveGroupRigidly([].concat(_toConsumableArray(roomDrag.members), _toConsumableArray(roomDrag.followers)), current, target);
+            roomDrag.current = target;
+            roomDrag.blockedBy = [];
+            roomDrag.slotSnapped = false;
+          }
+          // Only the dragged unit moves: it is put back into the room and goes onto what it docks to (else into the free slot
+          // place it snapped to), as the drag preview shows it, so docking it re-anchors nothing else. Its guests go with it.
+          var unit = this.getAllPlannerElements().filter(function (element) {
+            var _this24$dragUnit;
+            return element === plannerElement || ((_this24$dragUnit = _this24.dragUnit) === null || _this24$dragUnit === void 0 ? void 0 : _this24$dragUnit.has(element.ElementId));
+          });
+          var followers = unit.filter(function (element) {
+            return _this24.dragFollowers.has(element.ElementId);
+          });
+          var group = unit.filter(function (element) {
+            return !_this24.dragFollowers.has(element.ElementId);
+          });
+          this.dragUnit = undefined;
+          this.dragFollowers = new Set();
+          var roomRule = (roomDrag === null || roomDrag === void 0 ? void 0 : roomDrag.elementId) == elementId && !roomDrag.slotSnapped && (roomDrag.wallMode === 'forced' || roomDrag.rotating);
+          if (roomRule) this.placeGroupInRoom(group, plannerElement, followers);
+          this.snapToDock(plannerElement, unit, autoDockingDistance, !roomDrag);
+          this.dragSlots = undefined;
           var dockablePairs = dockingPointHandlerInst.searchDockableElementsInArea(plannerElement, this.getAllPlannerElements(), autoDockingDistance); //hier kann jetzt ein DP drinnen stehen - docke alle
           if (dockablePairs != null && dockablePairs.size > 0) {
             dockablePairs.forEach(function (dockPair, type) {
-              var targetPlannerElement = _this3.plannerElements.get(dockPair.targetDP.ElementId);
+              var targetPlannerElement = _this24.plannerElements.get(dockPair.targetDP.ElementId);
               if (targetPlannerElement) {
                 dockingPointHandlerInst.tryDockElementDPToDP(plannerElement, targetPlannerElement, dockPair.sourceDP, dockPair.targetDP);
               }
             });
           }
           updateConfig = this.updateAllElementsWorldPos(elementId);
+          if ((roomDrag === null || roomDrag === void 0 ? void 0 : roomDrag.elementId) == elementId) {
+            // The group as released, docked or turned: a wall-bound one goes to its wall, any other inside the room; where a
+            // slot snap put it, it stays.
+            if (!roomDrag.slotSnapped) this.placeGroupInRoom(this.getDockingGroupOf(plannerElement), plannerElement);
+            this.checkCollision(false, elementId);
+            this.roomDrag = undefined;
+          }
           this.updatePlannerPosNr();
           this.updatePlannerBoundingBox();
         }
@@ -1861,7 +3563,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "saveSetPlanner",
     value: function saveSetPlanner() {
-      var _this4 = this;
+      var _this25 = this;
       if (this.plannerElements.size == 0) return null;
       var plannerElements = [];
       this.plannerElements.forEach(function (elem, elemId) {
@@ -1876,13 +3578,18 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           };
           dpArr.push(saveDP);
         }
-        var plannerElement = {
+        var plannerElement = _objectSpread(_objectSpread(_objectSpread({
           elementID: elem.getElementId(),
-          basketID: _this4.set.getBasketId(elem.getElementId()),
-          CatalogCodex: _this4.set.getCatalogCodex(),
-          Codex: _this4.set.getArticleCodex(elem.getElementId()),
+          basketID: _this25.set.getBasketId(elem.getElementId()),
+          CatalogCodex: _this25.set.getCatalogCodex(),
+          Codex: _this25.set.getArticleCodex(elem.getElementId()),
           posNr: elem.PosNr,
-          accNr: elem.IsDockedAccessoire ? elem.AccessoirePosNr : undefined,
+          accNr: elem.IsDockedAccessoire ? elem.AccessoirePosNr : undefined
+        }, elem.PosNrAtEnd ? {
+          posNrAtEnd: true
+        } : {}), elem.Placement ? {
+          placement: elem.Placement
+        } : {}), {}, {
           x: elem.WorldPosCenter.x,
           y: elem.WorldPosCenter.y,
           z: elem.WorldPosCenter.z,
@@ -1891,9 +3598,9 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           height: elem.Height ? elem.Height : -1,
           depth: elem.Depth ? elem.Depth : -1,
           DP: dpArr
-        };
+        });
         if (elem.IsAccessoire) {
-          var parentBasketId = _this4.set.getParentBasketIdOfElementId(elem.getElementId());
+          var parentBasketId = _this25.set.getParentBasketIdOfElementId(elem.getElementId());
           if (parentBasketId != undefined) {
             plannerElement.AccessoireInitParams = {
               RelatedToBasketID: parentBasketId
@@ -1927,7 +3634,7 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "getSetData",
     value: function getSetData(only3DCompatible, useSetPlanner, doShow3DDimensionLines, alternateRenderInfo) {
-      var _this5 = this;
+      var _this26 = this;
       var setId = useSetPlanner ? this.set.getSetId() : 'S1';
       var setData = {
         //ID: "S" + this.plannerID,
@@ -1954,19 +3661,19 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
         setData.IDM3DEnvironment = this.IDM3DEnvironment;
       }
       this.plannerElements.forEach(function (elem, elemId) {
-        var config = _this5.set.getPlannerConfigData(elemId, alternateRenderInfo);
+        var config = _this26.set.getPlannerConfigData(elemId, alternateRenderInfo);
         var elemCfg = config.config;
         var accElements = [];
         if (config.accs && config.accs.length > 0) {
           for (var i = 0; i < config.accs.length; i++) {
-            if (_this5.plannerElements.has(config.accs[i])) {
+            if (_this26.plannerElements.has(config.accs[i])) {
               accElements.push('E' + config.accs[i]);
             }
           }
         }
         if (!only3DCompatible || elemCfg.Model != undefined) {
           var _elemCfg$MOVE;
-          var article = _this5.set.getArticleByElementId(elemId);
+          var article = _this26.set.getArticleByElementId(elemId);
           var elemJson = {
             ID: 'E' + elemId,
             // N: elemCfg.N,
@@ -1996,15 +3703,15 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
           elemJson.H = hash;
           setData.ELE.push(elemJson);
         }
-        var shelfPlannerElements = _this5.set.getShelfPlannerData(elemId);
+        var shelfPlannerElements = _this26.set.getShelfPlannerData(elemId);
         if (shelfPlannerElements) {
           for (var _i5 = 0; _i5 < shelfPlannerElements.length; _i5++) {
             var accessorire = shelfPlannerElements[_i5];
-            var shelfConfig = _this5.set.getShelfPlannerConfigData(accessorire.basketId).config;
+            var shelfConfig = _this26.set.getShelfPlannerConfigData(accessorire.basketId).config;
             var _accElements2 = [];
             if (shelfConfig.accs && shelfConfig.accs.length > 0) {
               for (var j = 0; j < shelfConfig.accs.length; j++) {
-                if (_this5.plannerElements.has(shelfConfig.accs[j])) {
+                if (_this26.plannerElements.has(shelfConfig.accs[j])) {
                   _accElements2.push('E' + shelfConfig.accs[j]);
                 }
               }
@@ -2067,12 +3774,12 @@ var DivaStandardPlanner = /*#__PURE__*/function () {
   }, {
     key: "getPlanningIsComplete",
     value: function getPlanningIsComplete(forceCheck) {
-      var _this6 = this;
+      var _this27 = this;
       var dontCheck = !forceCheck && (this.set.CatalogData.doHideCompletenessWarning || !this.set.CatalogData.doCheckConstructionWarnings);
       var elemNotComplete = false;
       this.plannerElements.forEach(function (plannerElement, key) {
-        var _this6$set$CatalogDat;
-        if (dontCheck && !((_this6$set$CatalogDat = _this6.set.CatalogData.forceConstructionWarningForArticles) !== null && _this6$set$CatalogDat !== void 0 && _this6$set$CatalogDat.includes(plannerElement.ArticleCodex))) return;
+        var _this27$set$CatalogDa;
+        if (dontCheck && !((_this27$set$CatalogDa = _this27.set.CatalogData.forceConstructionWarningForArticles) !== null && _this27$set$CatalogDa !== void 0 && _this27$set$CatalogDa.includes(plannerElement.ArticleCodex))) return;
         if (!elemNotComplete && (plannerElement.getFreeDockingPointsByType('AVL').length > 0 || plannerElement.getFreeDockingPointsByType('AVR').length > 0)) {
           elemNotComplete = true;
         }