@crystaldesign/web-planner-logic 25.13.0-beta.43 → 25.13.0-beta.45

package/build/cjs/{DivaBoxPlanner-a7a2bcb9.js → DivaBoxPlanner-78547263.js}

@@ -5,10 +5,10 @@ var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
 var _createClass = require('@babel/runtime/helpers/createClass');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var _regeneratorRuntime = require('@babel/runtime/regenerator');
-var index = require('./index-1c5aa2c3.js');
+var index = require('./index-65a02251.js');
 var DivaUtils = require('@crystaldesign/diva-utils');
 var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
-var PlannerHandler2D = require('./PlannerHandler2D-eda6acbb.js');
+var PlannerHandler2D = require('./PlannerHandler2D-f6080d6d.js');
 require('@babel/runtime/helpers/slicedToArray');
 require('@babel/runtime/helpers/objectWithoutProperties');
 require('axios');
@@ -3472,7 +3472,28 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
         curGrid[cell.index.x].splice(cell.index.y, 1);
         if (curGrid[cell.index.x].length == 0) curGrid.splice(cell.index.x, 1);
       });
-      if (gridCellsToDelete.backside) this.generalPlanningState.grids[1].matrix = curGrid;else this.generalPlanningState.grids[0].matrix = curGrid;
+      var refreshedGrid = [];
+      curGrid.forEach(function (row, x) {
+        refreshedGrid[x] = [];
+        row.forEach(function (column, y) {
+          var area = column.plannedElement.area;
+          refreshedGrid[x][y] = {
+            index: {
+              x: x,
+              y: y
+            },
+            plannedElement: _objectSpread(_objectSpread({}, column.plannedElement), {}, {
+              area: {
+                fromX: x,
+                fromY: y,
+                toX: x + (area.toX - area.fromX),
+                toY: y + (area.toY - area.fromY)
+              }
+            })
+          };
+        });
+      });
+      if (gridCellsToDelete.backside) this.generalPlanningState.grids[1].matrix = refreshedGrid;else this.generalPlanningState.grids[0].matrix = refreshedGrid;
     }
 
     /**
@@ -4108,18 +4129,22 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
       if (this.hasActiveBackside) throw new Error('this function is doesnt implement the backside logic (yet)');
       var result = [];
       var lastHeight = -1;
-      for (var idx = 0; idx < this.getColumnCount(); idx++) {
-        var row = this.generalPlanningState.grids[0].matrix[idx];
-        var height = row.reduce(function (added, column) {
-          return column.height + added;
-        }, 0);
+      for (var x = 0; x < this.getColumnCount();) {
+        var row = this.generalPlanningState.grids[0].matrix[x];
+        var height = 0;
+        for (var y = 0; y < row.length;) {
+          var element = row[y].plannedElement;
+          height += element.size.height;
+          y = element.area.toY;
+        }
         if (height == lastHeight || onBottom) {
           if (!result[result.length - 1]) result.push([]);
-          result[result.length - 1].push(this.getPlannerElementAtGridPos(idx, row.length - 1, false));
+          result[result.length - 1].push(this.getPlannerElementAtGridPos(x, row.length - 1, false));
         } else {
-          result.push([this.getPlannerElementAtGridPos(idx, row.length - 1, false)]);
+          result.push([this.getPlannerElementAtGridPos(x, row.length - 1, false)]);
         }
         lastHeight = height;
+        x = row[row.length - 1].plannedElement ? row[row.length - 1].plannedElement.area.toX : x + 1;
       }
       return result;
     }
@@ -4223,7 +4248,7 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
       };
       var curGrid = curPos.backside ? this.generalPlanningState.grids[1].matrix : this.generalPlanningState.grids[0].matrix;
       var resultPlannerIds = [];
-      for (var i = curPos.startColIndex; i <= curPos.endColIndex; i++) {
+      for (var i = curPos.startColIndex; i < curPos.endColIndex; i++) {
         for (var j = curPos.startRowIndex--; j >= 0; j--) {
           var _neighborCell$planned;
           var neighborCell = curGrid[i][j];
@@ -4522,12 +4547,8 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
             allCheckedElementIds.push(elementId);
             var topNeighbors = this.getNeighborElements(elementId, 'TOP');
             var rightNeighbors = this.getNeighborElements(elementId, 'RIGHT');
-            for (var n = 0; n < topNeighbors.length; n++) {
-              PlannerHandler2D.dockingPointHandlerInst.tryDockElement(element, 'AVO', [topNeighbors[n]]);
-            }
-            for (var n = 0; n < rightNeighbors.length; n++) {
-              PlannerHandler2D.dockingPointHandlerInst.tryDockElement(element, 'AVR', [rightNeighbors[n]]);
-            }
+            if (topNeighbors.length > 0) PlannerHandler2D.dockingPointHandlerInst.tryDockElement(element, 'AVO', [topNeighbors[0]]);
+            if (rightNeighbors.length > 0) PlannerHandler2D.dockingPointHandlerInst.tryDockElement(element, 'AVR', [rightNeighbors[0]]);
             element.PosNr = posNr;
             posNr++;
           }
@@ -4549,12 +4570,8 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
             }
             var _topNeighbors = this.getNeighborElements(_elementId6, 'TOP');
             var _rightNeighbors = this.getNeighborElements(_elementId6, 'RIGHT');
-            for (var n = 0; n < _topNeighbors.length; n++) {
-              PlannerHandler2D.dockingPointHandlerInst.tryDockElement(_element2, 'AVO', [_topNeighbors[n]]);
-            }
-            for (var n = 0; n < _rightNeighbors.length; n++) {
-              PlannerHandler2D.dockingPointHandlerInst.tryDockElement(_element2, 'AVL', [_rightNeighbors[n]]);
-            }
+            if (_topNeighbors.length > 0) PlannerHandler2D.dockingPointHandlerInst.tryDockElement(_element2, 'AVO', [_topNeighbors[0]]);
+            if (_rightNeighbors.length > 0) PlannerHandler2D.dockingPointHandlerInst.tryDockElement(_element2, 'AVL', [_rightNeighbors[0]]);
             _element2.PosNr = posNr;
             posNr++;
           }
@@ -5002,12 +5019,19 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
     }
   }, {
     key: "getGeneralPlanningState",
-    value: function getGeneralPlanningState(selectedElementId) {
-      return this.generalPlanningState;
-      /*
-      let matrix: Cell[][] = [];
-      let selectedElement: SelectedElement | undefined = undefined;
-       const plannedElements: PlannedElement[] = Array.from(this.plannerElements.values()).map((p) => {
+    value: function getGeneralPlanningState() {
+      var movables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var selectedElementId = arguments.length > 1 ? arguments[1] : undefined;
+      if (!movables) return this.generalPlanningState;
+      // fill to equal size
+      var matrix = this.generalPlanningState.grids[0].matrix;
+      var matrixWithMovables = [];
+      var maxWidth = matrix.length;
+      var maxHeight = 0;
+      matrix.forEach(function (x) {
+        if (x.length > maxHeight) maxHeight = x.length;
+      });
+      Array.from(this.plannerElements.values()).map(function (p) {
         return {
           basketId: p.getBasketId(),
           elementId: p.getElementId(),
@@ -5015,97 +5039,63 @@ var BoxPlannerGrid = /*#__PURE__*/function () {
           size: {
             width: p.getWidth(),
             height: p.getHeight(),
-            depth: p.getDepth(),
+            depth: p.getDepth()
           },
           area: {
             fromX: undefined,
             toX: undefined,
             fromY: undefined,
-            toY: undefined,
-          } as any,
+            toY: undefined
+          }
         };
       });
-       let frontGrid = this.generalPlanningState.grids[0].matrix;
-      let index = { x: 0, y: 0 };
-      for (let i = 0; i < frontGrid.length; i++) {
-        matrix.push([]);
-        const frontGridRow = frontGrid[i];
-        for (let j = 0; j < frontGridRow.length; j++) {
-          const cell = frontGridRow[j];
-          let elementId = cell.plannedElement?.elementId;
-          if (elementId && cell) {
-            const plannedElement = plannedElements.find((p) => p.elementId === elementId);
-            let matrixIndex = 0;
-            for (let idx = cell.index.x - 1; idx >= 0; idx--)
-              matrixIndex += frontGridRow[idx]!.plannedElement!.size.width / 19.2;
-             if (plannedElement) {
-              
-              plannedElement.area.fromX = matrixIndex;
-              plannedElement.area.toX = matrixIndex + cell.plannedElement!.size.width / 19.2;
-              plannedElement.area.fromY = cell.index.y;
-              plannedElement.area.toY = cell.index.y + cell.plannedElement!.size.height / 19.2;
-               for (let x = plannedElement.area.fromX; x < plannedElement.area.toX; x++) {
-                for (let y = plannedElement.area.fromY; y < plannedElement.area.toY; y++) {
-                  if (!matrix[x]) matrix[x] = [];
-                  matrix[x][y] = { index: { x, y }, plannedElement };
-                }
-              }
-              continue;
+      var isSupport = false;
+      var selectedElement = undefined;
+      var ele = undefined;
+      if (selectedElementId) {
+        var res = this.getCellsInGridByElementId(selectedElementId);
+        ele = res.cells[0].plannedElement;
+        selectedElement = {
+          articleCodex: ele.articleCodex,
+          elementId: ele.elementId,
+          gridSpace: {
+            rows: ele.area.toY - ele.area.fromY + 1,
+            colums: ele.area.toX - ele.area.fromX + 1
+          },
+          size: ele.size,
+          rules: []
+        };
+        isSupport = !!matrix.find(function (x, idx) {
+          return idx >= ele.area.fromX && idx < ele.area.toX && matrix[idx].length > ele.area.toY;
+        }); // can't move if there is anything above these cells
+      }
+      for (var x = 0; x < maxWidth; x++) {
+        if (!matrixWithMovables[x]) {
+          if (matrix[x]) matrixWithMovables[x] = _toConsumableArray__default["default"](matrix[x]);else matrixWithMovables[x] = [];
+        }
+        if (!matrixWithMovables[x]) matrixWithMovables[x] = [];
+        for (var y = 0; y < maxHeight; y++) {
+          if (matrix[x].length > y && matrix[x][y]) matrixWithMovables[x][y] = matrix[x][y];else if (!isSupport && !(x >= ele.area.fromX && x < ele.area.toX)) matrixWithMovables[x][y] = {
+            index: {
+              x: x,
+              y: y
             }
-            matrix[matrixIndex].push({ index: index, plannedElement });
-          }
+          };
         }
       }
-       // Fill matrix rows to equal length
-      const maxLength = Math.max(...matrix.map((row) => row.length));
-      matrix.forEach((row) => {
-        while (row.length < maxLength) {
-          const lastCell = row[row.length - 1];
-          const newY = lastCell ? lastCell.index.y + 1 : 0;
-          row.push({
-            index: new Vector2(row[0]?.index.x || 0, newY),
-            plannedElement: undefined,
-          });
+      var len = matrixWithMovables.length;
+      matrixWithMovables[len] = [{
+        index: {
+          x: len,
+          y: 0
         }
+      }];
+      return _objectSpread(_objectSpread({}, this.generalPlanningState), {}, {
+        selectedElement: selectedElement,
+        grids: [_objectSpread(_objectSpread({}, this.generalPlanningState.grids[0]), {}, {
+          matrix: matrixWithMovables
+        })]
       });
-       let selectedPlannedElement = selectedElementId ? plannedElements.find((p) => p.elementId === selectedElementId) : undefined;
-      if (selectedPlannedElement) {
-        //add the free let planningLeftLocation = this.getFreePlanningLocation(element.getElementId(), 'LEFT');
-        let planningLeftLocation = this.getFreePlanningLocation(selectedPlannedElement.elementId, 'LEFT');
-        let planningRightLocation = this.getFreePlanningLocation(selectedPlannedElement.elementId, 'RIGHT');
-        let planningTopLocation = this.getFreePlanningLocation(selectedPlannedElement.elementId, 'TOP');
-         let fixedPositionRules: FixedPositonRule[] = [];
-         if (planningLeftLocation) {
-          this.addFreeCellsToMatrix(matrix, planningLeftLocation.cells, fixedPositionRules);
-        }
-        if (planningRightLocation) {
-          this.addFreeCellsToMatrix(matrix, planningRightLocation.cells, fixedPositionRules);
-        }
-        if (planningTopLocation) {
-          this.addFreeCellsToMatrix(matrix, planningTopLocation.cells, fixedPositionRules);
-        }
-         selectedElement = {
-          articleCodex: selectedPlannedElement.articleCodex,
-          size: selectedPlannedElement.size,
-          gridSpace: {
-            rows: selectedPlannedElement.area.toY - selectedPlannedElement.area.fromY + 1,
-            colums: selectedPlannedElement.area.toX - selectedPlannedElement.area.fromX + 1,
-          },
-          rules: fixedPositionRules,
-          elementId: selectedElementId!,
-        };
-      }
-      return {
-        grids: [
-          {
-            index: 0, // boxplanner usecase grid index always 0
-            rowSizes: this.getRowSizes(matrix, selectedElement),
-            columnSizes: this.getColumnSizes(matrix, selectedElement),
-            matrix,
-          },
-        ],
-        selectedElement,
-      }; */
     }
   }, {
     key: "getRowSizes",
@@ -6107,7 +6097,7 @@ var DivaBoxPlanner = /*#__PURE__*/function () {
   }, {
     key: "getGeneralPlanningState",
     value: function getGeneralPlanningState(selectedElementId) {
-      return this.boxPlannerGrid.getGeneralPlanningState(selectedElementId);
+      return this.boxPlannerGrid.getGeneralPlanningState(true, selectedElementId);
     }
   }]);
 }();