@crystaldesign/web-planner-logic 26.13.0-beta.9 → 26.14.0-beta.1

package/build/esm/{ShelfPlanner-fbb7d7dd.js → ShelfPlanner-69cbb2c1.js}

@@ -4,14 +4,15 @@ import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { G as Grid, a as articleHandlerInstance, b as setHandlerInstance } from './index-86463de2.js';
+import { G as Grid, f as familyMembersOf, a as articleHandlerInstance, b as setHandlerInstance } from './index-88148ccc.js';
 import DivaUtils, { DivaError } from '@crystaldesign/diva-utils';
 import '@babel/runtime/helpers/slicedToArray';
 import '@babel/runtime/helpers/objectWithoutProperties';
 import 'axios';
-import '@crystaldesign/planner-2d-core';
-import '@crystaldesign/basket-model';
 import '@babel/runtime/helpers/typeof';
+import '@babel/runtime/helpers/toArray';
+import '@crystaldesign/planner-core';
+import '@crystaldesign/basket-model';
 import 'fast-xml-parser';
 import '@babel/runtime/helpers/possibleConstructorReturn';
 import '@babel/runtime/helpers/getPrototypeOf';
@@ -20,9 +21,19 @@ import '@babel/runtime/helpers/wrapNativeSuper';
 import '@crystaldesign/basket-handler';
 import 'socket.io-client';
 
+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');
+
+/** The accessoire really went into the cell - not a rejected fit, whose article is deleted again. */
+function isPlaced(result) {
+  return result !== false && result.index !== undefined && !!result.accessoire && result.type !== 'doesNotFit' && !result.type.startsWith('notAllowed');
+}
+
+/** Values the parents pass on to their accessoires with their global options, per basketId of the accessoire. */
 var ShelfPlanner = /*#__PURE__*/function () {
   function ShelfPlanner(data, article) {
     _classCallCheck(this, ShelfPlanner);
@@ -64,8 +75,12 @@ var ShelfPlanner = /*#__PURE__*/function () {
     _defineProperty(this, "shelfDebugSeq", 0);
     //accessoires of grids that were cleared by a grid rule, per gridIndex and the HeightGridCellCountOnRule entry the grid
     //ran as. They get placed again when the grid becomes active again under the same entry - eg a shelf that is configured
-    //from 100cm to 50cm and back keeps its accessoires. A grid that comes back under another entry starts with that entry's initAcc
+    //from 100cm to 50cm and back keeps its accessoires. A grid that comes back under another entry starts with that entry's
+    //initAcc; with rtv-next it first takes what the change cleared (placeTransferredAccessoires)
     _defineProperty(this, "stashedAccessoires", {});
+    //a memory is outdated once something was edited by hand after it was taken (the init jump of a shelf edits nothing)
+    _defineProperty(this, "editEpoch", 0);
+    _defineProperty(this, "stashEpochs", {});
     this.article = article;
     this.restorePending = !!article.shelfPlanData;
     this.disableCellsByElement = data.DisableCells;
@@ -115,6 +130,16 @@ var ShelfPlanner = /*#__PURE__*/function () {
         }
       }
     }
+
+    /**
+     * True when an accessoire with this codex can be planned for free on this shelf (an initAcc with noPrice, eg the first
+     * Kleiderstange of a Jutzler element).
+     */
+  }, {
+    key: "canBeFree",
+    value: function canBeFree(articleCodex) {
+      return this.freeArticlesPossible[articleCodex] !== undefined;
+    }
   }, {
     key: "IsVisible",
     get: function get() {
@@ -190,7 +215,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
     key: "onConfigChanged",
     value: (function () {
       var _onConfigChanged = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(variantValues) {
-        var newHeightSet, gridsTodos, ruleIndexesBefore, i, _i, grid, _i2, _i3, _grid, grids, _i4, _grid2$DisableCellsBy, _grid2;
+        var newHeightSet, gridsTodos, ruleIndexesBefore, i, _i, grid, clearedNow, _i2, stashed, _i3, _grid, own, carryOver, grids, _i4, _grid2$DisableCellsBy, _grid2;
         return _regeneratorRuntime.wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -232,39 +257,42 @@ var ShelfPlanner = /*#__PURE__*/function () {
               _context2.next = 5;
               break;
             case 14:
+              //what this change clears, per grid - carried over into a grid that comes back without an up-to-date memory of its own
+              clearedNow = new Map(); //first delete all disables grids then init all the new ones
               _i2 = 0;
-            case 15:
+            case 16:
               if (!(_i2 < gridsTodos.length)) {
-                _context2.next = 24;
+                _context2.next = 26;
                 break;
               }
               if (gridsTodos[_i2].length) {
-                _context2.next = 18;
+                _context2.next = 19;
                 break;
               }
-              return _context2.abrupt("continue", 21);
-            case 18:
+              return _context2.abrupt("continue", 23);
+            case 19:
               //remember the accessoires before they get deleted, so they can be placed again when the grid becomes active again
-              this.stashAccessoiresOfGrid(_i2, ruleIndexesBefore[_i2]);
-              _context2.next = 21;
+              stashed = this.stashAccessoiresOfGrid(_i2, ruleIndexesBefore[_i2]);
+              if (!this.isOnlyInitContent(this.grids[_i2], stashed)) clearedNow.set(_i2, stashed);
+              _context2.next = 23;
               return this.grids[_i2].deleteAllAccOfGrid();
-            case 21:
+            case 23:
               _i2++;
-              _context2.next = 15;
+              _context2.next = 16;
               break;
-            case 24:
+            case 26:
               _i3 = 0;
-            case 25:
+            case 27:
               if (!(_i3 < gridsTodos.length)) {
-                _context2.next = 41;
+                _context2.next = 65;
                 break;
               }
               if (gridsTodos[_i3].length) {
-                _context2.next = 28;
+                _context2.next = 30;
                 break;
               }
-              return _context2.abrupt("continue", 38);
-            case 28:
+              return _context2.abrupt("continue", 62);
+            case 30:
               if (gridsTodos[_i3].includes('heightGridRule')) {
                 this.creatNewGrid(_i3);
                 newHeightSet = true;
@@ -272,58 +300,109 @@ var ShelfPlanner = /*#__PURE__*/function () {
               //read the grid after a possible recreate, the replaced one is not the grid that gets filled
               _grid = this.grids[_i3];
               if (!((gridsTodos[_i3].includes('heightGridRule') || gridsTodos[_i3].includes('disableGridRule')) && !_grid.DisabledByRule)) {
-                _context2.next = 38;
+                _context2.next = 62;
                 break;
               }
               if (!this.restorePending) {
-                _context2.next = 33;
+                _context2.next = 35;
                 break;
               }
-              return _context2.abrupt("continue", 38);
-            case 33:
-              _context2.next = 35;
-              return this.placeStashedAccessoiresOfGrid(_i3);
+              return _context2.abrupt("continue", 62);
             case 35:
-              if (_context2.sent) {
-                _context2.next = 38;
+              //the grid's own memory beats the initAcc while nothing was edited since, else another grid's newer content is carried over
+              own = this.takeStashOfGrid(_i3); //only rtv-next carries content over between grids, otherwise the memory is restored as is
+              carryOver = this.article.set.CatalogData.divaUseRtvNext;
+              _context2.t0 = own && (!own.outdated || !carryOver);
+              if (!_context2.t0) {
+                _context2.next = 42;
+                break;
+              }
+              _context2.next = 41;
+              return this.placeStashedAccessoiresInGrid(_i3, own.accessoires);
+            case 41:
+              _context2.t0 = _context2.sent;
+            case 42:
+              if (!_context2.t0) {
+                _context2.next = 45;
+                break;
+              }
+              clearedNow["delete"](_i3);
+              return _context2.abrupt("continue", 62);
+            case 45:
+              _context2.t1 = carryOver;
+              if (!_context2.t1) {
+                _context2.next = 50;
+                break;
+              }
+              _context2.next = 49;
+              return this.placeTransferredAccessoires(_i3, clearedNow);
+            case 49:
+              _context2.t1 = _context2.sent;
+            case 50:
+              if (!_context2.t1) {
+                _context2.next = 54;
+                break;
+              }
+              _context2.next = 53;
+              return this.initAccList(_i3);
+            case 53:
+              return _context2.abrupt("continue", 62);
+            case 54:
+              if (!(carryOver && own !== null && own !== void 0 && own.outdated)) {
+                _context2.next = 60;
                 break;
               }
-              _context2.next = 38;
+              this.logShelfDebug({
+                phase: 'configChanged',
+                action: 'stashOutdatedRestored',
+                gridIndex: _i3,
+                detail: 'edited since, but nothing to carry over'
+              });
+              _context2.next = 58;
+              return this.placeStashedAccessoiresInGrid(_i3, own.accessoires);
+            case 58:
+              if (!_context2.sent) {
+                _context2.next = 60;
+                break;
+              }
+              return _context2.abrupt("continue", 62);
+            case 60:
+              _context2.next = 62;
               return this.initAccList(_i3);
-            case 38:
+            case 62:
               _i3++;
-              _context2.next = 25;
+              _context2.next = 27;
               break;
-            case 41:
+            case 65:
               if (!(!newHeightSet && Object.keys(variantValues).length)) {
-                _context2.next = 52;
+                _context2.next = 76;
                 break;
               }
               grids = this.activeGrids;
               _i4 = 0;
-            case 44:
+            case 68:
               if (!(_i4 < grids.length)) {
-                _context2.next = 52;
+                _context2.next = 76;
                 break;
               }
               _grid2 = grids[_i4];
               if (!((_grid2$DisableCellsBy = _grid2.DisableCellsByMeasures) !== null && _grid2$DisableCellsBy !== void 0 && _grid2$DisableCellsBy.options.find(function (o) {
                 return Object.keys(variantValues).includes('OPT' + o.opt);
               }) || !!_grid2.disableCellsByRules)) {
-                _context2.next = 49;
+                _context2.next = 73;
                 break;
               }
               newHeightSet = true;
-              return _context2.abrupt("break", 52);
-            case 49:
+              return _context2.abrupt("break", 76);
+            case 73:
               _i4++;
-              _context2.next = 44;
+              _context2.next = 68;
               break;
-            case 52:
+            case 76:
               if (newHeightSet) {
                 this.updateDisabledCells();
               }
-            case 53:
+            case 77:
             case "end":
               return _context2.stop();
           }
@@ -350,9 +429,146 @@ var ShelfPlanner = /*#__PURE__*/function () {
   }, {
     key: "stashAccessoiresOfGrid",
     value: function stashAccessoiresOfGrid(gridIndex, ruleIndex) {
-      var stashedAccessoires = this.collectAccessoiresToStash(this.grids[gridIndex]);
-      if (!stashedAccessoires.length) return;
-      this.stashedAccessoires[this.stashKey(gridIndex, ruleIndex)] = stashedAccessoires;
+      var stashedAccessoires = this.collectAccessoiresToStash(this.grids[gridIndex], this.valuesPassedOnByParents());
+      if (!stashedAccessoires.length) return stashedAccessoires;
+      var stashKey = this.stashKey(gridIndex, ruleIndex);
+      this.stashedAccessoires[stashKey] = stashedAccessoires;
+      this.stashEpochs[stashKey] = this.editEpoch;
+      return stashedAccessoires;
+    }
+
+    /** A hand edit of this shelf or of an accessoire inside it (add, delete, move) - outdates the memories taken before. */
+  }, {
+    key: "noteUserEdit",
+    value: function noteUserEdit() {
+      var _this$article$accesso;
+      this.editEpoch++;
+      (_this$article$accesso = this.article.accessoireParentArticle) === null || _this$article$accesso === void 0 || (_this$article$accesso = _this$article$accesso.shelfPlanner) === null || _this$article$accesso === void 0 || _this$article$accesso.noteUserEdit();
+    }
+
+    /** The hand edit noted last changed nothing (eg the drop did not fit) - the memories taken before it stay up to date. */
+  }, {
+    key: "withdrawUserEdit",
+    value: function withdrawUserEdit() {
+      var _this$article$accesso2;
+      this.editEpoch--;
+      (_this$article$accesso2 = this.article.accessoireParentArticle) === null || _this$article$accesso2 === void 0 || (_this$article$accesso2 = _this$article$accesso2.shelfPlanner) === null || _this$article$accesso2 === void 0 || _this$article$accesso2.withdrawUserEdit();
+    }
+
+    /**
+     * True when a grid held nothing but its own initAcc - eg the Kleiderstange of a shelf that only passes through another
+     * width while it initializes. Such content is not carried over, the other grid starts with its own initAcc.
+     */
+  }, {
+    key: "isOnlyInitContent",
+    value: function isOnlyInitContent(grid, stashed) {
+      return stashed.every(function (acc) {
+        var _grid$InitAccArr;
+        return (_grid$InitAccArr = grid.InitAccArr) === null || _grid$InitAccArr === void 0 ? void 0 : _grid$InitAccArr.some(function (init) {
+          return init.Codex === acc.articleCodex && init.initRH.includes(acc.cellIndex);
+        });
+      });
+    }
+
+    /**
+     * Fallback for a grid without an up-to-date memory of its own: places what this change cleared from it, else from a grid
+     * the change switched off, mapped by family (eg the 50cm tablar comes back as the 100cm one). The cleared grid keeps its
+     * own memory.
+     * @param cleared what this change cleared, per grid - a placed source is taken out
+     * @returns how many were placed
+     */
+  }, {
+    key: "placeTransferredAccessoires",
+    value: (function () {
+      var _placeTransferredAccessoires = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(gridIndex, cleared) {
+        var _this = this;
+        var sources, _iterator, _step, source, accessoires, placed;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              //a grid that stays active keeps its content for itself
+              sources = [gridIndex].concat(_toConsumableArray(_toConsumableArray(cleared.keys()).filter(function (source) {
+                return source !== gridIndex && _this.grids[source].DisabledByRule;
+              })));
+              _iterator = _createForOfIteratorHelper(sources);
+              _context3.prev = 2;
+              _iterator.s();
+            case 4:
+              if ((_step = _iterator.n()).done) {
+                _context3.next = 18;
+                break;
+              }
+              source = _step.value;
+              accessoires = cleared.get(source);
+              if (accessoires) {
+                _context3.next = 9;
+                break;
+              }
+              return _context3.abrupt("continue", 16);
+            case 9:
+              _context3.next = 11;
+              return this.placeStashedAccessoiresInGrid(gridIndex, accessoires, true);
+            case 11:
+              placed = _context3.sent;
+              if (placed) {
+                _context3.next = 14;
+                break;
+              }
+              return _context3.abrupt("continue", 16);
+            case 14:
+              cleared["delete"](source);
+              return _context3.abrupt("return", placed);
+            case 16:
+              _context3.next = 4;
+              break;
+            case 18:
+              _context3.next = 23;
+              break;
+            case 20:
+              _context3.prev = 20;
+              _context3.t0 = _context3["catch"](2);
+              _iterator.e(_context3.t0);
+            case 23:
+              _context3.prev = 23;
+              _iterator.f();
+              return _context3.finish(23);
+            case 26:
+              return _context3.abrupt("return", 0);
+            case 27:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[2, 20, 23, 26]]);
+      }));
+      function placeTransferredAccessoires(_x3, _x4) {
+        return _placeTransferredAccessoires.apply(this, arguments);
+      }
+      return placeTransferredAccessoires;
+    }() /** How many accessoires of `articleCodex` or of its family the grid holds, each counted in the cell it starts in. */)
+  }, {
+    key: "countPlacedOfFamily",
+    value: function countPlacedOfFamily(grid, articleCodex) {
+      var codexes = [articleCodex].concat(_toConsumableArray(familyMembersOf(articleCodex, this.article.CatalogData.allCatalogArticles)));
+      var startsHere = function startsHere(cell) {
+        return cell.InUse === cell.Index && !cell.OnlyPlaceHolder;
+      };
+      return grid.Cells.filter(function (cell) {
+        var _cell$Article$article, _cell$Article;
+        return startsHere(cell) && codexes.includes((_cell$Article$article = (_cell$Article = cell.Article) === null || _cell$Article === void 0 ? void 0 : _cell$Article.articleCodex) !== null && _cell$Article$article !== void 0 ? _cell$Article$article : '');
+      }).length;
+    }
+
+    /** The article itself when the grid allows it, else the members of its family the grid allows. */
+  }, {
+    key: "familyCandidates",
+    value: function familyCandidates(grid, articleCodex) {
+      var allowed = grid.getAllArticleRelations();
+      var family = familyMembersOf(articleCodex, this.article.CatalogData.allCatalogArticles).filter(function (codex) {
+        return codex !== articleCodex;
+      });
+      return [articleCodex].concat(_toConsumableArray(family)).filter(function (codex) {
+        return allowed.includes(codex);
+      });
     }
 
     /** The memory is per grid and per HeightGridCellCountOnRule entry, false when the grid runs without a matching entry. */
@@ -365,29 +581,29 @@ var ShelfPlanner = /*#__PURE__*/function () {
     /**
      * Collects an accessoire of every cell it starts in, including the accessoires of the accessoire itself
      * (eg the drawers of an EINBAU), because those get deleted with their parent as well.
+     * @param parentInheritedValues values the parents of the article pass on to the accessoires, per basketId
      */
   }, {
     key: "collectAccessoiresToStash",
-    value: function collectAccessoiresToStash(grid) {
+    value: function collectAccessoiresToStash(grid, parentInheritedValues) {
       var stashedAccessoires = [];
+      var inheritedValues = ShelfPlanner.addValuesPassedOnBy(this.article, parentInheritedValues);
       for (var i = 0; i < grid.Cells.length; i++) {
+        var _accessoire$shelfPlan, _accessoire$shelfPlan2, _inheritedValues$acce;
         var cell = grid.Cells[i];
         var accessoire = cell.Article;
         if (cell.InUse !== i || !accessoire) continue;
 
         //the accessoire can be a shelf itself (eg an EINBAU), its own accessoires are grouped by its own grids
-        var accessoires = {};
-        var accessoireShelfPlanner = accessoire.shelfPlanner;
-        for (var j = 0; j < ((_accessoireShelfPlann = accessoireShelfPlanner === null || accessoireShelfPlanner === void 0 ? void 0 : accessoireShelfPlanner.grids.length) !== null && _accessoireShelfPlann !== void 0 ? _accessoireShelfPlann : 0); j++) {
-          var _accessoireShelfPlann;
-          var accessoireGrid = accessoireShelfPlanner.grids[j];
-          var accessoiresOfGrid = accessoireShelfPlanner.collectAccessoiresToStash(accessoireGrid);
-          if (accessoiresOfGrid.length) {
-            accessoires[accessoireGrid.ShelfIndex] = {
-              ruleIndex: accessoireGrid.CurrentLoadedRuleIndex,
-              accessoires: accessoiresOfGrid
-            };
-          }
+        var accessoires = (_accessoire$shelfPlan = (_accessoire$shelfPlan2 = accessoire.shelfPlanner) === null || _accessoire$shelfPlan2 === void 0 ? void 0 : _accessoire$shelfPlan2.collectOwnAccessoiresToStash(inheritedValues)) !== null && _accessoire$shelfPlan !== void 0 ? _accessoire$shelfPlan : {};
+
+        //a value the accessoire only took over from the parent is not remembered: placed again, the accessoire takes over the
+        //parent's value of that time, the parent may have changed it in between
+        var variantValues = accessoire.VariantValues;
+        var inherited = (_inheritedValues$acce = inheritedValues[accessoire.basketId]) !== null && _inheritedValues$acce !== void 0 ? _inheritedValues$acce : {};
+        for (var _i5 = 0, _Object$keys = Object.keys(inherited); _i5 < _Object$keys.length; _i5++) {
+          var codex = _Object$keys[_i5];
+          if (variantValues[codex] === inherited[codex]) delete variantValues[codex];
         }
         stashedAccessoires.push({
           articleCodex: accessoire.articleCodex,
@@ -395,7 +611,8 @@ var ShelfPlanner = /*#__PURE__*/function () {
           noMove: cell.NoMove,
           noDelete: cell.NoDelete,
           quantity: accessoire.quantity,
-          variantValues: accessoire.VariantValues,
+          variantValues: variantValues,
+          inheritedValues: inherited,
           accessoires: accessoires
         });
       }
@@ -403,133 +620,231 @@ var ShelfPlanner = /*#__PURE__*/function () {
     }
 
     /**
-     * Places the accessoires remembered for the rule entry the grid runs now back into their cells.
-     * @param gridIndex grid that became active again
-     * @returns how many accessoires were placed - 0 means the grid is still empty and needs its initAcc
+     * The values the parents of the article pass on to their accessoires right now, per basketId. A stash can start at an
+     * accessoire that is a shelf itself (eg an EINBAU whose own grid gets rebuilt), its accessoires inherit the values of
+     * all its parents as well (eg the cabinet colour).
      */
   }, {
-    key: "placeStashedAccessoiresOfGrid",
-    value: (function () {
-      var _placeStashedAccessoiresOfGrid = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(gridIndex) {
-        var stashKey, stashedAccessoires;
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              //a recreated grid already runs its new rule entry, only accessoires planned under that entry belong into it
-              stashKey = this.stashKey(gridIndex, this.grids[gridIndex].CurrentLoadedRuleIndex);
-              stashedAccessoires = this.stashedAccessoires[stashKey];
-              if (stashedAccessoires !== null && stashedAccessoires !== void 0 && stashedAccessoires.length) {
-                _context3.next = 4;
-                break;
-              }
-              return _context3.abrupt("return", 0);
-            case 4:
-              //remove it first, a reconfiguration triggered by placing them must not place them a second time
-              delete this.stashedAccessoires[stashKey];
-              _context3.next = 7;
-              return this.placeStashedAccessoiresInGrid(gridIndex, stashedAccessoires);
-            case 7:
-              return _context3.abrupt("return", _context3.sent);
-            case 8:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function placeStashedAccessoiresOfGrid(_x3) {
-        return _placeStashedAccessoiresOfGrid.apply(this, arguments);
+    key: "valuesPassedOnByParents",
+    value: function valuesPassedOnByParents() {
+      var parents = [];
+      for (var parent = this.article.accessoireParentArticle; parent; parent = parent.accessoireParentArticle) parents.unshift(parent);
+      return parents.reduce(function (inheritedValues, parent) {
+        return ShelfPlanner.addValuesPassedOnBy(parent, inheritedValues);
+      }, {});
+    }
+
+    /**
+     * Adds the values the article passes on to its accessoires with its global options right now (eg the gardenhouse colour of
+     * the door) on top of the ones its parents pass on (eg the cabinet colour of the drawers in an EINBAU).
+     * @param parentInheritedValues values the parents of the article pass on, per basketId
+     * @returns the values passed on per basketId, a new object
+     */
+  }, {
+    key: "collectOwnAccessoiresToStash",
+    value: /** The accessoires of all grids of this shelfplanner, grouped by grid - eg the drawers of an EINBAU that gets replaced. */
+    function collectOwnAccessoiresToStash() {
+      var parentInheritedValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.valuesPassedOnByParents();
+      var accessoires = {};
+      for (var j = 0; j < this.grids.length; j++) {
+        var grid = this.grids[j];
+        var accessoiresOfGrid = this.collectAccessoiresToStash(grid, parentInheritedValues);
+        if (accessoiresOfGrid.length) accessoires[grid.ShelfIndex] = {
+          ruleIndex: grid.CurrentLoadedRuleIndex,
+          accessoires: accessoiresOfGrid
+        };
       }
-      return placeStashedAccessoiresOfGrid;
-    }() /** Places stashed accessoires that are grouped by gridIndex - used for the accessoires of an accessoire. */)
+      return accessoires;
+    }
+
+    /**
+     * Takes the accessoires remembered for the rule entry the grid runs now out of the memory.
+     * @param gridIndex grid that became active again
+     * @returns the remembered accessoires and whether something was edited by hand since they were taken
+     */
+  }, {
+    key: "takeStashOfGrid",
+    value: function takeStashOfGrid(gridIndex) {
+      //a recreated grid already runs its new rule entry, only accessoires planned under that entry belong into it
+      var stashKey = this.stashKey(gridIndex, this.grids[gridIndex].CurrentLoadedRuleIndex);
+      var accessoires = this.stashedAccessoires[stashKey];
+      var outdated = this.stashEpochs[stashKey] !== this.editEpoch;
+      //remove it first, a reconfiguration triggered by placing them must not place them a second time
+      delete this.stashedAccessoires[stashKey];
+      delete this.stashEpochs[stashKey];
+      return accessoires !== null && accessoires !== void 0 && accessoires.length ? {
+        accessoires: accessoires,
+        outdated: outdated
+      } : undefined;
+    }
+
+    /**
+     * Places stashed accessoires that are grouped by gridIndex - used for the accessoires of an accessoire.
+     * @param mapByFamily the accessoire was replaced by another member of its family: its grids run their own rule entry, and
+     * every accessoire is placed as itself or as the family member the grid allows
+     */
   }, {
     key: "placeStashedAccessoiresByGrid",
     value: (function () {
       var _placeStashedAccessoiresByGrid = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(stashedAccessoires) {
-        var gridIndexes, i, gridIndex, grid, stashed;
+        var mapByFamily,
+          gridIndexes,
+          i,
+          gridIndex,
+          grid,
+          stashed,
+          _args4 = arguments;
         return _regeneratorRuntime.wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
+              mapByFamily = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : false;
               gridIndexes = Object.keys(stashedAccessoires);
               i = 0;
-            case 2:
+            case 3:
               if (!(i < gridIndexes.length)) {
-                _context4.next = 18;
+                _context4.next = 19;
                 break;
               }
               gridIndex = Number(gridIndexes[i]);
               grid = this.getGridByIndex(gridIndex);
               stashed = stashedAccessoires[gridIndex]; //the accessoire was created new, its grids run their own rule entry with that entry's initAcc in place. A grid that
               //runs another entry than the remembered accessoires were planned under keeps them
-              if (!(!grid || grid.CurrentLoadedRuleIndex !== stashed.ruleIndex)) {
-                _context4.next = 8;
+              if (!(!grid || !mapByFamily && grid.CurrentLoadedRuleIndex !== stashed.ruleIndex)) {
+                _context4.next = 9;
                 break;
               }
-              return _context4.abrupt("continue", 15);
-            case 8:
-              _context4.next = 10;
+              return _context4.abrupt("continue", 16);
+            case 9:
+              _context4.next = 11;
               return grid.deleteAllAccOfGrid();
-            case 10:
-              _context4.next = 12;
-              return this.placeStashedAccessoiresInGrid(gridIndex, stashed.accessoires);
-            case 12:
+            case 11:
+              _context4.next = 13;
+              return this.placeStashedAccessoiresInGrid(gridIndex, stashed.accessoires, mapByFamily);
+            case 13:
               if (_context4.sent) {
-                _context4.next = 15;
+                _context4.next = 16;
                 break;
               }
-              _context4.next = 15;
+              _context4.next = 16;
               return this.initAccList(gridIndex);
-            case 15:
+            case 16:
               i++;
-              _context4.next = 2;
+              _context4.next = 3;
               break;
-            case 18:
+            case 19:
             case "end":
               return _context4.stop();
           }
         }, _callee4, this);
       }));
-      function placeStashedAccessoiresByGrid(_x4) {
+      function placeStashedAccessoiresByGrid(_x5) {
         return _placeStashedAccessoiresByGrid.apply(this, arguments);
       }
       return placeStashedAccessoiresByGrid;
-    }() /** @returns how many of the stashed accessoires were placed */)
+    }()
+    /**
+     * @param mapByFamily an accessoire the grid does not allow is placed as the member of its family the grid allows
+     * @returns how many of the stashed accessoires were placed
+     */
+    )
   }, {
     key: "placeStashedAccessoiresInGrid",
     value: (function () {
       var _placeStashedAccessoiresInGrid = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(gridIndex, stashedAccessoires) {
-        var placedAccessoires, grid, i, stashed, result, fitResult, accessoire;
+        var mapByFamily,
+          placedAccessoires,
+          grid,
+          i,
+          stashed,
+          result,
+          _iterator2,
+          _step2,
+          articleCodex,
+          fitResult,
+          accessoire,
+          replaced,
+          variantValues,
+          _args5 = arguments;
         return _regeneratorRuntime.wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
+              mapByFamily = _args5.length > 2 && _args5[2] !== undefined ? _args5[2] : false;
               placedAccessoires = 0;
               grid = this.getGridByIndex(gridIndex);
               if (grid) {
-                _context5.next = 4;
+                _context5.next = 5;
                 break;
               }
               return _context5.abrupt("return", placedAccessoires);
-            case 4:
-              i = 0;
             case 5:
+              i = 0;
+            case 6:
               if (!(i < stashedAccessoires.length)) {
-                _context5.next = 28;
+                _context5.next = 53;
                 break;
               }
               stashed = stashedAccessoires[i];
-              grid.ActAccessoire = stashed.articleCodex;
-              _context5.next = 10;
+              result = false;
+              _iterator2 = _createForOfIteratorHelper(mapByFamily ? this.familyCandidates(grid, stashed.articleCodex) : [stashed.articleCodex]);
+              _context5.prev = 10;
+              _iterator2.s();
+            case 12:
+              if ((_step2 = _iterator2.n()).done) {
+                _context5.next = 23;
+                break;
+              }
+              articleCodex = _step2.value;
+              grid.ActAccessoire = articleCodex;
+              _context5.next = 17;
               return setHandlerInstance.addAccessorieOnShelfPlanner(this.article.set, gridIndex, stashed.cellIndex, this.article.basketId, {
                 noMove: stashed.noMove,
                 noDelete: stashed.noDelete,
-                byInit: true
+                byInit: true,
+                onlyOfferedCells: mapByFamily
               });
-            case 10:
+            case 17:
               result = _context5.sent;
               grid.ActAccessoire = undefined;
-              fitResult = result === false || result.index === undefined ? undefined : result;
+              if (!isPlaced(result)) {
+                _context5.next = 21;
+                break;
+              }
+              return _context5.abrupt("break", 23);
+            case 21:
+              _context5.next = 12;
+              break;
+            case 23:
+              _context5.next = 28;
+              break;
+            case 25:
+              _context5.prev = 25;
+              _context5.t0 = _context5["catch"](10);
+              _iterator2.e(_context5.t0);
+            case 28:
+              _context5.prev = 28;
+              _iterator2.f();
+              return _context5.finish(28);
+            case 31:
+              //a failed fit still returns its result, with the temporary article already deleted
+              fitResult = mapByFamily ? isPlaced(result) ? result : undefined : result === false || result.index === undefined ? undefined : result;
               accessoire = fitResult === null || fitResult === void 0 ? void 0 : fitResult.accessoire;
+              if (!(mapByFamily && (!fitResult || !accessoire))) {
+                _context5.next = 36;
+                break;
+              }
+              //carrying over is a best effort - what has no fitting family member in this grid is left out
+              this.logShelfDebug({
+                phase: 'configChanged',
+                action: 'accessoryNotTransferred',
+                gridIndex: gridIndex,
+                cellIndex: stashed.cellIndex,
+                articleCodex: stashed.articleCodex,
+                detail: 'no member of its family fits into this grid'
+              });
+              return _context5.abrupt("continue", 50);
+            case 36:
               if (!(!fitResult || !accessoire)) {
-                _context5.next = 17;
+                _context5.next = 39;
                 break;
               }
               LOG.error(new DivaError('shelfaccessoire of a switched off grid does not fit anymore and gets dropped', {
@@ -543,50 +858,91 @@ var ShelfPlanner = /*#__PURE__*/function () {
                   parentBasketId: this.article.basketId
                 }
               }));
-              return _context5.abrupt("continue", 25);
-            case 17:
+              return _context5.abrupt("continue", 50);
+            case 39:
               accessoire.quantity = stashed.quantity;
               placedAccessoires++;
-              if (!Object.keys(stashed.variantValues).length) {
-                _context5.next = 22;
+              replaced = accessoire.articleCodex !== stashed.articleCodex;
+              if (mapByFamily) this.logShelfDebug({
+                phase: 'configChanged',
+                action: 'accessoryTransferred',
+                gridIndex: gridIndex,
+                cellIndex: stashed.cellIndex,
+                articleCodex: accessoire.articleCodex,
+                detail: replaced ? "as family member of ".concat(stashed.articleCodex) : 'same article'
+              });
+              variantValues = this.valuesToPlaceAgain(stashed, accessoire);
+              if (!Object.keys(variantValues).length) {
+                _context5.next = 47;
                 break;
               }
-              _context5.next = 22;
-              return articleHandlerInstance.updateCfgValues(accessoire, stashed.variantValues, {});
-            case 22:
+              _context5.next = 47;
+              return articleHandlerInstance.updateCfgValues(accessoire, variantValues, {});
+            case 47:
               if (!accessoire.shelfPlanner) {
-                _context5.next = 25;
+                _context5.next = 50;
                 break;
               }
-              _context5.next = 25;
-              return accessoire.shelfPlanner.placeStashedAccessoiresByGrid(stashed.accessoires);
-            case 25:
+              _context5.next = 50;
+              return accessoire.shelfPlanner.placeStashedAccessoiresByGrid(stashed.accessoires, mapByFamily || replaced);
+            case 50:
               i++;
-              _context5.next = 5;
+              _context5.next = 6;
               break;
-            case 28:
+            case 53:
               return _context5.abrupt("return", placedAccessoires);
-            case 29:
+            case 54:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this);
+        }, _callee5, this, [[10, 25, 28, 31]]);
       }));
-      function placeStashedAccessoiresInGrid(_x5, _x6) {
+      function placeStashedAccessoiresInGrid(_x6, _x7) {
         return _placeStashedAccessoiresInGrid.apply(this, arguments);
       }
       return placeStashedAccessoiresInGrid;
     }()
+    /**
+     * The remembered values of a stashed accessoire to set on the accessoire that was placed for it. A value of its own (eg an
+     * anthracite door) does not come back when the parent passes on another value than at stash time (eg the gardenhouse turned
+     * dark grey): an accessoire that stays in place takes over the parent's new value as well (updateAccessoriesFromGlobalOption).
+     * @param accessoire the accessoire placed for the stashed one, the values the parents pass on to it now are looked up by its basketId
+     */
+    )
+  }, {
+    key: "valuesToPlaceAgain",
+    value: function valuesToPlaceAgain(stashed, accessoire) {
+      var _ShelfPlanner$addValu;
+      var variantValues = _objectSpread({}, stashed.variantValues);
+      var ownInheritableCodices = Object.keys(stashed.inheritedValues).filter(function (codex) {
+        return codex in variantValues;
+      });
+      if (!ownInheritableCodices.length) return variantValues;
+      var inheritedNow = (_ShelfPlanner$addValu = ShelfPlanner.addValuesPassedOnBy(this.article, this.valuesPassedOnByParents())[accessoire.basketId]) !== null && _ShelfPlanner$addValu !== void 0 ? _ShelfPlanner$addValu : {};
+      var _iterator3 = _createForOfIteratorHelper(ownInheritableCodices),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var codex = _step3.value;
+          if (inheritedNow[codex] !== undefined && inheritedNow[codex] !== stashed.inheritedValues[codex]) delete variantValues[codex];
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return variantValues;
+    }
+
     /**
      * runs through the InitAccArr and initialized all the accessoires eg: Kleiderstange gets placed
      * if the replaceFromParent == true it removed the same article from the parent shelfplanner if one is found  eg: Kleiderstange gets removed from schrank when the T-Sück gets initialized
      */
-    )
   }, {
     key: "initAccList",
     value: (function () {
       var _initAccList = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(gridIndex) {
-        var grids, i, grid, j, initAcc, k, _this$article$accesso, shelfId, accessoires, _accessoireToDelete$s, accessoireToDelete, rh;
+        var grids, i, grid, heldByFamily, j, _this$article$Catalog, _this$article$Catalog2, _heldByFamily$get, initAcc, family, held, placed, k, parentIsReal, _this$article$accesso3, shelfId, accessoires, _accessoireToDelete$s, accessoireToDelete, rh;
         return _regeneratorRuntime.wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
@@ -594,7 +950,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
               i = 0;
             case 2:
               if (!(i < grids.length)) {
-                _context6.next = 37;
+                _context6.next = 43;
                 break;
               }
               grid = grids[i];
@@ -602,25 +958,31 @@ var ShelfPlanner = /*#__PURE__*/function () {
                 _context6.next = 6;
                 break;
               }
-              return _context6.abrupt("continue", 34);
+              return _context6.abrupt("continue", 40);
             case 6:
               if (grid.InitAccArr) {
                 _context6.next = 8;
                 break;
               }
-              return _context6.abrupt("continue", 34);
+              return _context6.abrupt("continue", 40);
             case 8:
+              //only tops up: what the grid held of a family before (eg a carried over Kleiderstange in another cell) counts once
+              heldByFamily = new Map();
               j = 0;
-            case 9:
+            case 10:
               if (!(j < grid.InitAccArr.length)) {
-                _context6.next = 34;
+                _context6.next = 40;
                 break;
               }
               initAcc = grid.InitAccArr[j];
-              k = 0;
-            case 12:
+              family = (_this$article$Catalog = (_this$article$Catalog2 = this.article.CatalogData.allCatalogArticles[initAcc.Codex]) === null || _this$article$Catalog2 === void 0 ? void 0 : _this$article$Catalog2.accessoireFamily) !== null && _this$article$Catalog !== void 0 ? _this$article$Catalog : initAcc.Codex;
+              held = (_heldByFamily$get = heldByFamily.get(family)) !== null && _heldByFamily$get !== void 0 ? _heldByFamily$get : this.countPlacedOfFamily(grid, initAcc.Codex);
+              placed = Math.min(held, initAcc.initRH.length);
+              heldByFamily.set(family, held - placed);
+              k = placed;
+            case 17:
               if (!(k < initAcc.initRH.length)) {
-                _context6.next = 31;
+                _context6.next = 37;
                 break;
               }
               grid.ActAccessoire = initAcc.Codex;
@@ -632,56 +994,58 @@ var ShelfPlanner = /*#__PURE__*/function () {
                 articleCodex: initAcc.Codex,
                 detail: 'from InitAccArr — a missing matching accessoryPlaced entry right after means the init placement failed'
               });
-              _context6.next = 17;
+              _context6.next = 22;
               return setHandlerInstance.addAccessorieOnShelfPlanner(this.article.set, grid.ShelfIndex, initAcc.initRH[k], grid.basketId, {
                 noMove: initAcc.noMove,
                 noDelete: initAcc.noDelete,
                 byInit: true
               });
-            case 17:
-              if (!initAcc.replaceFromParent) {
-                _context6.next = 27;
+            case 22:
+              //UseCase Atlantis Kleiderstange gets deleted on parent - not by a dry run, its parent is the real shelf it previews in
+              parentIsReal = !setHandlerInstance.isDryRunArticle(this.article.accessoireParentArticle);
+              if (!(initAcc.replaceFromParent && !(setHandlerInstance.isDryRunArticle(this.article) && parentIsReal))) {
+                _context6.next = 33;
                 break;
               }
               shelfId = this.getShelfParentShelfId();
-              if (!(shelfId && (_this$article$accesso = this.article.accessoireParentArticle) !== null && _this$article$accesso !== void 0 && _this$article$accesso.shelfPlanner)) {
-                _context6.next = 27;
+              if (!(shelfId && (_this$article$accesso3 = this.article.accessoireParentArticle) !== null && _this$article$accesso3 !== void 0 && _this$article$accesso3.shelfPlanner)) {
+                _context6.next = 33;
                 break;
               }
               accessoires = this.article.accessoireParentArticle.shelfPlanner.getAccessorireByCodex(shelfId, initAcc.Codex);
               if (!(accessoires && accessoires.length > 0)) {
-                _context6.next = 27;
+                _context6.next = 33;
                 break;
               }
               accessoireToDelete = accessoires[0];
               rh = (_accessoireToDelete$s = accessoireToDelete.shelfPlanner) === null || _accessoireToDelete$s === void 0 ? void 0 : _accessoireToDelete$s.getRHOnParentArticle();
               if (!(rh !== undefined && accessoireToDelete.relatedToShelfGrid !== undefined)) {
-                _context6.next = 27;
+                _context6.next = 33;
                 break;
               }
-              _context6.next = 27;
+              _context6.next = 33;
               return setHandlerInstance.deleteAccessorieOnShelfPlanner(this.article.set, accessoireToDelete.relatedToShelfGrid, rh, this.article.accessoireParentArticle.basketId);
-            case 27:
+            case 33:
               grid.ActAccessoire = undefined;
-            case 28:
+            case 34:
               k++;
-              _context6.next = 12;
+              _context6.next = 17;
               break;
-            case 31:
+            case 37:
               j++;
-              _context6.next = 9;
+              _context6.next = 10;
               break;
-            case 34:
+            case 40:
               i++;
               _context6.next = 2;
               break;
-            case 37:
+            case 43:
             case "end":
               return _context6.stop();
           }
         }, _callee6, this);
       }));
-      function initAccList(_x7) {
+      function initAccList(_x8) {
         return _initAccList.apply(this, arguments);
       }
       return initAccList;
@@ -711,7 +1075,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
     key: "triggerVisibility",
     value: function () {
       var _triggerVisibility = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(gridGroup) {
-        var toCleanOptions, toUpdateOptions, i, grid, _i5, option, visitOptionState;
+        var toCleanOptions, toUpdateOptions, i, grid, _i6, option, visitOptionState;
         return _regeneratorRuntime.wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
@@ -747,13 +1111,13 @@ var ShelfPlanner = /*#__PURE__*/function () {
               _context7.next = 3;
               break;
             case 13:
-              _i5 = 0;
+              _i6 = 0;
             case 14:
-              if (!(_i5 < [].concat(toUpdateOptions, toCleanOptions).length)) {
+              if (!(_i6 < [].concat(toUpdateOptions, toCleanOptions).length)) {
                 _context7.next = 23;
                 break;
               }
-              option = [].concat(toUpdateOptions, toCleanOptions)[_i5];
+              option = [].concat(toUpdateOptions, toCleanOptions)[_i6];
               visitOptionState = this.article.getArticleOptionState((!this.article.CatalogData.isIDMFormat ? 'OPT' : '') + option);
               if (!visitOptionState) {
                 _context7.next = 20;
@@ -762,7 +1126,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
               _context7.next = 20;
               return articleHandlerInstance.updateOption(this.article, visitOptionState.optionCodex, toUpdateOptions.includes(option) ? 'OPVMIT' : 'OPVOHNE');
             case 20:
-              _i5++;
+              _i6++;
               _context7.next = 14;
               break;
             case 23:
@@ -771,7 +1135,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
           }
         }, _callee7, this);
       }));
-      function triggerVisibility(_x8) {
+      function triggerVisibility(_x9) {
         return _triggerVisibility.apply(this, arguments);
       }
       return triggerVisibility;
@@ -858,6 +1222,21 @@ var ShelfPlanner = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * `tryFitOnShelfOfGrid` limited to the cells `getFreeSpacesOfAccessoire` offers (an active grid, room above and below,
+     * neighbour and montage rules) - for a placement nobody picked by hand: a carry-over or a family swap.
+     */
+  }, {
+    key: "tryFitOnOfferedCellOfGrid",
+    value: function tryFitOnOfferedCellOfGrid(gridIndex, cellIndex, accessoire) {
+      var fit = this.tryFitOnShelfOfGrid(gridIndex, cellIndex, accessoire);
+      if (fit === false || fit.index === undefined || fit.type === 'doesNotFit' || fit.type.startsWith('notAllowed')) return fit;
+      return this.grids[gridIndex].getFreeSpacesOfAccessoire(accessoire).includes(fit.index) ? fit : {
+        type: 'doesNotFit',
+        size: fit.size
+      };
+    }
+
     /**
      *
      * @param gridName
@@ -950,7 +1329,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
           }
         }, _callee9, this);
       }));
-      function deleteAccessoireOfCellInGrid(_x9, _x10) {
+      function deleteAccessoireOfCellInGrid(_x10, _x11) {
         return _deleteAccessoireOfCellInGrid.apply(this, arguments);
       }
       return deleteAccessoireOfCellInGrid;
@@ -986,7 +1365,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
     key: "handleDeleteTakePlaceOnOtherGrids",
     value: (function () {
       var _handleDeleteTakePlaceOnOtherGrids = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10(gridIndex, cellIndex, accessoire) {
-        var i, _cell$Article, cell, _i6, _cell$Article2, _cell, _i7;
+        var i, _cell$Article2, cell, _i7, _cell$Article3, _cell, _i8;
         return _regeneratorRuntime.wrap(function _callee10$(_context10) {
           while (1) switch (_context10.prev = _context10.next) {
             case 0:
@@ -999,15 +1378,15 @@ var ShelfPlanner = /*#__PURE__*/function () {
               if (accessoire.shelfHeightAbove) {
                 for (i = 0; i < accessoire.shelfHeightAbove; i++) {
                   cell = this.grids[gridIndex].Cells[cellIndex + accessoire.shelfHeight + i];
-                  if ((cell === null || cell === void 0 || (_cell$Article = cell.Article) === null || _cell$Article === void 0 ? void 0 : _cell$Article.basketId) === accessoire.basketId) {
+                  if ((cell === null || cell === void 0 || (_cell$Article2 = cell.Article) === null || _cell$Article2 === void 0 ? void 0 : _cell$Article2.basketId) === accessoire.basketId) {
                     cell.ClearInUse();
                   }
                 }
               }
               if (accessoire.shelfHeightBelow) {
-                for (_i6 = 0; _i6 < accessoire.shelfHeightBelow; _i6++) {
-                  _cell = this.grids[gridIndex].Cells[cellIndex - (_i6 + 1)];
-                  if ((_cell === null || _cell === void 0 || (_cell$Article2 = _cell.Article) === null || _cell$Article2 === void 0 ? void 0 : _cell$Article2.basketId) === accessoire.basketId) {
+                for (_i7 = 0; _i7 < accessoire.shelfHeightBelow; _i7++) {
+                  _cell = this.grids[gridIndex].Cells[cellIndex - (_i7 + 1)];
+                  if ((_cell === null || _cell === void 0 || (_cell$Article3 = _cell.Article) === null || _cell$Article3 === void 0 ? void 0 : _cell$Article3.basketId) === accessoire.basketId) {
                     _cell.ClearInUse();
                   }
                 }
@@ -1016,22 +1395,22 @@ var ShelfPlanner = /*#__PURE__*/function () {
                 _context10.next = 14;
                 break;
               }
-              _i7 = 0;
+              _i8 = 0;
             case 6:
-              if (!(_i7 < this.grids.length)) {
+              if (!(_i8 < this.grids.length)) {
                 _context10.next = 14;
                 break;
               }
-              if (!(_i7 === gridIndex)) {
+              if (!(_i8 === gridIndex)) {
                 _context10.next = 9;
                 break;
               }
               return _context10.abrupt("continue", 11);
             case 9:
               _context10.next = 11;
-              return this.grids[_i7].deleteAccessoireInCells(cellIndex);
+              return this.grids[_i8].deleteAccessoireInCells(cellIndex);
             case 11:
-              _i7++;
+              _i8++;
               _context10.next = 6;
               break;
             case 14:
@@ -1040,7 +1419,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
           }
         }, _callee10, this);
       }));
-      function handleDeleteTakePlaceOnOtherGrids(_x11, _x12, _x13) {
+      function handleDeleteTakePlaceOnOtherGrids(_x12, _x13, _x14) {
         return _handleDeleteTakePlaceOnOtherGrids.apply(this, arguments);
       }
       return handleDeleteTakePlaceOnOtherGrids;
@@ -1105,7 +1484,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
           }
         }, _callee11, this);
       }));
-      function addAccessoireInCellInGrid(_x14, _x15, _x16, _x17, _x18) {
+      function addAccessoireInCellInGrid(_x15, _x16, _x17, _x18, _x19) {
         return _addAccessoireInCellInGrid.apply(this, arguments);
       }
       return addAccessoireInCellInGrid;
@@ -1211,10 +1590,10 @@ var ShelfPlanner = /*#__PURE__*/function () {
           });
           if (grid.ShelfIndex != i) cells[j].gridIndex = grid.ShelfIndex;
           if (cell.InUse == j) {
-            var _cell$Article3, _cell$Article4;
+            var _cell$Article4, _cell$Article5;
             cells[j].usedArticleData = {
-              Codex: (_cell$Article3 = cell.Article) === null || _cell$Article3 === void 0 ? void 0 : _cell$Article3.articleCodex,
-              BasketID: (_cell$Article4 = cell.Article) === null || _cell$Article4 === void 0 ? void 0 : _cell$Article4.basketId
+              Codex: (_cell$Article4 = cell.Article) === null || _cell$Article4 === void 0 ? void 0 : _cell$Article4.articleCodex,
+              BasketID: (_cell$Article5 = cell.Article) === null || _cell$Article5 === void 0 ? void 0 : _cell$Article5.basketId
             };
           }
         }
@@ -1240,13 +1619,13 @@ var ShelfPlanner = /*#__PURE__*/function () {
         for (var j = 0; j < grid.Cells.length; j++) {
           var cell = grid.Cells[j];
           if (cell.InUse == j && cell.Article && cell.Article.model3DName && !cell.OnlyPlaceHolder) {
-            var _cell$Article5;
+            var _cell$Article6;
             var cellIndex = cell.Index;
             if (grid.Direction == 'vertikal' && this.article.CatalogData.useShelfPlannerRTV != true) {
               cellIndex = grid.Cells.length - 1 - cell.Index;
             }
             accessoires.push({
-              basketId: (_cell$Article5 = cell.Article) === null || _cell$Article5 === void 0 ? void 0 : _cell$Article5.basketId,
+              basketId: (_cell$Article6 = cell.Article) === null || _cell$Article6 === void 0 ? void 0 : _cell$Article6.basketId,
               gridId: grid.ShelfIndex,
               gridName: grid.GridName,
               model: cell.Article.model3DName,
@@ -1267,8 +1646,8 @@ var ShelfPlanner = /*#__PURE__*/function () {
   }, {
     key: "getShelfElementId",
     value: function getShelfElementId() {
-      var _this$article$accesso2;
-      if ((_this$article$accesso2 = this.article.accessoireParentArticle) !== null && _this$article$accesso2 !== void 0 && _this$article$accesso2.shelfPlanner && this.article.relatedToShelfGrid !== undefined && this.grids.length > 0) {
+      var _this$article$accesso4;
+      if ((_this$article$accesso4 = this.article.accessoireParentArticle) !== null && _this$article$accesso4 !== void 0 && _this$article$accesso4.shelfPlanner && this.article.relatedToShelfGrid !== undefined && this.grids.length > 0) {
         var rh = this.getRHOnParentArticle();
         var parentId = this.article.accessoireParentArticle.shelfPlanner.getShelfElementId();
         return parentId + '.' + this.article.relatedToShelfGrid + '.' + rh;
@@ -1283,13 +1662,13 @@ var ShelfPlanner = /*#__PURE__*/function () {
   }, {
     key: "getRHOnParentArticle",
     value: function getRHOnParentArticle() {
-      var _this$article$accesso3,
-        _this = this;
+      var _this$article$accesso5,
+        _this2 = this;
       if (this.article.relatedToShelfGrid === undefined) return undefined;
-      return (_this$article$accesso3 = this.article.accessoireParentArticle) === null || _this$article$accesso3 === void 0 || (_this$article$accesso3 = _this$article$accesso3.shelfPlanner) === null || _this$article$accesso3 === void 0 || (_this$article$accesso3 = _this$article$accesso3.grids[this.article.relatedToShelfGrid].Cells.find(function (item) {
+      return (_this$article$accesso5 = this.article.accessoireParentArticle) === null || _this$article$accesso5 === void 0 || (_this$article$accesso5 = _this$article$accesso5.shelfPlanner) === null || _this$article$accesso5 === void 0 || (_this$article$accesso5 = _this$article$accesso5.grids[this.article.relatedToShelfGrid].Cells.find(function (item) {
         var _item$Article;
-        return ((_item$Article = item.Article) === null || _item$Article === void 0 ? void 0 : _item$Article.basketId) == _this.article.basketId;
-      })) === null || _this$article$accesso3 === void 0 ? void 0 : _this$article$accesso3.InUse;
+        return ((_item$Article = item.Article) === null || _item$Article === void 0 ? void 0 : _item$Article.basketId) == _this2.article.basketId;
+      })) === null || _this$article$accesso5 === void 0 ? void 0 : _this$article$accesso5.InUse;
     }
 
     /**
@@ -1352,8 +1731,8 @@ var ShelfPlanner = /*#__PURE__*/function () {
   }, {
     key: "getShelfParentShelfId",
     value: function getShelfParentShelfId() {
-      var _this$article$accesso4;
-      if (this.article.relatedToShelfGrid !== undefined) return (_this$article$accesso4 = this.article.accessoireParentArticle) === null || _this$article$accesso4 === void 0 || (_this$article$accesso4 = _this$article$accesso4.shelfPlanner) === null || _this$article$accesso4 === void 0 || (_this$article$accesso4 = _this$article$accesso4.grids[this.article.relatedToShelfGrid]) === null || _this$article$accesso4 === void 0 ? void 0 : _this$article$accesso4.ShelfId;
+      var _this$article$accesso6;
+      if (this.article.relatedToShelfGrid !== undefined) return (_this$article$accesso6 = this.article.accessoireParentArticle) === null || _this$article$accesso6 === void 0 || (_this$article$accesso6 = _this$article$accesso6.shelfPlanner) === null || _this$article$accesso6 === void 0 || (_this$article$accesso6 = _this$article$accesso6.grids[this.article.relatedToShelfGrid]) === null || _this$article$accesso6 === void 0 ? void 0 : _this$article$accesso6.ShelfId;
       return undefined;
     }
 
@@ -1413,7 +1792,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
     key: "disableCellsByDockedShelfs",
     value: (function () {
       var _disableCellsByDockedShelfs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12(count) {
-        var _this2 = this;
+        var _this3 = this;
         var grids, _loop2, i;
         return _regeneratorRuntime.wrap(function _callee12$(_context13) {
           while (1) switch (_context13.prev = _context13.next) {
@@ -1437,7 +1816,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
                       newlyEnabled = grid.Cells.filter(function (cell, j) {
                         return cell.IsDisabled && !toDisableCells.includes(j);
                       }).length;
-                      if (newlyDisabled.length || newlyEnabled) _this2.logShelfDebug({
+                      if (newlyDisabled.length || newlyEnabled) _this3.logShelfDebug({
                         phase: 'docking',
                         action: 'disabledCellsUpdated',
                         gridIndex: grid.ShelfIndex,
@@ -1455,7 +1834,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
                         break;
                       }
                       _context12.next = 14;
-                      return setHandlerInstance.deleteAccessorieOnShelfPlanner(_this2.article.set, grid.ShelfIndex, cell.InUse, grid.basketId);
+                      return setHandlerInstance.deleteAccessorieOnShelfPlanner(_this3.article.set, grid.ShelfIndex, cell.InUse, grid.basketId);
                     case 14:
                       cell.IsDisabled = true;
                     case 15:
@@ -1503,7 +1882,7 @@ var ShelfPlanner = /*#__PURE__*/function () {
           }
         }, _callee12, this);
       }));
-      function disableCellsByDockedShelfs(_x19) {
+      function disableCellsByDockedShelfs(_x20) {
         return _disableCellsByDockedShelfs.apply(this, arguments);
       }
       return disableCellsByDockedShelfs;
@@ -1576,6 +1955,24 @@ var ShelfPlanner = /*#__PURE__*/function () {
       }
       return undefined;
     }
+  }], [{
+    key: "addValuesPassedOnBy",
+    value: function addValuesPassedOnBy(article, parentInheritedValues) {
+      var globalValues = {};
+      for (var _i9 = 0, _Object$keys2 = Object.keys(article.getGlobalOptions()); _i9 < _Object$keys2.length; _i9++) {
+        var _article$getArticleOp;
+        var opt = _Object$keys2[_i9];
+        var valCodex = (_article$getArticleOp = article.getArticleOptionState(opt)) === null || _article$getArticleOp === void 0 ? void 0 : _article$getArticleOp.valCodex;
+        if (valCodex) globalValues[opt] = valCodex;
+      }
+      var inheritedValues = _objectSpread({}, parentInheritedValues);
+      var ownInheritedValues = article.getAccessoriesToChangeFromGlobalOption(globalValues);
+      for (var _i10 = 0, _Object$keys3 = Object.keys(ownInheritedValues); _i10 < _Object$keys3.length; _i10++) {
+        var _basketId = _Object$keys3[_i10];
+        inheritedValues[_basketId] = _objectSpread(_objectSpread({}, inheritedValues[_basketId]), ownInheritedValues[_basketId].variantValues);
+      }
+      return inheritedValues;
+    }
   }]);
 }();