kitchen-simulator 11.0.0-react.18 → 11.0.0

package/lib/utils/threeCSG.es6.js

@@ -0,0 +1,504 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var THREE = _interopRequireWildcard(require("three"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+/*jshint esversion: 6 */
+
+var EPSILON = 1e-5,
+  COPLANAR = 0,
+  FRONT = 1,
+  BACK = 2,
+  SPANNING = 3;
+var ThreeBSP = exports["default"] = /*#__PURE__*/function () {
+  function ThreeBSP(geometry) {
+    (0, _classCallCheck2["default"])(this, ThreeBSP);
+    // Convert THREE.Geometry to ThreeBSP
+    var i,
+      _length_i,
+      face,
+      vertex,
+      faceVertexUvs,
+      uvs,
+      polygon,
+      polygons = [],
+      tree;
+    this.Polygon = Polygon;
+    this.Vertex = Vertex;
+    this.Node = Node;
+    if (geometry instanceof THREE.BufferGeometry) {
+      this.matrix = new THREE.Matrix4();
+    } else if (geometry instanceof THREE.Mesh) {
+      // #todo: add hierarchy support
+      geometry.updateMatrix();
+      this.matrix = geometry.matrix.clone();
+      geometry = geometry.geometry;
+    } else if (geometry instanceof Node) {
+      this.tree = geometry;
+      this.matrix = new THREE.Matrix4();
+      return this;
+    } else {
+      throw 'ThreeBSP: Given geometry is unsupported';
+    }
+    // Retrieve attributes and indices
+    var positionAttribute = geometry.attributes.position;
+    var normalAttribute = geometry.attributes.normal;
+    var uvAttribute = geometry.attributes.uv;
+    var indexAttribute = geometry.index;
+    for (var _i = 0; _i < indexAttribute.count; _i += 3) {
+      polygon = new Polygon();
+      for (var j = 0; j < 3; j++) {
+        var index = indexAttribute.getX(_i + j);
+        var _vertex = new THREE.Vector3().fromBufferAttribute(positionAttribute, index);
+        var normal = new THREE.Vector3().fromBufferAttribute(normalAttribute, index);
+        var _uvs = uvAttribute ? new THREE.Vector2().fromBufferAttribute(uvAttribute, index) : null;
+        var vertexData = new Vertex(_vertex.x, _vertex.y, _vertex.z, normal, _uvs);
+        vertexData.applyMatrix4(this.matrix);
+        polygon.vertices.push(vertexData);
+      }
+      polygon.calculateProperties();
+      polygons.push(polygon);
+    }
+    this.tree = new Node(polygons);
+  }
+  return (0, _createClass2["default"])(ThreeBSP, [{
+    key: "subtract",
+    value: function subtract(other_tree) {
+      var a = this.tree.clone(),
+        b = other_tree.tree.clone();
+      a.invert();
+      a.clipTo(b);
+      b.clipTo(a);
+      b.invert();
+      b.clipTo(a);
+      b.invert();
+      a.build(b.allPolygons());
+      a.invert();
+      a = new ThreeBSP(a);
+      a.matrix = this.matrix;
+      return a;
+    }
+  }, {
+    key: "union",
+    value: function union(other_tree) {
+      var a = this.tree.clone(),
+        b = other_tree.tree.clone();
+      a.clipTo(b);
+      b.clipTo(a);
+      b.invert();
+      b.clipTo(a);
+      b.invert();
+      a.build(b.allPolygons());
+      a = new ThreeBSP(a);
+      a.matrix = this.matrix;
+      return a;
+    }
+  }, {
+    key: "intersect",
+    value: function intersect(other_tree) {
+      var a = this.tree.clone(),
+        b = other_tree.tree.clone();
+      a.invert();
+      b.clipTo(a);
+      b.invert();
+      a.clipTo(b);
+      b.clipTo(a);
+      a.build(b.allPolygons());
+      a.invert();
+      a = new ThreeBSP(a);
+      a.matrix = this.matrix;
+      return a;
+    }
+  }, {
+    key: "toGeometry",
+    value: function toGeometry() {
+      var matrix = new THREE.Matrix4().copy(this.matrix).invert();
+      var geometry = new THREE.BufferGeometry();
+      var polygons = this.tree.allPolygons();
+      var verticeDict = new Map();
+      var positions = [];
+      var normals = [];
+      var uvs = [];
+      var indices = [];
+      polygons.forEach(function (polygon) {
+        var polygonVertices = polygon.vertices;
+        var _loop = function _loop() {
+          var verts = [polygonVertices[0], polygonVertices[j - 1], polygonVertices[j]];
+          var verticeIndices = [];
+          verts.forEach(function (vertex) {
+            var vector = new THREE.Vector3(vertex.x, vertex.y, vertex.z).applyMatrix4(matrix);
+            var verticeIndex = positions.length / 3;
+            verticeIndices.push(verticeIndex);
+            positions.push(vector.x, vector.y, vector.z);
+            normals.push(vertex.normal.x, vertex.normal.y, vertex.normal.z);
+            uvs.push(vertex.uv.x, vertex.uv.y);
+          });
+          indices.push(verticeIndices[0], verticeIndices[1], verticeIndices[2]);
+        };
+        for (var j = 2; j < polygonVertices.length; j++) {
+          _loop();
+        }
+      });
+      geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+      geometry.setIndex(indices);
+      return geometry;
+    }
+  }, {
+    key: "toMesh",
+    value: function toMesh(material) {
+      var geometry = this.toGeometry(),
+        mesh = new THREE.Mesh(geometry, material);
+      mesh.position.setFromMatrixPosition(this.matrix);
+      mesh.rotation.setFromRotationMatrix(this.matrix);
+      return mesh;
+    }
+  }]);
+}();
+var Polygon = /*#__PURE__*/function () {
+  function Polygon(vertices, normal, w) {
+    (0, _classCallCheck2["default"])(this, Polygon);
+    if (!(vertices instanceof Array)) {
+      vertices = [];
+    }
+    this.vertices = vertices;
+    if (vertices.length > 0) {
+      this.calculateProperties();
+    } else {
+      this.normal = this.w = undefined;
+    }
+  }
+  return (0, _createClass2["default"])(Polygon, [{
+    key: "calculateProperties",
+    value: function calculateProperties() {
+      var a = this.vertices[0],
+        b = this.vertices[1],
+        c = this.vertices[2];
+      this.normal = b.clone().subtract(a).cross(c.clone().subtract(a)).normalize();
+      this.w = this.normal.clone().dot(a);
+      return this;
+    }
+  }, {
+    key: "clone",
+    value: function clone() {
+      var i,
+        vertice_count,
+        polygon = new Polygon();
+      for (i = 0, vertice_count = this.vertices.length; i < vertice_count; i++) {
+        polygon.vertices.push(this.vertices[i].clone());
+      }
+      polygon.calculateProperties();
+      return polygon;
+    }
+  }, {
+    key: "flip",
+    value: function flip() {
+      var i,
+        vertices = [];
+      this.normal.multiplyScalar(-1);
+      this.w *= -1;
+      for (i = this.vertices.length - 1; i >= 0; i--) {
+        vertices.push(this.vertices[i]);
+      }
+      this.vertices = vertices;
+      return this;
+    }
+  }, {
+    key: "classifyVertex",
+    value: function classifyVertex(vertex) {
+      var side_value = this.normal.dot(vertex) - this.w;
+      if (side_value < -EPSILON) {
+        return BACK;
+      } else if (side_value > EPSILON) {
+        return FRONT;
+      } else {
+        return COPLANAR;
+      }
+    }
+  }, {
+    key: "classifySide",
+    value: function classifySide(polygon) {
+      var i,
+        vertex,
+        classification,
+        num_positive = 0,
+        num_negative = 0,
+        vertice_count = polygon.vertices.length;
+      for (i = 0; i < vertice_count; i++) {
+        vertex = polygon.vertices[i];
+        classification = this.classifyVertex(vertex);
+        if (classification === FRONT) {
+          num_positive++;
+        } else if (classification === BACK) {
+          num_negative++;
+        }
+      }
+      if (num_positive > 0 && num_negative === 0) {
+        return FRONT;
+      } else if (num_positive === 0 && num_negative > 0) {
+        return BACK;
+      } else if (num_positive === 0 && num_negative === 0) {
+        return COPLANAR;
+      } else {
+        return SPANNING;
+      }
+    }
+  }, {
+    key: "splitPolygon",
+    value: function splitPolygon(polygon, coplanar_front, coplanar_back, front, back) {
+      var classification = this.classifySide(polygon);
+      if (classification === COPLANAR) {
+        (this.normal.dot(polygon.normal) > 0 ? coplanar_front : coplanar_back).push(polygon);
+      } else if (classification === FRONT) {
+        front.push(polygon);
+      } else if (classification === BACK) {
+        back.push(polygon);
+      } else {
+        var vertice_count,
+          i,
+          j,
+          ti,
+          tj,
+          vi,
+          vj,
+          t,
+          v,
+          f = [],
+          b = [];
+        for (i = 0, vertice_count = polygon.vertices.length; i < vertice_count; i++) {
+          j = (i + 1) % vertice_count;
+          vi = polygon.vertices[i];
+          vj = polygon.vertices[j];
+          ti = this.classifyVertex(vi);
+          tj = this.classifyVertex(vj);
+          if (ti != BACK) f.push(vi);
+          if (ti != FRONT) b.push(vi);
+          if ((ti | tj) === SPANNING) {
+            t = (this.w - this.normal.dot(vi)) / this.normal.dot(vj.clone().subtract(vi));
+            v = vi.interpolate(vj, t);
+            f.push(v);
+            b.push(v);
+          }
+        }
+        if (f.length >= 3) front.push(new Polygon(f).calculateProperties());
+        if (b.length >= 3) back.push(new Polygon(b).calculateProperties());
+      }
+    }
+  }]);
+}();
+var Vertex = /*#__PURE__*/function () {
+  function Vertex(x, y, z, normal, uv) {
+    (0, _classCallCheck2["default"])(this, Vertex);
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.normal = normal || new THREE.Vector3();
+    this.uv = uv || new THREE.Vector2();
+  }
+  return (0, _createClass2["default"])(Vertex, [{
+    key: "clone",
+    value: function clone() {
+      return new Vertex(this.x, this.y, this.z, this.normal.clone(), this.uv.clone());
+    }
+  }, {
+    key: "add",
+    value: function add(vertex) {
+      this.x += vertex.x;
+      this.y += vertex.y;
+      this.z += vertex.z;
+      return this;
+    }
+  }, {
+    key: "subtract",
+    value: function subtract(vertex) {
+      this.x -= vertex.x;
+      this.y -= vertex.y;
+      this.z -= vertex.z;
+      return this;
+    }
+  }, {
+    key: "multiplyScalar",
+    value: function multiplyScalar(scalar) {
+      this.x *= scalar;
+      this.y *= scalar;
+      this.z *= scalar;
+      return this;
+    }
+  }, {
+    key: "cross",
+    value: function cross(vertex) {
+      var x = this.x,
+        y = this.y,
+        z = this.z;
+      this.x = y * vertex.z - z * vertex.y;
+      this.y = z * vertex.x - x * vertex.z;
+      this.z = x * vertex.y - y * vertex.x;
+      return this;
+    }
+  }, {
+    key: "normalize",
+    value: function normalize() {
+      var length = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+      this.x /= length;
+      this.y /= length;
+      this.z /= length;
+      return this;
+    }
+  }, {
+    key: "dot",
+    value: function dot(vertex) {
+      return this.x * vertex.x + this.y * vertex.y + this.z * vertex.z;
+    }
+  }, {
+    key: "lerp",
+    value: function lerp(a, t) {
+      this.add(a.clone().subtract(this).multiplyScalar(t));
+      this.normal.add(a.normal.clone().sub(this.normal).multiplyScalar(t));
+      this.uv.add(a.uv.clone().sub(this.uv).multiplyScalar(t));
+      return this;
+    }
+  }, {
+    key: "interpolate",
+    value: function interpolate(other, t) {
+      return this.clone().lerp(other, t);
+    }
+  }, {
+    key: "applyMatrix4",
+    value: function applyMatrix4(m) {
+      // input: THREE.Matrix4 affine matrix
+
+      var x = this.x,
+        y = this.y,
+        z = this.z;
+      var e = m.elements;
+      this.x = e[0] * x + e[4] * y + e[8] * z + e[12];
+      this.y = e[1] * x + e[5] * y + e[9] * z + e[13];
+      this.z = e[2] * x + e[6] * y + e[10] * z + e[14];
+      return this;
+    }
+  }]);
+}();
+var Node = /*#__PURE__*/function () {
+  function Node(polygons) {
+    (0, _classCallCheck2["default"])(this, Node);
+    var i,
+      polygon_count,
+      front = [],
+      back = [];
+    this.polygons = [];
+    this.front = this.back = undefined;
+    if (!(polygons instanceof Array) || polygons.length === 0) return;
+    this.divider = polygons[0].clone();
+    for (i = 0, polygon_count = polygons.length; i < polygon_count; i++) {
+      this.divider.splitPolygon(polygons[i], this.polygons, this.polygons, front, back);
+    }
+    if (front.length > 0) {
+      this.front = new Node(front);
+    }
+    if (back.length > 0) {
+      this.back = new Node(back);
+    }
+  }
+  return (0, _createClass2["default"])(Node, [{
+    key: "isConvex",
+    value: function isConvex(polygons) {
+      var i, j;
+      for (i = 0; i < polygons.length; i++) {
+        for (j = 0; j < polygons.length; j++) {
+          if (i !== j && polygons[i].classifySide(polygons[j]) !== BACK) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+  }, {
+    key: "build",
+    value: function build(polygons) {
+      var i,
+        polygon_count,
+        front = [],
+        back = [];
+      if (!this.divider) {
+        this.divider = polygons[0].clone();
+      }
+      for (i = 0, polygon_count = polygons.length; i < polygon_count; i++) {
+        this.divider.splitPolygon(polygons[i], this.polygons, this.polygons, front, back);
+      }
+      if (front.length > 0) {
+        if (!this.front) this.front = new Node();
+        this.front.build(front);
+      }
+      if (back.length > 0) {
+        if (!this.back) this.back = new Node();
+        this.back.build(back);
+      }
+    }
+  }, {
+    key: "allPolygons",
+    value: function allPolygons() {
+      var polygons = this.polygons.slice();
+      if (this.front) polygons = polygons.concat(this.front.allPolygons());
+      if (this.back) polygons = polygons.concat(this.back.allPolygons());
+      return polygons;
+    }
+  }, {
+    key: "clone",
+    value: function clone() {
+      var node = new Node();
+      node.divider = this.divider.clone();
+      node.polygons = this.polygons.map(function (polygon) {
+        return polygon.clone();
+      });
+      node.front = this.front && this.front.clone();
+      node.back = this.back && this.back.clone();
+      return node;
+    }
+  }, {
+    key: "invert",
+    value: function invert() {
+      var i, polygon_count, temp;
+      for (i = 0, polygon_count = this.polygons.length; i < polygon_count; i++) {
+        this.polygons[i].flip();
+      }
+      this.divider.flip();
+      if (this.front) this.front.invert();
+      if (this.back) this.back.invert();
+      temp = this.front;
+      this.front = this.back;
+      this.back = temp;
+      return this;
+    }
+  }, {
+    key: "clipPolygons",
+    value: function clipPolygons(polygons) {
+      var i, polygon_count, front, back;
+      if (!this.divider) return polygons.slice();
+      front = [];
+      back = [];
+      for (i = 0, polygon_count = polygons.length; i < polygon_count; i++) {
+        this.divider.splitPolygon(polygons[i], front, back, front, back);
+      }
+      if (this.front) front = this.front.clipPolygons(front);
+      if (this.back) back = this.back.clipPolygons(back);else back = [];
+      return front.concat(back);
+    }
+  }, {
+    key: "clipTo",
+    value: function clipTo(node) {
+      this.polygons = node.clipPolygons(this.polygons);
+      if (this.front) this.front.clipTo(node);
+      if (this.back) this.back.clipTo(node);
+    }
+  }]);
+}();
+window.ThreeBSP = ThreeBSP;
+module.exports = exports.default;

package/lib/version.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERSION = void 0;
+var VERSION = exports.VERSION = '1.0.0';

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "kitchen-simulator",
-  "version": "11.0.0-react.18",
+  "version": "11.0.0",
   "description": "It is a kitchen simulator (self-contained micro-frontend).",
   "license": "MIT",
+  "main": "lib/index.js",
   "module": "es/index.js",
   "exports": {
     ".": {
-      "import": "./es/index.js"
+      "import": "./es/index.js",
+      "require": "./lib/index.js"
     }
   },
   "files": [
+    "lib",
     "es",
     "README.md",
     "LICENSE"
@@ -19,18 +22,18 @@
     "*.scss"
   ],
   "scripts": {
-    "start": "webpack-dev-server --config webpack.config.js --mode development --port 9000",
+    "start": "webpack-dev-server --config webpack.config.js --port 9000 --mode development",
     "start9010": "webpack-dev-server --config webpack.config.js --port 9010 --mode development",
     "start9020": "webpack-dev-server --config webpack.config.js --port 9020 --mode development",
     "build": "node scripts/custom-build.js",
     "build-src": "webpack --config webpack.config.js --mode production",
     "build-dist": "npm run clean && npm run build-src && mkdir -p dist && cp -R src/catalog dist/ && cp -R src/assets dist/",
-    "clean": "rimraf es",
+    "clean": "rimraf lib es",
     "update-version-file": "const-version ./package.json ./src/version.js",
     "version": "npm run update-version-file && npm run build && npm run add-build-to-vcs",
     "prepublishOnly": "cross-env NODE_ENV=production npm run build",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "add-build-to-vcs": "git add -A src/version.js && git add -A es"
+    "add-build-to-vcs": "git add -A src/version.js && git add -A es && git add -A lib"
   },
   "repository": {
     "type": "git",
@@ -59,7 +62,7 @@
     "@babel/runtime": "^7.28.4",
     "@sentry/react": "^9.10.1",
     "aws-sdk": "^2.984.0",
-    "axios": "^1.11.0",
+    "axios": "^0.20.0",
     "camera-controls": "^2.8.5",
     "clsx": "^2.1.1",
     "dotenv": "^16.4.7",
@@ -69,31 +72,40 @@
     "immutablediff": "0.4.4",
     "immutablepatch": "0.5.0",
     "invariant": "^2.0.0",
-    "jwt-decode": "^2.2.0",
-    "moment": "^2.30.1",
     "nanoid": "^5.1.6",
     "polylabel": "1.0.2",
     "posthog-js": "^1.271.0",
     "prop-types": "^15.8.1",
-    "react-ga4": "^1.4.1",
+    "react": "^16.9.0",
+    "react-container-dimensions": "1.4.1",
+    "react-dom": "16.9.0",
     "react-hotjar": "^1.0.11",
     "react-icons": "3.5.0",
-    "react-redux": "7.2.9",
-    "react-resize-detector": "^12.3.0",
-    "react-svg-pan-zoom": "^3.13.1",
+    "react-redux": "5.0.7",
+    "react-svg-pan-zoom": "2.18.0",
     "redux": "4.0.1",
-    "styled-components": "^5.2.0",
-    "three": "0.166.0"
+    "three": "0.166.0",
+    "moment": "^2.30.1",
+    "jwt-decode": "^2.2.0",
+    "react-ga4": "^1.4.1",
+    "styled-components": "^5.2.0"
   },
   "devDependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
+    "localstorage-slim": "^1.3.0",
+    "react-tabs": "3.0.0",
+    "sass": "^1.29.0",
+    "reactjs-popup": "^2.0.4",
+    "sass-loader": "^10.0.5",
+    "antd": "^4.24.16",
     "@babel/cli": "^7.28.3",
     "@babel/core": "^7.28.4",
     "@babel/plugin-transform-modules-commonjs": "^7.27.1",
     "@babel/plugin-transform-runtime": "^7.28.3",
     "@babel/preset-env": "^7.28.3",
     "@babel/preset-react": "^7.27.1",
+    "@material-ui/core": "^4.12.3",
+    "@material-ui/icons": "^4.11.2",
+    "@material-ui/lab": "^4.0.0-alpha.61",
     "@sentry/webpack-plugin": "^3.2.4",
     "assert": "^2.1.0",
     "babel-loader": "^9.1.3",
@@ -110,22 +122,15 @@
     "file-loader": "6.2.0",
     "html-webpack-plugin": "5.6.0",
     "immutable-devtools": "0.1.4",
-    "localstorage-slim": "^1.3.0",
     "mobile-detect": "^1.4.5",
     "path-browserify": "^1.0.1",
     "react-query": "^3.39.3",
-    "reactjs-popup": "^2.0.4",
+    "react-router-dom": "5.1.2",
     "rimraf": "^2.6.3",
-    "sass": "^1.29.0",
-    "sass-loader": "^10.0.5",
     "stream-browserify": "^3.0.0",
     "style-loader": "*",
     "webpack": "5.92.1",
     "webpack-cli": "5.1.4",
     "webpack-dev-server": "5.0.4"
-  },
-  "peerDependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
   }
 }

package/es/WorkSpace.js

@@ -1,30 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import React, { useState } from 'react';
-import { createRoot } from 'react-dom/client';
-import WorkSpaceHostMimic from "./WorkSpaceHostMimic";
-import WorkSpaceOriginal from "./WorkSpaceOriginal";
-function App() {
-  var _useState = useState(''),
-    _useState2 = _slicedToArray(_useState, 2),
-    mode = _useState2[0],
-    setMode = _useState2[1];
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
-    style: {
-      position: 'fixed',
-      zIndex: 9999,
-      bottom: 10,
-      left: 10
-    }
-  }, /*#__PURE__*/React.createElement("button", {
-    onClick: function onClick() {
-      return setMode('host');
-    }
-  }, "Host mimic"), /*#__PURE__*/React.createElement("button", {
-    onClick: function onClick() {
-      return setMode('old');
-    }
-  }, "Old workspace")), mode === 'host' ? /*#__PURE__*/React.createElement(WorkSpaceHostMimic, null) : /*#__PURE__*/React.createElement(WorkSpaceOriginal, null));
-}
-var container = document.getElementById('app');
-var root = createRoot(container);
-root.render(/*#__PURE__*/React.createElement(App, null));