@crystaldesign/web-planner-logic 26.11.0-beta.2 → 26.11.0-beta.21

package/build/esm/PlannerHandler2D-d93ae013.js

@@ -0,0 +1,526 @@
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { c as Vector2 } from './index-b755400a.js';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import DivaUtils, { DivaError } from '@crystaldesign/diva-utils';
+import { parseXml, serializeXml, removeMask, stretchArticleSvg, DockingPointHandler as DockingPointHandler$1, polygonEdgesIntersect, polygonInsidePolygon, getOlfGeometry, getOltGeometry, getRootSize, getMinBorder } from '@crystaldesign/planner-2d-core';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _get from '@babel/runtime/helpers/get';
+import _inherits from '@babel/runtime/helpers/inherits';
+
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var LOG$1 = DivaUtils.initLog('Planner', 'WEB-PLANNER-LOGIC');
+var SVGUtils = /*#__PURE__*/function () {
+  function SVGUtils() {
+    _classCallCheck(this, SVGUtils);
+  }
+  /**
+   * This function removes all VIF and OLF information from the SVG. This is used for displaying only the OLT information
+   * @param content The svg with OLF and OLT
+   * @returns SVG with only OLT information
+   */
+  return _createClass(SVGUtils, [{
+    key: "removeOLFFromSvg",
+    value: function removeOLFFromSvg(content) {
+      var xmlDocument = parseXml(content);
+      var vifObjs = xmlDocument.evaluate("//*[starts-with(@id,'VIF')]", xmlDocument, null, 7, null);
+      if (vifObjs.snapshotLength > 0) {
+        for (var i = 0; i < vifObjs.snapshotLength; i++) {
+          var _parentElement;
+          (_parentElement = vifObjs.snapshotItem(i).parentElement) === null || _parentElement === void 0 || _parentElement.removeChild(vifObjs.snapshotItem(i));
+        }
+      }
+      var olfObjs = xmlDocument.evaluate("//*[starts-with(@id,'OLF')]", xmlDocument, null, 7, null);
+      if (olfObjs.snapshotLength > 0) {
+        for (var i = 0; i < olfObjs.snapshotLength; i++) {
+          var _parentElement2;
+          (_parentElement2 = olfObjs.snapshotItem(i).parentElement) === null || _parentElement2 === void 0 || _parentElement2.removeChild(olfObjs.snapshotItem(i));
+        }
+      }
+      return serializeXml(xmlDocument);
+    }
+
+    /**
+     * This function returns the DPs of an svg
+     * @param content The svg with OLF and OLT
+     * @returns SVG with only OLT information
+     */
+  }, {
+    key: "getDPsInSVG",
+    value: function getDPsInSVG(content) {
+      var dockingpointsSvgLine = [];
+      var xmlDocument = parseXml(content);
+      var dpObjs = xmlDocument.evaluate("//*[starts-with(@id,'AV')]", xmlDocument, null, 7, null);
+      if (dpObjs.snapshotLength > 0) {
+        for (var i = 0; i < dpObjs.snapshotLength; i++) {
+          var obj = dpObjs.snapshotItem(i);
+          if ((obj === null || obj === void 0 ? void 0 : obj.nodeName) === 'line') {
+            dockingpointsSvgLine.push({
+              x1: Number(obj.getAttribute('x1')),
+              y1: Number(obj.getAttribute('y1')),
+              x2: Number(obj.getAttribute('x2')),
+              y2: Number(obj.getAttribute('y2')),
+              dockingName: obj.getAttribute('id'),
+              dockingType: obj.getAttribute('id').substring(0, 3)
+            });
+          } else {
+            throw new Error('nodename type: ' + obj.nodeName + ' not implemented');
+          }
+        }
+      }
+      dockingpointsSvgLine.sort(function (a, b) {
+        if (a.dockingType === 'AVL') return -1;
+        if (a.dockingType === 'AVR' && ['AVR', 'AVC', 'AVU', 'AVO', 'AVS', 'AVN'].includes(b.dockingType)) return -1;
+        return 0;
+      });
+      return dockingpointsSvgLine;
+    }
+
+    /**
+     * This function returns the DPs of an svg
+     * @param content The svg with OLF and OLT
+     * @returns SVG with only OLT information
+     */
+  }, {
+    key: "getPointOfPoligonById",
+    value: function getPointOfPoligonById(content, id) {
+      var points = [];
+      var xmlDocument = parseXml(content);
+      var dpObjs = xmlDocument.evaluate("//*[starts-with(@id,'" + id + "')]", xmlDocument, null, 7, null);
+      if (dpObjs.snapshotLength > 1 || dpObjs.snapshotLength == 0) return undefined;
+      for (var i = 0; i < dpObjs.snapshotLength; i++) {
+        var obj = dpObjs.snapshotItem(i);
+        if ((obj === null || obj === void 0 ? void 0 : obj.nodeName) === 'polygon') {
+          var pointsAsString = obj.getAttribute('points');
+          if (pointsAsString) {
+            var pointsFromString = pointsAsString.split(' ');
+            for (var j = 0; j < pointsFromString.length; j++) {
+              var xandY = pointsFromString[j].split(',');
+              if (xandY.length !== 2) continue;
+              points.push(new Vector2(Number(xandY[0]), Number(xandY[1])));
+            }
+          } else {
+            return undefined;
+          }
+        }
+      }
+      return points;
+    }
+  }, {
+    key: "getBoundingBoxOfPoints",
+    value: function getBoundingBoxOfPoints(points) {
+      var xArr = points.map(function (c) {
+        return c.x;
+      });
+      var yArr = points.map(function (c) {
+        return c.y;
+      });
+      var minX = Math.min.apply(Math, _toConsumableArray(xArr));
+      var maxX = Math.max.apply(Math, _toConsumableArray(xArr));
+      var minY = Math.min.apply(Math, _toConsumableArray(yArr));
+      var maxY = Math.max.apply(Math, _toConsumableArray(yArr));
+      var width = maxX - minX;
+      var height = maxY - minY;
+      return {
+        width: width,
+        height: height,
+        minX: minX,
+        minY: minY
+      };
+    }
+
+    /**
+     * Returns OLF geometry (minX, minY, width, height) from SVG - supports rect and polygon.
+     * Iterates through matches to find first rect/polygon (handles Illustrator group wrappers).
+     */
+  }, {
+    key: "getOLFGeometryFromSvg",
+    value: function getOLFGeometryFromSvg(content) {
+      var xmlDocument = parseXml(content);
+      var olfObjs = xmlDocument.evaluate("//*[starts-with(@id,'OLF')]", xmlDocument, null, 7, null);
+      for (var i = 0; i < olfObjs.snapshotLength; i++) {
+        var obj = olfObjs.snapshotItem(i);
+        if ((obj === null || obj === void 0 ? void 0 : obj.nodeName) === 'rect') {
+          var _obj$getAttribute, _obj$getAttribute2, _obj$getAttribute3, _obj$getAttribute4;
+          var x = parseFloat((_obj$getAttribute = obj.getAttribute('x')) !== null && _obj$getAttribute !== void 0 ? _obj$getAttribute : '0');
+          var y = parseFloat((_obj$getAttribute2 = obj.getAttribute('y')) !== null && _obj$getAttribute2 !== void 0 ? _obj$getAttribute2 : '0');
+          var width = parseFloat((_obj$getAttribute3 = obj.getAttribute('width')) !== null && _obj$getAttribute3 !== void 0 ? _obj$getAttribute3 : '0');
+          var height = parseFloat((_obj$getAttribute4 = obj.getAttribute('height')) !== null && _obj$getAttribute4 !== void 0 ? _obj$getAttribute4 : '0');
+          return {
+            minX: x,
+            minY: y,
+            width: width,
+            height: height
+          };
+        }
+        if ((obj === null || obj === void 0 ? void 0 : obj.nodeName) === 'polygon') {
+          var pts = obj.getAttribute('points');
+          if (pts) {
+            var points = pts.split(/\s+/).reduce(function (acc, p) {
+              var _p$split = p.split(','),
+                _p$split2 = _slicedToArray(_p$split, 2),
+                x = _p$split2[0],
+                y = _p$split2[1];
+              if (x != null && y != null) acc.push(new Vector2(Number(x), Number(y)));
+              return acc;
+            }, []);
+            if (points.length) {
+              var bbox = this.getBoundingBoxOfPoints(points);
+              return {
+                minX: bbox.minX,
+                minY: bbox.minY,
+                width: bbox.width,
+                height: bbox.height
+              };
+            }
+          }
+        }
+      }
+      return undefined;
+    }
+
+    /**
+     * Returns OLT geometry (x, y, width, height) from SVG attributes - untransformed coords.
+     * Iterates through matches to find first rect/polygon (handles Illustrator group wrappers).
+     */
+  }, {
+    key: "getOLTGeometryFromSvg",
+    value: function getOLTGeometryFromSvg(content) {
+      var xmlDocument = parseXml(content);
+      var oltObjs = xmlDocument.evaluate("//*[starts-with(@id,'OLT')]", xmlDocument, null, 7, null);
+      for (var i = 0; i < oltObjs.snapshotLength; i++) {
+        var obj = oltObjs.snapshotItem(i);
+        if ((obj === null || obj === void 0 ? void 0 : obj.nodeName) === 'rect') {
+          var _obj$getAttribute5, _obj$getAttribute6, _obj$getAttribute7, _obj$getAttribute8;
+          var x = parseFloat((_obj$getAttribute5 = obj.getAttribute('x')) !== null && _obj$getAttribute5 !== void 0 ? _obj$getAttribute5 : '0');
+          var y = parseFloat((_obj$getAttribute6 = obj.getAttribute('y')) !== null && _obj$getAttribute6 !== void 0 ? _obj$getAttribute6 : '0');
+          var width = parseFloat((_obj$getAttribute7 = obj.getAttribute('width')) !== null && _obj$getAttribute7 !== void 0 ? _obj$getAttribute7 : '0');
+          var height = parseFloat((_obj$getAttribute8 = obj.getAttribute('height')) !== null && _obj$getAttribute8 !== void 0 ? _obj$getAttribute8 : '0');
+          return {
+            x: x,
+            y: y,
+            width: width,
+            height: height
+          };
+        }
+        if ((obj === null || obj === void 0 ? void 0 : obj.nodeName) === 'polygon') {
+          var pts = obj.getAttribute('points');
+          if (pts) {
+            var points = pts.split(/\s+/).reduce(function (acc, p) {
+              var _p$split3 = p.split(','),
+                _p$split4 = _slicedToArray(_p$split3, 2),
+                x = _p$split4[0],
+                y = _p$split4[1];
+              if (x != null && y != null) acc.push(new Vector2(Number(x), Number(y)));
+              return acc;
+            }, []);
+            if (points.length) {
+              var bbox = this.getBoundingBoxOfPoints(points);
+              return {
+                x: bbox.minX,
+                y: bbox.minY,
+                width: bbox.width,
+                height: bbox.height
+              };
+            }
+          }
+        }
+      }
+      return undefined;
+    }
+
+    /**
+     * This function looks if the svg has a Mask HTML element. If so it removes all masks from SVG
+     * @param content
+     */
+  }, {
+    key: "removeMaskFromSvg",
+    value: function removeMaskFromSvg(content) {
+      return removeMask(content);
+    }
+
+    /**
+     * Stretches the SVG to the target OLT size and passes the result to the callback.
+     * @param svgSourceUrl optional URL / path of the loaded SVG for diagnostics
+     */
+  }, {
+    key: "ccCheckStretchAreas",
+    value: function ccCheckStretchAreas(content, newWidthCM, newHeightCM, useglobalSvgScale, svgMinBorderXVal, svgMinBorderYVal, callback, svgSourceUrl) {
+      var result = stretchArticleSvg(content, newWidthCM, newHeightCM, {
+        useGlobalScale: useglobalSvgScale,
+        minBorderX: svgMinBorderXVal,
+        minBorderY: svgMinBorderYVal
+      });
+      var _iterator = _createForOfIteratorHelper(result.warnings),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var warning = _step.value;
+          LOG$1.warn('[SVGUtils] ccCheckStretchAreas: ' + warning + (svgSourceUrl ? ' (svg: ' + svgSourceUrl + ')' : ''));
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      callback(result.svg);
+      return result.sizes;
+    }
+  }]);
+}();
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, e, o, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), e, o); return 2 & r && "function" == typeof p ? function (t) { return p.apply(o, t); } : p; }
+
+/** Legacy minBorder parameter shape still used by this package's callers. */
+/** Docking point handler that additionally accepts the legacy minBorder shape. */
+var DockingPointHandler = /*#__PURE__*/function (_CoreDockingPointHand) {
+  function DockingPointHandler() {
+    _classCallCheck(this, DockingPointHandler);
+    return _callSuper(this, DockingPointHandler, arguments);
+  }
+  _inherits(DockingPointHandler, _CoreDockingPointHand);
+  return _createClass(DockingPointHandler, [{
+    key: "initDockingPointsFromSvg",
+    value: function initDockingPointsFromSvg(plannerElement, dockingVectors, minBorder, plannerConfig) {
+      var normalized = 'minX' in minBorder ? minBorder : {
+        minX: minBorder.svgMinXVal,
+        minY: minBorder.svgMinYVal
+      };
+      _superPropGet(DockingPointHandler, "initDockingPointsFromSvg", this, 3)([plannerElement, dockingVectors, normalized, plannerConfig]);
+    }
+  }]);
+}(DockingPointHandler$1);
+var dockingPointHandlerInst = new DockingPointHandler();
+
+var LOG = DivaUtils.initLog('Planner', 'WEB-PLANNER-LOGIC');
+
+/**
+ * Loads and parses the article SVGs of planner elements and computes element collisions.
+ * Runs headless; the fabric shapes for the visible 2D canvas are built by the render layer from SvgData.
+ */
+var PlannerHandler2D = /*#__PURE__*/function () {
+  function PlannerHandler2D() {
+    _classCallCheck(this, PlannerHandler2D);
+    _defineProperty(this, "svgUtils", void 0);
+    this.svgUtils = new SVGUtils();
+  }
+  /**
+   * This function computes the collision between two elements.
+   * First it computes the collision with the bounding box. Only if these collide - we compute the collision between the OLF Polygons
+   * @param element1
+   * @param element2
+   */
+  return _createClass(PlannerHandler2D, [{
+    key: "checkCollision",
+    value: function checkCollision(element1, element2, checkCollisionForDifferentLayers) {
+      DivaUtils.startSpanOfApm('PlannerHandler2D checkCollision');
+      if (element1.Layer != element2.Layer && (!checkCollisionForDifferentLayers.includes(Number(element1.Layer)) || !checkCollisionForDifferentLayers.includes(Number(element2.Layer)))) {
+        DivaUtils.endSpanOfApm('PlannerHandler2D checkCollision');
+        return false;
+      }
+      var bboxPoints1 = element1.getWorld2DBBoxOutline();
+      var bboxPoints2 = element2.getWorld2DBBoxOutline();
+      if (polygonEdgesIntersect(bboxPoints1, bboxPoints2)) {
+        if (!element1.HasOLTPolygon && !element1.HasOLFPolygon) {
+          LOG.error(new DivaError('checkCollision PlannerHandler2D - The element with id: ' + element1.getElementId() + ' has no OLT AND no OLF', {
+            code: 'WC_0012'
+          }));
+          DivaUtils.endSpanOfApm('PlannerHandler2D checkCollision');
+          return false;
+        } else if (!element2.HasOLTPolygon && !element2.HasOLFPolygon) {
+          LOG.error(new DivaError('checkCollision PlannerHandler2D - The element with id: ' + element2.getElementId() + ' has no OLT AND no OLF', {
+            code: 'WC_0012'
+          }));
+          DivaUtils.endSpanOfApm('PlannerHandler2D checkCollision');
+          return false;
+        }
+        var detailPolygon1 = element1.HasOLFPolygon ? element1.getOLFPolygonWorldPos() : element1.getOLTPolygonWorldPos();
+        var detailPolygon2 = element2.HasOLFPolygon ? element2.getOLFPolygonWorldPos() : element2.getOLTPolygonWorldPos();
+        DivaUtils.endSpanOfApm('PlannerHandler2D checkCollision');
+        return polygonEdgesIntersect(detailPolygon1, detailPolygon2);
+      } else {
+        DivaUtils.endSpanOfApm('PlannerHandler2D checkCollision');
+        return polygonInsidePolygon(bboxPoints1, bboxPoints2); //wenn sie sich nicht überschneiden untersuche, ob ein Polygon genau innerhalb des anderen liegt
+      }
+    }
+  }, {
+    key: "parseSvg",
+    value: function parseSvg(plannerElement, svgXml, minBorderSVG, plannerconfig, sizes) {
+      var _oltGeo$width, _oltGeo$height;
+      svgXml = this.svgUtils.removeMaskFromSvg(svgXml); //Correct mask attributes
+      dockingPointHandlerInst.initDockingPointsFromSvg(plannerElement, this.svgUtils.getDPsInSVG(svgXml), minBorderSVG, plannerconfig);
+      var oltPoints = this.svgUtils.getPointOfPoligonById(svgXml, 'OLT');
+      if (!(oltPoints !== null && oltPoints !== void 0 && oltPoints.length)) {
+        LOG.warn('no olt fount in svg for element' + plannerElement.ArticleCodex + ' with id ' + plannerElement.getElementId());
+      }
+      plannerElement.OLTPolygon = oltPoints;
+      var olf = this.svgUtils.getPointOfPoligonById(svgXml, 'OLF');
+      var olfGeo = getOlfGeometry(svgXml);
+      if (olf !== null && olf !== void 0 && olf.length) {
+        var _olfGeo$width, _olfGeo$height;
+        var olfBBox = this.svgUtils.getBoundingBoxOfPoints(olf);
+        // Prefer getOlfGeometry for dims - single source of truth, handles split(/\s+/) correctly
+        var olfW = (_olfGeo$width = olfGeo === null || olfGeo === void 0 ? void 0 : olfGeo.width) !== null && _olfGeo$width !== void 0 ? _olfGeo$width : olfBBox.width;
+        var olfD = (_olfGeo$height = olfGeo === null || olfGeo === void 0 ? void 0 : olfGeo.height) !== null && _olfGeo$height !== void 0 ? _olfGeo$height : olfBBox.height;
+        plannerElement.setupOLF(olf, olfW, olfD);
+      } else {
+        if (olfGeo) {
+          var olfRectPoints = [new Vector2(olfGeo.minX, olfGeo.minY), new Vector2(olfGeo.minX + olfGeo.width, olfGeo.minY), new Vector2(olfGeo.minX + olfGeo.width, olfGeo.minY + olfGeo.height), new Vector2(olfGeo.minX, olfGeo.minY + olfGeo.height)];
+          plannerElement.setupOLF(olfRectPoints, olfGeo.width, olfGeo.height);
+        } else if (sizes !== null && sizes !== void 0 && sizes.heightOLF, sizes !== null && sizes !== void 0 && sizes.widthOLF) {
+          plannerElement.setupOLF(olf, sizes === null || sizes === void 0 ? void 0 : sizes.widthOLF, sizes === null || sizes === void 0 ? void 0 : sizes.heightOLF);
+        } else {
+          plannerElement.clearOLF();
+        }
+      }
+
+      // Assign unconditionally: parseSvg re-runs per measure change, so keeping the previous SVG's OLT box would offset docked neighbours.
+      var oltGeo = getOltGeometry(svgXml);
+      plannerElement.OLTWidth = (_oltGeo$width = oltGeo === null || oltGeo === void 0 ? void 0 : oltGeo.width) !== null && _oltGeo$width !== void 0 ? _oltGeo$width : 0;
+      plannerElement.OLTDepth = (_oltGeo$height = oltGeo === null || oltGeo === void 0 ? void 0 : oltGeo.height) !== null && _oltGeo$height !== void 0 ? _oltGeo$height : 0;
+      plannerElement.OLTLeft = oltGeo && olfGeo ? oltGeo.x - olfGeo.minX : 0;
+      plannerElement.OLTTop = oltGeo && olfGeo ? oltGeo.y - olfGeo.minY : 0;
+      if (plannerElement.DoSetWidthFromSVG || plannerElement.DoSetDepthFromSVG) {
+        // The ROOT size, not the ink bounds: an article whose drawing does not fill its canvas must still report the canvas size.
+        var rootSize = getRootSize(svgXml);
+        if (plannerElement.DoSetWidthFromSVG && rootSize !== null && rootSize !== void 0 && rootSize.width) plannerElement.WidthFromSVG = rootSize.width / DivaUtils.UnitRecalc;
+        // since the svg is always top down perspective height in 2D represents depth in 2D planner and 3D
+        if (plannerElement.DoSetDepthFromSVG && rootSize !== null && rootSize !== void 0 && rootSize.height) plannerElement.DepthFromSVG = rootSize.height / DivaUtils.UnitRecalc;
+      }
+      plannerElement.SvgData = svgXml;
+      // Clearing marks the shapes stale - the render layer rebuilds them from SvgData.
+      plannerElement.cleanShapeOLF2D();
+      plannerElement.cleanShapeOLT2D();
+    }
+  }, {
+    key: "getMinBorderSVG",
+    value: function getMinBorderSVG(svgXml) {
+      var minBorder = getMinBorder(svgXml);
+      return {
+        svgMinXVal: minBorder.minX,
+        svgMinYVal: minBorder.minY
+      };
+    }
+    /*
+      This function is used to load the SVG of the element and set everything up.
+      */
+  }, {
+    key: "loadSVG",
+    value: (function () {
+      var _loadSVG = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(plannerElement, set) {
+        var _this = this;
+        var svgFile, svgContentXML, svgContent, result, svgNewWidth, svgNewDepth, sizes, minBoderSVG, svgSourceUrl, correctedContent;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              svgFile = plannerElement.SvgFileName;
+              if (svgFile) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return", false);
+            case 3:
+              if (!set.CatalogData.isIDMFormat) {
+                _context.next = 9;
+                break;
+              }
+              _context.next = 6;
+              return set.api.fetchData(svgFile, {
+                method: 'GET',
+                config: {},
+                data: {}
+              });
+            case 6:
+              svgContentXML = _context.sent;
+              _context.next = 16;
+              break;
+            case 9:
+              _context.next = 11;
+              return set.api.getDataCache(this.getSVGUrl(svgFile, set.CatalogData.mediaUrl), undefined, set.CatalogData.accountSessionGuid);
+            case 11:
+              result = _context.sent;
+              if (!result.Error) {
+                _context.next = 14;
+                break;
+              }
+              throw new Error(result.Error);
+            case 14:
+              if (result.Result.toLowerCase() == 'success') {
+                svgContent = result.Content;
+              }
+              svgContentXML = DivaUtils.decodeBase64(svgContent);
+            case 16:
+              if (!svgContentXML) {
+                LOG.error(new DivaError('Fehler beim laden des SVGs ', {
+                  code: 'WC_0009',
+                  custom: {
+                    svgFile: svgFile
+                  }
+                }));
+              }
+              plannerElement.svgBefore = svgContentXML;
+              svgNewWidth = plannerElement.Width;
+              svgNewDepth = plannerElement.Depth;
+              //fix for "kissen" that didnt had a depth but do have a height https://app.asana.com/0/1201426433314773/1201432109700389
+              if (svgNewDepth === -1 && plannerElement.Height !== -1) svgNewDepth = plannerElement.Height;
+              if (!(svgNewWidth != undefined && svgNewWidth > 0 && svgNewDepth != undefined && svgNewDepth > 0)) {
+                _context.next = 31;
+                break;
+              }
+              minBoderSVG = this.getMinBorderSVG(svgContentXML);
+              svgSourceUrl = set.CatalogData.isIDMFormat ? svgFile : "".concat(set.CatalogData.mediaUrl, "pln_").concat(svgFile);
+              correctedContent = '';
+              _context.next = 27;
+              return new Promise(function (resolve, reject) {
+                sizes = _this.svgUtils.ccCheckStretchAreas(svgContentXML, svgNewWidth, svgNewDepth, set.CatalogData.useGlobalSVGScale, minBoderSVG.svgMinXVal, minBoderSVG.svgMinYVal, function (_correctedContent) {
+                  correctedContent = _correctedContent;
+                  resolve();
+                }, svgSourceUrl);
+              });
+            case 27:
+              plannerElement.svgAfter = correctedContent;
+              this.parseSvg(plannerElement, correctedContent, minBoderSVG, set.CatalogData.getPlannerConfig(), sizes);
+              _context.next = 33;
+              break;
+            case 31:
+              plannerElement.svgAfter = svgContentXML;
+              this.parseSvg(plannerElement, svgContentXML, {
+                svgMinXVal: 0,
+                svgMinYVal: 0
+              }, set.CatalogData.getPlannerConfig());
+            case 33:
+              return _context.abrupt("return", true);
+            case 34:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function loadSVG(_x, _x2) {
+        return _loadSVG.apply(this, arguments);
+      }
+      return loadSVG;
+    }())
+  }, {
+    key: "getSVGUrl",
+    value: function getSVGUrl(svgFile, mediaUrl) {
+      var url = mediaUrl + 'pln_' + svgFile;
+      //Split url
+      var index = url.indexOf('/files/');
+      url = url.substring(index);
+      return 'function=GetFileAsString' + '&fileUrl=' + encodeURIComponent(url);
+    }
+  }]);
+}();
+var handler2D = new PlannerHandler2D();
+
+export { dockingPointHandlerInst as d, handler2D as h };

package/build/esm/{SeriousBasketHandler-276a8035.js → SeriousBasketHandler-bca9210d.js}

@@ -1,7 +1,7 @@
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { s as summaryHandlerInstance } from './index-358c0a3c.js';
+import { s as summaryHandlerInstance } from './index-b755400a.js';
 import DivaUtils from '@crystaldesign/diva-utils';
 import '@babel/runtime/helpers/slicedToArray';
 import '@babel/runtime/helpers/asyncToGenerator';
@@ -11,12 +11,14 @@ import '@babel/runtime/helpers/toConsumableArray';
 import 'axios';
 import '@crystaldesign/basket-model';
 import '@babel/runtime/helpers/typeof';
+import 'fast-xml-parser';
 import '@babel/runtime/helpers/possibleConstructorReturn';
 import '@babel/runtime/helpers/getPrototypeOf';
 import '@babel/runtime/helpers/inherits';
 import '@babel/runtime/helpers/wrapNativeSuper';
 import '@crystaldesign/basket-handler';
 import 'socket.io-client';
+import '@crystaldesign/planner-2d-core';
 
 //Der in einem Set gemergte Optionsbaum
 var MAIN_COLOR_OPTIONCODEX = 'OPTBE_BOX'; // this field indicates the the main Color. This main color is used in the PDF