kitchen-simulator 1.0.0-DIY-1119

package/lib/reducers/project-reducer.js

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _export = require("../utils/export");
+var _constants = require("../constants");
+var _export2 = require("../class/export");
+function _default(state, action) {
+  switch (action.type) {
+    case _constants.NEW_PROJECT:
+      return _export2.Project.newProject(state).updatedState;
+    case _constants.LOAD_PROJECT:
+      return _export2.Project.loadProject(state, action.sceneJSON).updatedState;
+    case _constants.OPEN_CATALOG:
+      return _export2.Project.openCatalog(state).updatedState;
+    case _constants.CHANGE_CATALOG_PAGE:
+      return _export2.Project.changeCatalogPage(state, action.oldPage, action.newPage).updatedState;
+    case _constants.GO_BACK_TO_CATALOG_PAGE:
+      return _export2.Project.goBackToCatalogPage(state, action.newPage).updatedState;
+    case _constants.SELECT_TOOL_EDIT:
+      return _export2.Project.setMode(state, _constants.MODE_IDLE).updatedState;
+    case _constants.UNSELECT_ALL:
+      return _export2.Project.unselectAll(state).updatedState;
+    case _constants.SELECT_ALL:
+      return _export2.Project.selectAll(state, action.value).updatedState;
+    case _constants.SET_PROPERTIES:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.setProperties(state, state.getIn(['scene', 'selectedLayer']), action.properties).updatedState;
+    case _constants.SET_ITEMS_ATTRIBUTES:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.setItemsAttributes(state, action.itemsAttributes).updatedState;
+    case _constants.SET_LINES_ATTRIBUTES:
+      if (state.mode != _constants.MODE_DRAWING_LINE) state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.setLinesAttributes(state, action.linesAttributes, action.isDirect, action.directData).updatedState;
+    case _constants.SET_HOLES_ATTRIBUTES:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.setHolesAttributes(state, action.holesAttributes).updatedState;
+    case _constants.REMOVE:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.remove(state, action.delObject).updatedState;
+    case _constants.UNDO:
+      return _export2.Project.undo(state).updatedState;
+    case _constants.REDO:
+      return _export2.Project.redo(state).updatedState;
+    case _constants.UNCREATE:
+      return _export2.Project.uncreate(state).updatedState;
+    case _constants.PROJECT_RE_NAME:
+      return _export2.Project.rename(state, action.name).updatedState;
+    case _constants.RECREATE:
+      return _export2.Project.recreate(state).updatedState;
+    case _constants.SHIFT2DOFF:
+      return _export2.Project.shift2doff(state).updatedState;
+    case _constants.SHIFT2DON:
+      return _export2.Project.shift2don(state).updatedState;
+    case _constants.ROLLBACK:
+      return _export2.Project.rollback(state).updatedState;
+    case _constants.SET_PROJECT_PROPERTIES:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.setProjectProperties(state, action.properties).updatedState;
+    case _constants.SET_PROJECT_ID:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.setProjectId(state, action.id).updatedState;
+    case _constants.OPEN_PROJECT_CONFIGURATOR:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.openProjectConfigurator(state).updatedState;
+    case _constants.INIT_CATALOG:
+      return _export2.Project.initCatalog(state, action.catalog).updatedState;
+    case _constants.ADD_ELEMENT_TO_CATALOG:
+      return _export2.Project.addElementToCatalog(state, action.element).updatedState;
+    case _constants.UPDATE_MOUSE_COORDS:
+      return _export2.Project.updateMouseCoord(state, action.coords).updatedState;
+    case _constants.UPDATE_ZOOM_SCALE:
+      return _export2.Project.updateZoomScale(state, action.scale).updatedState;
+    case _constants.TOGGLE_SNAP:
+      return _export2.Project.toggleSnap(state, action.mask).updatedState;
+    case _constants.THROW_ERROR:
+      return _export2.Project.throwError(state, action.error).updatedState;
+    case _constants.THROW_WARNING:
+      return _export2.Project.throwWarning(state, action.warning).updatedState;
+    case _constants.COPY_PROPERTIES:
+      return _export2.Project.copyProperties(state, action.properties).updatedState;
+    case _constants.PASTE_PROPERTIES:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.pasteProperties(state).updatedState;
+    case _constants.PUSH_LAST_SELECTED_CATALOG_ELEMENT_TO_HISTORY:
+      return _export2.Project.pushLastSelectedCatalogElementToHistory(state, action.element).updatedState;
+    case _constants.ALTERATE_STATE:
+      return _export2.Project.setAlterate(state).updatedState;
+    case _constants.SET_MODE:
+      return _export2.Project.setMode(state, action.mode).updatedState;
+    case _constants.ADD_HORIZONTAL_GUIDE:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.addHorizontalGuide(state, action.coordinate).updatedState;
+    case _constants.ADD_VERTICAL_GUIDE:
+      return _export2.Project.addVerticalGuide(state, action.coordinate).updatedState;
+    case _constants.ADD_CIRCULAR_GUIDE:
+      return _export2.Project.addCircularGuide(state, action.x, action.y, action.radius).updatedState;
+    case _constants.REMOVE_HORIZONTAL_GUIDE:
+      return _export2.Project.removeHorizontalGuide(state, action.guideID).updatedState;
+    case _constants.REMOVE_VERTICAL_GUIDE:
+      return _export2.Project.removeVerticalGuide(state, action.guideID).updatedState;
+    case _constants.REMOVE_CIRCULAR_GUIDE:
+      return _export2.Project.removeCircularGuide(state, action.guideID).updatedState;
+    case _constants.REMOVE_DRAWING_SUPPORT:
+      return _export2.Project.removeDrawingSupport(state).updatedState;
+    case _constants.SET_STATE_PROPERTIES:
+      return _export2.Project.setStateProperties(state, action.properties).updatedState;
+    case _constants.SET_IS_HELP:
+      return _export2.Project.setIsHelp(state, action.isHelp).updatedState;
+    case _constants.SET_IS_CABINET_DRAWING:
+      return _export2.Project.setIsCabinetDrawing(state, action.isCabinetDrawing).updatedState;
+    case _constants.CREATE_ROOM_WITH_SHAPE:
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Project.createRoomWithShape(state, action.roomShapeType, action.width, action.height, action.measurementUnit, action.doorStyle).updatedState;
+    default:
+      return state;
+  }
+}
+module.exports = exports.default;

package/lib/reducers/reducer.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = appReducer;
+exports.initialState = void 0;
+var _constants = require("../constants");
+var _export = require("./export");
+var _models = require("../models");
+var initialState = exports.initialState = new _models.State();
+function appReducer(state, action) {
+  // /////////
+  if (_constants.PROJECT_ACTIONS[action.type]) return _export.KitchenConfiguratorProjectReducer.apply(void 0, arguments);
+  if (_constants.VIEWER2D_ACTIONS[action.type]) return _export.KitchenConfiguratorViewer2dReducer.apply(void 0, arguments);
+  if (_constants.VIEWER3D_ACTIONS[action.type]) return _export.KitchenConfiguratorViewer3dReducer.apply(void 0, arguments);
+  if (_constants.ITEMS_ACTIONS[action.type]) return _export.KitchenConfiguratorItemsReducer.apply(void 0, arguments);
+  if (_constants.HOLE_ACTIONS[action.type]) return _export.KitchenConfiguratorHolesReducer.apply(void 0, arguments);
+  if (_constants.LINE_ACTIONS[action.type]) return _export.KitchenConfiguratorLinesReducer.apply(void 0, arguments);
+  if (_constants.AREA_ACTIONS[action.type]) return _export.KitchenConfiguratorAreasReducer.apply(void 0, arguments);
+  if (_constants.GROUP_ACTIONS[action.type]) return _export.KitchenConfiguratorGroupsReducer.apply(void 0, arguments);
+  if (_constants.SCENE_ACTIONS[action.type]) return _export.KitchenConfiguratorSceneReducer.apply(void 0, arguments);
+  if (_constants.VERTEX_ACTIONS[action.type]) return _export.KitchenConfiguratorVerticesReducer.apply(void 0, arguments);
+  return state || initialState;
+}

package/lib/reducers/scene-reducer.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _export = require("../class/export");
+var _export2 = require("../utils/export");
+var _constants = require("../constants");
+function _default(state, action) {
+  var saveHistory = function saveHistory() {
+    return state = state.merge({
+      sceneHistory: _export2.history.historyPush(state.sceneHistory, state.scene)
+    });
+  };
+  switch (action.type) {
+    case _constants.ADD_LAYER:
+      saveHistory();
+      return _export.Layer.create(state, action.name, action.altitude).updatedState;
+    case _constants.SELECT_LAYER:
+      saveHistory();
+      return _export.Layer.select(state, action.layerID).updatedState;
+    case _constants.SET_LAYER_PROPERTIES:
+      saveHistory();
+      return _export.Layer.setProperties(state, action.layerID, action.properties).updatedState;
+    case _constants.REMOVE_LAYER:
+      saveHistory();
+      return _export.Layer.remove(state, action.layerID).updatedState;
+    case _constants.UPDATE_MOVING_STATE:
+      return _export.Layer.updateMovingState(state, action.showflag).updatedState;
+    default:
+      return state;
+  }
+}
+module.exports = exports.default;

package/lib/reducers/vertices-reducer.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _constants = require("../constants");
+var _export = require("../utils/export");
+var _export2 = require("../class/export");
+function _default(state, action) {
+  switch (action.type) {
+    case _constants.BEGIN_DRAGGING_VERTEX:
+      return _export2.Vertex.beginDraggingVertex(state, action.layerID, action.vertexID, action.x, action.y).updatedState;
+    case _constants.UPDATE_DRAGGING_VERTEX:
+      return _export2.Vertex.updateDraggingVertex(state, action.x, action.y).updatedState;
+    case _constants.END_DRAGGING_VERTEX:
+      // Code that saving the scene history (26 ~ 28)
+      state = state.merge({
+        sceneHistory: _export.history.historyPush(state.sceneHistory, state.scene)
+      });
+      return _export2.Vertex.endDraggingVertex(state, action.x, action.y).updatedState;
+    default:
+      return state;
+  }
+}
+module.exports = exports.default;

package/lib/reducers/viewer2d-reducer.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _constants = require("../constants");
+var _convertUnitsLite = require("../utils/convert-units-lite");
+function _default(state, action) {
+  var _state = state,
+    scene = _state.scene;
+  switch (action.type) {
+    case _constants.UPDATE_CEIL_HEIGHT_UNIT:
+      {
+        var _state2 = state,
+          _scene = _state2.scene;
+        var selectedLayer = _scene.selectedLayer;
+        var layer = _scene.layers.get(selectedLayer);
+        var newLayer = layer.merge({
+          unit: action.value
+        });
+        state = state.mergeIn(['scene', 'layers', selectedLayer], newLayer);
+        return state;
+      }
+    case _constants.UPDATE_CEIL_HEIGHT:
+      {
+        var _selectedLayer = scene.selectedLayer;
+        var _layer = scene.layers.get(_selectedLayer);
+        var _newLayer = _layer.merge({
+          ceilHeight: action.value
+        });
+        state = state.mergeIn(['scene', 'layers', _selectedLayer], _newLayer);
+        var items = state.scene.layers.get(state.scene.selectedLayer).items;
+        var newItems = items.map(function (item) {
+          if (item.type.includes('Light')) {
+            var height = item.properties.getIn(['height', '_length']);
+            var heightUnit = item.properties.getIn(['height', '_unit']);
+            var newAltitude = (0, _convertUnitsLite.convert)(action.value).from(_layer.unit).to('in') - (0, _convertUnitsLite.convert)(height).from(heightUnit).to('in');
+            item = item.setIn(['properties', 'altitude', '_length'], (0, _convertUnitsLite.convert)(newAltitude).from('in').to(_layer.unit));
+            item = item.setIn(['properties', 'altitude', '_unit'], _layer.unit);
+            item = item.setIn(['properties', 'altitude', 'length'], (0, _convertUnitsLite.convert)(newAltitude).from('in').to('cm'));
+          }
+          return item;
+        });
+        state = state.mergeIn(['scene', 'layers', _selectedLayer, 'items'], newItems);
+        return state;
+      }
+    case _constants.UPDATE_2D_CAMERA:
+      return state.merge({
+        viewer2D: action.value
+      });
+    case _constants.CHANGE_WALL_LENGTH_MEASURE:
+      return state.merge({
+        scene: scene.merge({
+          showWallLengthMeasure: action.value
+        })
+      });
+    case _constants.CHANGE_BASE_CABINET_MEASURE:
+      return state.merge({
+        scene: scene.merge({
+          showBaseCabinetMeasure: action.value
+        })
+      });
+    case _constants.CHANGE_WALL_CABINET_MEASURE:
+      return state.merge({
+        scene: scene.merge({
+          showWallCabinetMeasure: action.value
+        })
+      });
+    case _constants.CHANGE_WINDOW_DOOR_MEASURE:
+      return state.merge({
+        scene: scene.merge({
+          showWindowDoorMeasure: action.value
+        })
+      });
+    case _constants.SELECT_TOOL_PAN:
+      return state.set('mode', _constants.MODE_2D_PAN);
+    case _constants.SELECT_TOOL_ZOOM_IN:
+      return state.set('mode', _constants.MODE_2D_ZOOM_IN);
+    case _constants.SELECT_TOOL_ZOOM_OUT:
+      return state.set('mode', _constants.MODE_2D_ZOOM_OUT);
+  }
+}
+module.exports = exports.default;

package/lib/reducers/viewer3d-reducer.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+var _constants = require("../constants");
+var _export = require("../class/export");
+var _export2 = require("../utils/export");
+var _convertUnitsLite = require("../utils/convert-units-lite");
+function _default(state, action) {
+  state = state.merge({
+    sceneHistory: _export2.history.historyPush(state.sceneHistory, state.scene)
+  });
+  switch (action.type) {
+    case _constants.UPDATE_3D_CEIL_HEIGHT_UNIT:
+      {
+        var _state = state,
+          scene = _state.scene;
+        var selectedLayer = scene.selectedLayer;
+        var layer = scene.layers.get(selectedLayer);
+        var newLayer = layer.merge({
+          unit: action.value
+        });
+        state = state.mergeIn(['scene', 'layers', selectedLayer], newLayer);
+        return state;
+      }
+    case _constants.UPDATE_3D_CEIL_HEIGHT:
+      {
+        var _state2 = state,
+          _scene = _state2.scene;
+        var _selectedLayer = _scene.selectedLayer;
+        var _layer = _scene.layers.get(_selectedLayer);
+        var _newLayer = _layer.merge({
+          ceilHeight: action.value
+        });
+        state = state.mergeIn(['scene', 'layers', _selectedLayer], _newLayer);
+        var items = state.scene.layers.get(state.scene.selectedLayer).items;
+        var newItems = items.map(function (item) {
+          if (item.type.includes('Light')) {
+            var height = item.properties.getIn(['height', '_length']);
+            var heightUnit = item.properties.getIn(['height', '_unit']);
+            var newAltitude = (0, _convertUnitsLite.convert)(action.value).from(_layer.unit).to('in') - (0, _convertUnitsLite.convert)(height).from(heightUnit).to('in');
+            item = item.setIn(['properties', 'altitude', '_length'], (0, _convertUnitsLite.convert)(newAltitude).from('in').to(_layer.unit));
+            item = item.setIn(['properties', 'altitude', '_unit'], _layer.unit);
+            item = item.setIn(['properties', 'altitude', 'length'], (0, _convertUnitsLite.convert)(newAltitude).from('in').to('cm'));
+          }
+          return item;
+        });
+        state = state.mergeIn(['scene', 'layers', _selectedLayer, 'items'], newItems);
+        return state;
+      }
+    case _constants.SELECT_TOOL_3D_VIEW:
+      state = _export.Project.rollback(state).updatedState;
+      state = _export.Project.setMode(state, _constants.MODE_3D_VIEW).updatedState;
+      return state;
+    case _constants.SELECT_TOOL_3D_FIRST_PERSON:
+      state = _export.Project.rollback(state).updatedState;
+      state = _export.Project.setMode(state, _constants.MODE_3D_FIRST_PERSON).updatedState;
+      return state;
+    default:
+      return state;
+  }
+}
+module.exports = exports.default;

package/lib/shared/concurrency/async-pool.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncPool = asyncPool;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+/**
+ * Run async work over a list with a concurrency limit.
+ *
+ * @template T,R
+ * @param {number} limit number of concurrently executing promises
+ * @param {T[]} items input items
+ * @param {(item: T, index: number) => Promise<R>} iteratorFn async function
+ * @returns {Promise<R[]>} results in input order
+ */
+function asyncPool(_x, _x2, _x3) {
+  return _asyncPool.apply(this, arguments);
+}
+function _asyncPool() {
+  _asyncPool = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(limit, items, iteratorFn) {
+    var safeLimit, ret, executing, _loop, i, _items$length;
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          safeLimit = Math.max(1, Number(limit) || 1);
+          ret = [];
+          executing = new Set();
+          _loop = /*#__PURE__*/_regenerator["default"].mark(function _loop(i) {
+            var item, p, cleanup;
+            return _regenerator["default"].wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  item = items[i];
+                  p = Promise.resolve().then(function () {
+                    return iteratorFn(item, i);
+                  });
+                  ret.push(p);
+                  executing.add(p);
+                  cleanup = function cleanup() {
+                    return executing["delete"](p);
+                  };
+                  p.then(cleanup)["catch"](cleanup);
+                  if (!(executing.size >= safeLimit)) {
+                    _context.next = 1;
+                    break;
+                  }
+                  _context.next = 1;
+                  return Promise.race(executing);
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop);
+          });
+          i = 0;
+        case 1:
+          if (!(i < ((_items$length = items === null || items === void 0 ? void 0 : items.length) !== null && _items$length !== void 0 ? _items$length : 0))) {
+            _context2.next = 3;
+            break;
+          }
+          return _context2.delegateYield(_loop(i), "t0", 2);
+        case 2:
+          i++;
+          _context2.next = 1;
+          break;
+        case 3:
+          return _context2.abrupt("return", Promise.all(ret));
+        case 4:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee);
+  }));
+  return _asyncPool.apply(this, arguments);
+}

package/lib/shared/domain/asset/load-asset-json.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadJSONWithFallback = loadJSONWithFallback;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _loadJson = require("../../network/load-json");
+var _sanitizeAssetUrl = require("./sanitize-asset-url");
+function loadJSONWithFallback(_x) {
+  return _loadJSONWithFallback.apply(this, arguments);
+}
+function _loadJSONWithFallback() {
+  _loadJSONWithFallback = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(path) {
+    var sanitized, _t, _t2;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (path) {
+            _context.next = 1;
+            break;
+          }
+          return _context.abrupt("return", null);
+        case 1:
+          sanitized = (0, _sanitizeAssetUrl.sanitizeAssetUrl)(path);
+          _context.prev = 2;
+          _context.next = 3;
+          return (0, _loadJson.loadJSON)(path);
+        case 3:
+          return _context.abrupt("return", _context.sent);
+        case 4:
+          _context.prev = 4;
+          _t = _context["catch"](2);
+          console.warn('[GLTF load failed, retrying with sanitized URL]', sanitized);
+          _context.prev = 5;
+          if (!(!sanitized || sanitized === path)) {
+            _context.next = 6;
+            break;
+          }
+          throw _t;
+        case 6:
+          _context.next = 7;
+          return (0, _loadJson.loadJSON)(sanitized);
+        case 7:
+          return _context.abrupt("return", _context.sent);
+        case 8:
+          _context.prev = 8;
+          _t2 = _context["catch"](5);
+          console.error('[GLTF load failed after retry]');
+          return _context.abrupt("return", null);
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 4], [5, 8]]);
+  }));
+  return _loadJSONWithFallback.apply(this, arguments);
+}

package/lib/shared/domain/asset/sanitize-asset-url.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeAssetUrl = void 0;
+/**
+ * Strip stray dots from the **path portion** of a GLTF/BIN URL.
+ * e.g. `…/B36_36x34.5x24.gltf` → `…/B36_36x345x24.gltf`
+ *
+ * Leaves the protocol/domain and the final file extension untouched.
+ */
+var sanitizeAssetUrl = exports.sanitizeAssetUrl = function sanitizeAssetUrl(url) {
+  if (!url) return url;
+  var parsed = new URL(url);
+
+  // If the URL starts with the S3 base, only sanitize the path after it.
+  var base = parsed.origin; // https://industry-media.addovisuals.com
+  var hasBase = base && url.startsWith(base);
+  var prefix = hasBase ? base : '';
+  var rest = hasBase ? url.substring(base.length) : url;
+
+  // Find the last dot in the remaining part — that's the file extension.
+  var lastDotIdx = rest.lastIndexOf('.');
+  if (lastDotIdx === -1) return url;
+  var pathPart = rest.substring(0, lastDotIdx);
+  var extension = rest.substring(lastDotIdx); // e.g. ".gltf"
+
+  // Remove all dots in the path portion (they're dimension separators like 34.5).
+  return prefix + pathPart.replace(/\./g, '') + extension;
+};

package/lib/shared/domain/cabinet-corner.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCornerCabinet = exports.isCorner = void 0;
+var isCorner = exports.isCorner = function isCorner(value) {
+  return value === 1 || value === true || value === '1' || value === 'true';
+};
+var isCornerCabinet = exports.isCornerCabinet = function isCornerCabinet(cabinet) {
+  return isCorner(cabinet === null || cabinet === void 0 ? void 0 : cabinet.is_corner);
+};

package/lib/shared/domain/cabinet-mirror.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canMirrorCabinet = canMirrorCabinet;
+var _constants = require("../../constants");
+var _immutable = require("../objects/immutable");
+function canMirrorCabinet(item) {
+  var js = (0, _immutable.toJSIfNeeded)(item);
+  var isCabinet = (js === null || js === void 0 ? void 0 : js.category) === _constants.ITEM_TYPE.CABINET || (js === null || js === void 0 ? void 0 : js.type) === _constants.ITEM_TYPE.CABINET;
+  return isCabinet && (js === null || js === void 0 ? void 0 : js.can_be_mirrored) === true;
+}

package/lib/shared/domain/cabinet-warning.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWarningCabinet = isWarningCabinet;
+var _constants = require("../../constants");
+var _immutable = require("../objects/immutable");
+// Centralized warning heuristic for cabinets across 2D/3D.
+// Rule: a cabinet is "warning" when there are no assets for the current door style.
+
+// Implementation: return true if item.category === 'cabinet' and (no ccdf or empty ccdf.assets3d)
+function isWarningCabinet(item) {
+  var _js$ccdf;
+  var js = (0, _immutable.toJSIfNeeded)(item);
+  var isCabinet = (js === null || js === void 0 ? void 0 : js.category) === _constants.ITEM_TYPE.CABINET;
+  return isCabinet && !(js !== null && js !== void 0 && (_js$ccdf = js.ccdf) !== null && _js$ccdf !== void 0 && _js$ccdf.is_available_in_current_door_finish);
+}

package/lib/shared/math/line-metrics.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLineLength = getLineLength;
+var _convertUnitsLite = require("../../utils/convert-units-lite");
+function getVertexId(lineVertices, index) {
+  if (!lineVertices) return null;
+  return typeof lineVertices.get === 'function' ? lineVertices.get(index) : lineVertices[index];
+}
+function getVertex(vertices, vertexId) {
+  if (!vertices || vertexId == null) return null;
+  return typeof vertices.get === 'function' ? vertices.get(vertexId) : vertices[vertexId];
+}
+
+/**
+ * Computes a line length using its 2 vertices.
+ *
+ * Assumptions (matches existing DRAG logic):
+ * - vertex coordinates are stored in centimeters
+ * - result is converted to the provided unit
+ *
+ * @param {object} line - line object/record with `vertices` (array or immutable List)
+ * @param {object} vertices - vertices collection (plain object map or immutable Map)
+ * @param {string} unit - target unit (e.g. 'in', 'cm')
+ * @returns {number|null}
+ */
+function getLineLength(line, vertices) {
+  var _v0$x, _v1$x, _v0$y, _v1$y;
+  var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'cm';
+  var lineVertices = line === null || line === void 0 ? void 0 : line.vertices;
+  var v0Id = getVertexId(lineVertices, 0);
+  var v1Id = getVertexId(lineVertices, 1);
+  var v0 = getVertex(vertices, v0Id);
+  var v1 = getVertex(vertices, v1Id);
+  if (!v0 || !v1) return null;
+  var distanceCm = Math.hypot(((_v0$x = v0.x) !== null && _v0$x !== void 0 ? _v0$x : 0) - ((_v1$x = v1.x) !== null && _v1$x !== void 0 ? _v1$x : 0), ((_v0$y = v0.y) !== null && _v0$y !== void 0 ? _v0$y : 0) - ((_v1$y = v1.y) !== null && _v1$y !== void 0 ? _v1$y : 0));
+  return (0, _convertUnitsLite.convert)(distanceCm).from('cm').to(unit);
+}