kitchen-simulator 3.1.15 → 3.3.0

package/es/catalog/utils/exporter.js

@@ -137,6 +137,7 @@ export default function (_ref) {
     img: base,
     obj: obj_property,
     cds: cds,
+    structure_json: structure_json,
     render2D: function render2D(element, layer, scene) {
       return render2DItem.call(this, element, layer, scene, sizeinfo, layoutpos, is_corner, shape_svg);
     },

package/es/components/viewer3d/scene-creator.js

@@ -16,7 +16,7 @@ import { verticesDistance } from "../../utils/geometry";
 import * as GeomUtils from "../../catalog/utils/geom-utils";
 import { loadTexture } from "../../catalog/utils/item-loader";
 import { returnReplaceableDeepSearchType } from "../viewer2d/utils";
-import { animateDoor, isElevationView, isEmpty, replaceMeshesWithLineSegments, translateDrawer } from "../../utils/helper";
+import { animateDoor, isElevationView, isEmpty, isImmutable, replaceMeshesWithLineSegments, translateDrawer } from "../../utils/helper";
 import { formatNumber } from "../../utils/math";
 var transformBox;
 export var fVLine = [];
@@ -187,6 +187,31 @@ export function createWarningObject() {
   warningObj.name = 'warningObj';
   return warningObj;
 }
+function swapLengthProperty(diffs) {
+  var idx1 = diffs.findIndex(function (v) {
+    return v.path[v.path.length - 1] === 'length';
+  });
+  var idx2 = diffs.findIndex(function (v) {
+    return v.path[v.path.length - 1] === '_length';
+  });
+  if (idx1 < 0 || idx2 < 0) return diffs;
+  if (idx1 > idx2) return diffs;
+  if (diffs[idx1].op === diffs[idx2].op) {
+    var isSwap = true;
+    for (var i = 0; i < diffs[idx1].path.length - 2; i++) {
+      if (diffs[idx1].path[i] !== diffs[idx2].path[i]) {
+        isSwap = false;
+        break;
+      }
+    }
+    if (isSwap) {
+      var temp = diffs[idx1];
+      diffs[idx1] = diffs[idx2];
+      diffs[idx2] = temp;
+    }
+  }
+  return diffs;
+}
 export function updateScene(planData, sceneData, oldSceneData, diffArray, actions, catalog) {
   var _draggingItem$toJS, _filteredDiffs, _filteredDiffs2;
   var mode = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
@@ -204,6 +229,9 @@ export function updateScene(planData, sceneData, oldSceneData, diffArray, action
       value: el.value
     };
   });
+
+  // move "length" to after "_length"
+  splitted = swapLengthProperty(splitted);
   var filteredDiffs = filterDiffs(splitted, sceneData, oldSceneData);
   //***testing additional filter***
   filteredDiffs = filteredDiffs.filter(function (_ref) {
@@ -3418,9 +3446,11 @@ export function updateMoldingGroupArray(MGArray, selItem, planData, layer) {
       // refresh mesh of the updating molding groups
       new_MGArray.forEach(function (mg, index) {
         if (mg.items[0].molding.some(function (mol) {
-          return mol.location_type === mg.location_type;
+          return isImmutable(mol) ? mol.toJS().location_type === mg.location_type : mol.location_type === mg.location_type;
         })) {
-          var molding = mg.items[0].molding.filter(function (mol) {
+          var molding = isImmutable(mg.items[0].molding) ? mg.items[0].molding.filter(function (mol) {
+            return mol.toJS().location_type === mg.location_type;
+          }).toJS()[0] : mg.items[0].molding.filter(function (mol) {
             return mol.location_type === mg.location_type;
           })[0];
           if (mg.molding === null || mg.molding.itemID !== mol.itemID || mg.lines === null || mg.points === null) {

package/es/components/viewer3d/viewer3d.js

@@ -1490,8 +1490,8 @@ var Scene3DViewer = /*#__PURE__*/function (_React$Component) {
           }
           gridMatrix.copy(gridPlane.matrixWorld).invert();
           var addItemToolObj = function addItemToolObj() {
-            var _intersects$_i;
-            var selectedItem = planData.sceneGraph.layers[selectedObject.layerID].items[selectedObject.itemID];
+            var _planData$sceneGraph, _selectedObject, _intersects$_i;
+            var selectedItem = (_planData$sceneGraph = planData.sceneGraph) === null || _planData$sceneGraph === void 0 || (_planData$sceneGraph = _planData$sceneGraph.layers[selectedObject.layerID]) === null || _planData$sceneGraph === void 0 ? void 0 : _planData$sceneGraph.items[(_selectedObject = selectedObject) === null || _selectedObject === void 0 ? void 0 : _selectedObject.itemID];
             if (isUndefined(selectedItem)) return;
             selectedElement = _this2.props.state.scene.layers.get(selectedObject.layerID).items.get(selectedObject.itemID);
             var itemPos = selectedItem.position.clone();
@@ -1592,6 +1592,7 @@ var Scene3DViewer = /*#__PURE__*/function (_React$Component) {
               selectedObj = allItemRect.cur;
             }
           } else {
+            var _planData$sceneGraph2, _selectedObject2, _selectedObject3;
             visibleTransformBox(false);
             var alti = 0;
             if (allItemRect && allItemRect.cur && allItemRect.cur.itemInfo !== undefined) {
@@ -1601,16 +1602,17 @@ var Scene3DViewer = /*#__PURE__*/function (_React$Component) {
               alti = convert(alti).from(_unit2).to(_this2.props.state.scene.unit);
             }
             getPoint(event, alti);
+            var _selectedItem = planData === null || planData === void 0 || (_planData$sceneGraph2 = planData.sceneGraph) === null || _planData$sceneGraph2 === void 0 || (_planData$sceneGraph2 = _planData$sceneGraph2.layers[(_selectedObject2 = selectedObject) === null || _selectedObject2 === void 0 ? void 0 : _selectedObject2.layerID]) === null || _planData$sceneGraph2 === void 0 ? void 0 : _planData$sceneGraph2.items[(_selectedObject3 = selectedObject) === null || _selectedObject3 === void 0 ? void 0 : _selectedObject3.itemID];
+            if (isSelected && !isEmpty(_selectedItem)) addItemToolObj();
             if (bRotate) {
-              addItemToolObj();
               _this2.setState({
                 toolObj: toolObj
               });
               _this2.context.itemsActions.endRotatingItem3D(Point.x, Point.y);
               bRotate = false;
-            } else if (bMove) {
+            }
+            if (bMove) {
               bMove = false;
-              addItemToolObj();
               _this2.setState({
                 toolObj: toolObj
               });
@@ -1630,7 +1632,7 @@ var Scene3DViewer = /*#__PURE__*/function (_React$Component) {
                 _item3D.position.z = targetPoint.z;
                 _item3D.visible = true;
               }
-            } else {}
+            }
             if (bMoveUP) {
               bMoveUP = false;
             }

package/es/index.js

@@ -4,26 +4,335 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 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 _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; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import React from 'react';
-import ReactDOM from 'react-dom';
 import LiteRenderer from "./LiteRenderer";
+import { createRoot } from 'react-dom/client';
+function nextFrame() {
+  return new Promise(function (resolve) {
+    return requestAnimationFrame(resolve);
+  });
+}
+function sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+}
+
+/**
+ * Track GLTF/GLB network activity via XHR + fetch.
+ * Returns { getInFlight, waitForIdle, uninstall }.
+ */
+function installGltfTracker() {
+  var _XHR$prototype, _XHR$prototype2;
+  if (typeof window === 'undefined') {
+    return {
+      getInFlight: function getInFlight() {
+        return 0;
+      },
+      waitForIdle: function () {
+        var _waitForIdle = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+          return _regeneratorRuntime.wrap(function (_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return", true);
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        function waitForIdle() {
+          return _waitForIdle.apply(this, arguments);
+        }
+        return waitForIdle;
+      }(),
+      uninstall: function uninstall() {}
+    };
+  }
+  var inFlight = 0;
+  var listeners = new Set();
+  var notify = function notify() {
+    var _iterator = _createForOfIteratorHelper(listeners),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var fn = _step.value;
+        fn(inFlight);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+  var isGltfUrl = function isGltfUrl(url) {
+    try {
+      var _url$toString, _url$toString2;
+      var s = typeof url === 'string' ? url : (_url$toString = url === null || url === void 0 || (_url$toString2 = url.toString) === null || _url$toString2 === void 0 ? void 0 : _url$toString2.call(url)) !== null && _url$toString !== void 0 ? _url$toString : '';
+      var u = s.toLowerCase();
+      return u.includes('.gltf') || u.includes('.glb');
+    } catch (_unused) {
+      return false;
+    }
+  };
+
+  // ---- XHR hook ----
+  var XHR = window.XMLHttpRequest;
+  var originalOpen = null;
+  var originalSend = null;
+  if (XHR !== null && XHR !== void 0 && (_XHR$prototype = XHR.prototype) !== null && _XHR$prototype !== void 0 && _XHR$prototype.open && XHR !== null && XHR !== void 0 && (_XHR$prototype2 = XHR.prototype) !== null && _XHR$prototype2 !== void 0 && _XHR$prototype2.send) {
+    originalOpen = XHR.prototype.open;
+    originalSend = XHR.prototype.send;
+    XHR.prototype.open = function (method, url) {
+      var _originalOpen;
+      this.__isGltfRequest = isGltfUrl(url);
+      for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        rest[_key - 2] = arguments[_key];
+      }
+      return (_originalOpen = originalOpen).call.apply(_originalOpen, [this, method, url].concat(rest));
+    };
+    XHR.prototype.send = function () {
+      var _this = this;
+      if (this.__isGltfRequest) {
+        inFlight += 1;
+        notify();
+        var _done = function done() {
+          inFlight -= 1;
+          if (inFlight < 0) inFlight = 0;
+          notify();
+          _this.removeEventListener('loadend', _done);
+        };
+        this.addEventListener('loadend', _done);
+      }
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return originalSend.apply(this, args);
+    };
+  }
+
+  // ---- fetch hook ----
+  var originalFetch = window.fetch;
+  if (typeof originalFetch === 'function') {
+    window.fetch = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _len3,
+        args,
+        _key3,
+        url,
+        track,
+        _args2 = arguments;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            for (_len3 = _args2.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+              args[_key3] = _args2[_key3];
+            }
+            url = args === null || args === void 0 ? void 0 : args[0];
+            track = isGltfUrl(url);
+            if (track) {
+              _context2.next = 1;
+              break;
+            }
+            return _context2.abrupt("return", originalFetch.apply(this, args));
+          case 1:
+            inFlight += 1;
+            notify();
+            _context2.prev = 2;
+            _context2.next = 3;
+            return originalFetch.apply(this, args);
+          case 3:
+            return _context2.abrupt("return", _context2.sent);
+          case 4:
+            _context2.prev = 4;
+            inFlight -= 1;
+            if (inFlight < 0) inFlight = 0;
+            notify();
+            return _context2.finish(4);
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this, [[2,, 4, 5]]);
+    }));
+  }
+  var subscribe = function subscribe(fn) {
+    listeners.add(fn);
+    fn(inFlight);
+    return function () {
+      return listeners["delete"](fn);
+    };
+  };
+
+  /**
+   * Wait until GLTF network is idle (inFlight===0).
+   * Includes a grace window to catch loads that start slightly after the event.
+   */
+  var waitForIdle = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var _ref3,
+        _ref3$timeoutMs,
+        timeoutMs,
+        _ref3$graceMs,
+        graceMs,
+        start,
+        _args3 = arguments;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _ref3 = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {}, _ref3$timeoutMs = _ref3.timeoutMs, timeoutMs = _ref3$timeoutMs === void 0 ? 30000 : _ref3$timeoutMs, _ref3$graceMs = _ref3.graceMs, graceMs = _ref3$graceMs === void 0 ? 50 : _ref3$graceMs;
+            start = Date.now(); // Grace: give async pipelines a chance to start requests
+            if (!(graceMs > 0)) {
+              _context3.next = 1;
+              break;
+            }
+            _context3.next = 1;
+            return sleep(graceMs);
+          case 1:
+            return _context3.abrupt("return", new Promise(function (resolve, reject) {
+              var unsub = subscribe(function (count) {
+                if (count === 0) {
+                  unsub();
+                  resolve(true);
+                  return;
+                }
+                if (Date.now() - start > timeoutMs) {
+                  unsub();
+                  reject(new Error('GLTF did not become idle within timeout'));
+                }
+              });
+            }));
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return function waitForIdle() {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+  var uninstall = function uninstall() {
+    var _XHR$prototype3, _XHR$prototype4;
+    if (XHR !== null && XHR !== void 0 && (_XHR$prototype3 = XHR.prototype) !== null && _XHR$prototype3 !== void 0 && _XHR$prototype3.open && originalOpen) XHR.prototype.open = originalOpen;
+    if (XHR !== null && XHR !== void 0 && (_XHR$prototype4 = XHR.prototype) !== null && _XHR$prototype4 !== void 0 && _XHR$prototype4.send && originalSend) XHR.prototype.send = originalSend;
+    if (typeof originalFetch === 'function') window.fetch = originalFetch;
+    listeners.clear();
+    inFlight = 0;
+  };
+  return {
+    getInFlight: function getInFlight() {
+      return inFlight;
+    },
+    waitForIdle: waitForIdle,
+    uninstall: uninstall
+  };
+}
 export function renderKitchenSimulator(container) {
+  var _props$framesPerEvent, _props$waitForGltfIdl, _props$gltfTimeoutMs, _props$gltfGraceMs;
   var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var root = createRoot(container);
   var setExternalEventFn = null;
+  var queue = [];
+  var pendingMarkers = new Set();
+  var draining = false;
+  var destroyed = false;
+  var FRAMES_PER_EVENT = (_props$framesPerEvent = props.framesPerEvent) !== null && _props$framesPerEvent !== void 0 ? _props$framesPerEvent : 2;
+
+  // ✅ assume all events may load gltfs
+  var WAIT_FOR_GLTF_IDLE_AFTER_EACH_EVENT = (_props$waitForGltfIdl = props.waitForGltfIdleAfterEachEvent) !== null && _props$waitForGltfIdl !== void 0 ? _props$waitForGltfIdl : true;
+  var GLTF_TIMEOUT_MS = (_props$gltfTimeoutMs = props.gltfTimeoutMs) !== null && _props$gltfTimeoutMs !== void 0 ? _props$gltfTimeoutMs : 30000;
+  var GLTF_GRACE_MS = (_props$gltfGraceMs = props.gltfGraceMs) !== null && _props$gltfGraceMs !== void 0 ? _props$gltfGraceMs : 50;
+  var gltfTracker = installGltfTracker();
+  function drain() {
+    return _drain.apply(this, arguments);
+  }
+  function _drain() {
+    _drain = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+      var _setExternalEventFn, ev, i, _ev$gltfTimeoutMs, _ev$gltfGraceMs;
+      return _regeneratorRuntime.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            if (!(draining || destroyed)) {
+              _context5.next = 1;
+              break;
+            }
+            return _context5.abrupt("return");
+          case 1:
+            draining = true;
+            _context5.prev = 2;
+          case 3:
+            if (!(queue.length && !destroyed)) {
+              _context5.next = 10;
+              break;
+            }
+            ev = queue.shift(); // skip internal markers
+            if (!(ev && ev.__batchMarker)) {
+              _context5.next = 4;
+              break;
+            }
+            pendingMarkers["delete"](ev.__batchMarker);
+            return _context5.abrupt("continue", 3);
+          case 4:
+            (_setExternalEventFn = setExternalEventFn) === null || _setExternalEventFn === void 0 || _setExternalEventFn(ev);
 
-  // Internal wrapper that exposes a state setter
+            // baseline spacing for react + legacy lifecycle
+            i = 0;
+          case 5:
+            if (!(i < FRAMES_PER_EVENT)) {
+              _context5.next = 7;
+              break;
+            }
+            _context5.next = 6;
+            return nextFrame();
+          case 6:
+            i += 1;
+            _context5.next = 5;
+            break;
+          case 7:
+            if (!WAIT_FOR_GLTF_IDLE_AFTER_EACH_EVENT) {
+              _context5.next = 9;
+              break;
+            }
+            _context5.next = 8;
+            return gltfTracker.waitForIdle({
+              timeoutMs: (_ev$gltfTimeoutMs = ev === null || ev === void 0 ? void 0 : ev.gltfTimeoutMs) !== null && _ev$gltfTimeoutMs !== void 0 ? _ev$gltfTimeoutMs : GLTF_TIMEOUT_MS,
+              graceMs: (_ev$gltfGraceMs = ev === null || ev === void 0 ? void 0 : ev.gltfGraceMs) !== null && _ev$gltfGraceMs !== void 0 ? _ev$gltfGraceMs : GLTF_GRACE_MS
+            });
+          case 8:
+            _context5.next = 9;
+            return nextFrame();
+          case 9:
+            _context5.next = 3;
+            break;
+          case 10:
+            _context5.prev = 10;
+            draining = false;
+            return _context5.finish(10);
+          case 11:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, null, [[2,, 10, 11]]);
+    }));
+    return _drain.apply(this, arguments);
+  }
   var Wrapper = /*#__PURE__*/function (_React$Component) {
     function Wrapper(p) {
-      var _this;
+      var _this2;
       _classCallCheck(this, Wrapper);
-      _this = _callSuper(this, Wrapper, [p]);
-      _this.state = {
+      _this2 = _callSuper(this, Wrapper, [p]);
+      _this2.state = {
         externalEvent: p.externalEvent || null
       };
-      setExternalEventFn = _this.setExternalEvent.bind(_this);
-      return _this;
+      setExternalEventFn = _this2.setExternalEvent.bind(_this2);
+      return _this2;
     }
     _inherits(Wrapper, _React$Component);
     return _createClass(Wrapper, [{
@@ -41,15 +350,80 @@ export function renderKitchenSimulator(container) {
         }));
       }
     }]);
-  }(React.Component); // Mount once
-  ReactDOM.render(/*#__PURE__*/React.createElement(Wrapper, props), container);
+  }(React.Component);
+  root.render(/*#__PURE__*/React.createElement(Wrapper, props));
   return {
+    sendExternalEvents: function sendExternalEvents(eventOrEvents) {
+      var events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
+      var _iterator2 = _createForOfIteratorHelper(events),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var e = _step2.value;
+          queue.push(e);
+        }
+
+        // marker for this batch
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var token = Symbol('batch');
+      pendingMarkers.add(token);
+      queue.push({
+        __batchMarker: token
+      });
+      drain();
+      return new Promise(function (resolve) {
+        var check = /*#__PURE__*/function () {
+          var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+            return _regeneratorRuntime.wrap(function (_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  if (destroyed) {
+                    _context4.next = 3;
+                    break;
+                  }
+                  if (!pendingMarkers.has(token)) {
+                    _context4.next = 2;
+                    break;
+                  }
+                  _context4.next = 1;
+                  return nextFrame();
+                case 1:
+                  return _context4.abrupt("continue", 0);
+                case 2:
+                  resolve(true);
+                  return _context4.abrupt("return");
+                case 3:
+                  resolve(false);
+                case 4:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4);
+          }));
+          return function check() {
+            return _ref4.apply(this, arguments);
+          };
+        }();
+        check();
+      });
+    },
     updateExternalEvent: function updateExternalEvent(newExternalEvent) {
-      var _setExternalEventFn;
-      (_setExternalEventFn = setExternalEventFn) === null || _setExternalEventFn === void 0 || _setExternalEventFn(newExternalEvent);
+      return this.sendExternalEvents(newExternalEvent);
+    },
+    clearQueue: function clearQueue() {
+      queue.length = 0;
+      pendingMarkers.clear();
     },
     unmount: function unmount() {
-      ReactDOM.unmountComponentAtNode(container);
+      var _this$clearQueue;
+      destroyed = true;
+      (_this$clearQueue = this.clearQueue) === null || _this$clearQueue === void 0 || _this$clearQueue.call(this);
+      gltfTracker.uninstall();
+      root.unmount();
     }
   };
 }

package/es/models.js

@@ -341,7 +341,8 @@ export var CatalogElement = /*#__PURE__*/function (_Record1) {
   properties: new Map(),
   obj: new Map(),
   type: '',
-  cds: new Map()
+  cds: new Map(),
+  structure_json: {}
 }, 'CatalogElement'));
 export var Catalog = /*#__PURE__*/function (_Record10) {
   function Catalog() {