kitchen-simulator 11.0.0-react.18 → 11.0.0

package/lib/catalog/areas/area/planner-element.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _export = require("../../factories/export");
+var _parquet = _interopRequireDefault(require("./textures/parquet.jpg"));
+var _tile = _interopRequireDefault(require("./textures/tile1.jpg"));
+var _ceramicTile = _interopRequireDefault(require("./textures/ceramic-tile.jpg"));
+var _strandPorcelain = _interopRequireDefault(require("./textures/strand-porcelain.jpg"));
+var _grass = _interopRequireDefault(require("./textures/grass.jpg"));
+var info = {
+  title: 'area',
+  tag: ['area'],
+  description: 'Generic Room',
+  image: ''
+};
+var textures = {
+  parquet: {
+    name: 'Parquet',
+    uri: _parquet["default"],
+    lengthRepeatScale: 0.004,
+    heightRepeatScale: 0.004
+  },
+  tile1: {
+    name: 'Tile1',
+    uri: _tile["default"],
+    lengthRepeatScale: 0.01,
+    heightRepeatScale: 0.01
+  },
+  ceramic: {
+    name: 'Ceramic Tile',
+    uri: _ceramicTile["default"],
+    lengthRepeatScale: 0.02,
+    heightRepeatScale: 0.02
+  },
+  strand_porcelain: {
+    name: 'Strand Porcelain Tile',
+    uri: _strandPorcelain["default"],
+    lengthRepeatScale: 0.02,
+    heightRepeatScale: 0.02
+  },
+  grass: {
+    name: 'Grass',
+    uri: _grass["default"],
+    lengthRepeatScale: 0.01,
+    heightRepeatScale: 0.01
+  }
+};
+var _default = exports["default"] = (0, _export.AreaFactory)('area', info, textures);
+module.exports = exports.default;

package/lib/catalog/cabinet/cabinet-assembly-order.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.orderCabinetAssemblyKeys = orderCabinetAssemblyKeys;
+// Sort the keys of a cabinet assembly so nested parts can be attached in the
+// correct order (e.g. drawer-door assets are inserted into placeholder nodes
+// that exist only after the drawer interior is loaded).
+function orderCabinetAssemblyKeys(cabinetAssembly) {
+  var keys = Object.keys(cabinetAssembly || {});
+  var keyPriority = function keyPriority(key) {
+    if (key === 'base' || key === 'animation' || key === 'placeholders' || key === 'tempPlaceholders' || key === 'model') {
+      return 1000;
+    }
+
+    // Drawer interiors (NOT door)
+    if (key.startsWith('base_drawer_') && !key.includes('_door')) return 10;
+    // Fixed drawer interiors (NOT door)
+    if (key.startsWith('base_fixed_drawer_') && !key.includes('door')) return 10;
+
+    // Drawer doors
+    if (key.startsWith('base_drawer_door_')) return 20;
+    if (key.startsWith('base_fixed_drawer_door_')) return 20;
+
+    // Drawer door handles
+    if (key.startsWith('drawer_door_handle_')) return 30;
+    if (key.startsWith('fixed_drawer_door_handle_')) return 30;
+    return 50;
+  };
+  return keys.map(function (k, idx) {
+    return {
+      k: k,
+      idx: idx
+    };
+  }).sort(function (a, b) {
+    return keyPriority(a.k) - keyPriority(b.k) || a.idx - b.idx;
+  }).map(function (_ref) {
+    var k = _ref.k;
+    return k;
+  });
+}

package/lib/catalog/catalog.js

@@ -0,0 +1,270 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _constants = require("../constants");
+var _utils = require("../components/viewer2d/utils");
+var Catalog = exports["default"] = /*#__PURE__*/function () {
+  function Catalog() {
+    var unit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.UNIT_CENTIMETER;
+    (0, _classCallCheck2["default"])(this, Catalog);
+    this.elements = {};
+    this.categories = {
+      root: {
+        name: 'root',
+        label: '/',
+        elements: [],
+        categories: []
+      }
+    };
+    this.propertyTypes = {};
+    this.unit = unit;
+  }
+
+  /**
+   * @description Get catalog's element
+   * @param {string} type Element's type
+   * @return {?object} Element
+   */
+  return (0, _createClass2["default"])(Catalog, [{
+    key: "getElement",
+    value: function getElement(type) {
+      if (this.hasElement(type)) {
+        return this.elements[type];
+      } else {
+        var deepSearchType = (0, _utils.returnReplaceableDeepSearchType)(type);
+        var element = this.elements[deepSearchType];
+        if (element) return element;
+        if (!element) return false;
+        // console.log("getElement", this);
+        throw new Error("Element ".concat(type, " does not exist in catalog"));
+      }
+    }
+
+    /**
+     * @description Get catalog category
+     * @param {string} categoryName Name of category
+     * @return {object} Category
+     */
+  }, {
+    key: "getCategory",
+    value: function getCategory(categoryName) {
+      if (this.hasCategory(categoryName)) {
+        return this.categories[categoryName];
+      }
+      throw new Error("Category ".concat(categoryName, " does not exist in catalog"));
+    }
+
+    /**
+     * @description Return type of a specfied property
+     * @param {string} type Property type
+     * @return {?object} Property
+     */
+  }, {
+    key: "getPropertyType",
+    value: function getPropertyType(type) {
+      if (this.propertyTypes.hasOwnProperty(type)) {
+        return this.propertyTypes[type];
+      }
+      throw new Error("Element ".concat(type, " does not exist in catalog"));
+    }
+
+    /**
+     * @description Register a new element
+     * @param {object} json Element structure
+     * @return {void}
+     */
+  }, {
+    key: "registerElement",
+    value: function registerElement(json) {
+      json.properties = json.properties || {};
+      if (this.validateElement(json)) {
+        this.elements[json.name] = json;
+        this.categories.root.elements.push(this.elements[json.name]);
+      }
+    }
+
+    /**
+     * @description Register multiple elements
+     * @param {array} [elementArray] Array of elements
+     * @return {void}
+     */
+  }, {
+    key: "registerMultipleElements",
+    value: function registerMultipleElements(elementArray) {
+      var _this = this;
+      elementArray.forEach(function (el) {
+        return _this.registerElement(el);
+      });
+    }
+
+    /**
+     * @description Register a new property
+     * @param {string} type Type of property
+     * @param {object} Viewer Property viewer component
+     * @param {object} Editor Property editor component
+     * @return {void}
+     */
+  }, {
+    key: "registerPropertyType",
+    value: function registerPropertyType(type, Viewer, Editor) {
+      this.propertyTypes[type] = {
+        type: type,
+        Viewer: Viewer,
+        Editor: Editor
+      };
+    }
+
+    /**
+     * @description Register multiple property
+     * @param {array} propertyTypeArray Array of properties
+     * @return {void}
+     */
+  }, {
+    key: "registerMultiplePropertyType",
+    value: function registerMultiplePropertyType(propertyTypeArray) {
+      var _this2 = this;
+      propertyTypeArray.forEach(function (el) {
+        return _this2.registerPropertyType.apply(_this2, (0, _toConsumableArray2["default"])(el));
+      });
+    }
+
+    /**
+     * @description Validate an element
+     * @param {object} json Element's structure
+     * @return {?boolean}
+     */
+  }, {
+    key: "validateElement",
+    value: function validateElement(json) {
+      if (!json.hasOwnProperty('name')) throw new Error('Element not valid');
+      var name = json.name;
+      if (json.prototype.toLowerCase().includes('molding')) return true;
+      if (!json.hasOwnProperty('prototype')) throw new Error("Element ".concat(name, " doesn't have prototype"));
+      if (!json.hasOwnProperty('info')) throw new Error("Element ".concat(name, " doesn't have info"));
+      if (!json.info.hasOwnProperty('tag')) throw new Error("Element ".concat(name, " doesn't have tag"));
+      if (!json.info.hasOwnProperty('description')) throw new Error("Element ".concat(name, " doesn't have description"));
+      // if (!json.info.hasOwnProperty('image')) throw new Error(`Element ${name} doesn't have image`);
+
+      if (!json.hasOwnProperty('render2D')) throw new Error("Element ".concat(name, " doesn't have render2D handler"));
+      if (!json.hasOwnProperty('render3D')) throw new Error("Element ".concat(name, " doesn't have render3D handler"));
+      if (!json.hasOwnProperty('properties')) throw new Error("Element ".concat(name, " doesn't have properties"));
+      for (var propertyName in json.properties) {
+        var propertyConfigs = json.properties[propertyName];
+        if (!propertyConfigs.hasOwnProperty('type')) throw new Error("Element ".concat(name, ", Property ").concat(propertyName, " doesn't have type"));
+        if (!propertyConfigs.hasOwnProperty('defaultValue')) throw new Error("Element ".concat(name, ", Property ").concat(propertyName, " doesn't have defaultValue"));
+      }
+      return true;
+    }
+
+    /**
+     * @description Check if catalog has element
+     * @param {string} type Element's type
+     * @return {boolean}
+     */
+  }, {
+    key: "hasElement",
+    value: function hasElement(type) {
+      return this.elements.hasOwnProperty(type);
+    }
+
+    /**
+     * @description Register a new category
+     * @param {string} name Name of category
+     * @param {string} label Label of category
+     * @param {array} [childs] Category's childs
+     * @return {?object} Registered category
+     */
+  }, {
+    key: "registerCategory",
+    value: function registerCategory(name, label, childs) {
+      var _this3 = this;
+      if (this.validateCategory(name, label)) {
+        this.categories[name] = {
+          name: name,
+          label: label,
+          categories: [],
+          elements: []
+        };
+        this.categories.root.categories.push(this.categories[name]);
+        if (childs && childs.length) {
+          childs.forEach(function (el) {
+            return _this3.addToCategory(name, el);
+          });
+        }
+        return this.categories[name];
+      }
+      return null;
+    }
+
+    /**
+     * @description Add an element to the specified category
+     * @param {string} name Name of category
+     * @param {object} child Element's structure
+     * @return {?void}
+     */
+  }, {
+    key: "addToCategory",
+    value: function addToCategory(name, child) {
+      if (this.hasElement(child.name)) {
+        this.categories[name].elements.push(child);
+        this.categories.root.elements.splice(this.categories.root.elements.indexOf(child), 1);
+      } else if (this.hasCategory(child.name)) {
+        this.categories[name].categories.push(child);
+        this.categories.root.categories.splice(this.categories.root.categories.indexOf(child), 1);
+      } else {
+        throw new Error("child ".concat(child, " is either category nor element"));
+      }
+    }
+
+    /**
+     * @description Check if category contain element
+     * @param {string} categoryName Name of category
+     * @param {string} elementName Name of element
+     * @return {boolean}
+     */
+  }, {
+    key: "categoryHasElement",
+    value: function categoryHasElement(categoryName, elementName) {
+      return this.hasCategory(categoryName) && this.categories[categoryName].elements.some(function (el) {
+        return el.name === elementName;
+      });
+    }
+
+    /**
+     * @description Validate a category
+     * @param {string} name Name of category
+     * @param {string} label Label of category
+     * @return {?boolean}
+     */
+  }, {
+    key: "validateCategory",
+    value: function validateCategory(name, label) {
+      if (!name) {
+        throw new Error('Category has undefined name');
+      }
+      if (name === '') {
+        throw new Error('Category has empty name');
+      }
+      return !this.hasCategory(name);
+    }
+
+    /**
+     * @description Verify if catalog already contain a category with specified name
+     * @param {string} categoryName Name of category
+     * @return {boolean}
+     */
+  }, {
+    key: "hasCategory",
+    value: function hasCategory(categoryName) {
+      return this.categories.hasOwnProperty(categoryName);
+    }
+  }]);
+}();
+module.exports = exports.default;

package/lib/catalog/export.js

@@ -0,0 +1 @@
+"use strict";

package/lib/catalog/factories/area-factory-3d.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createArea = createArea;
+exports.updatedArea = updatedArea;
+var _three = _interopRequireWildcard(require("three"));
+var Three = _three;
+var SharedStyle = _interopRequireWildcard(require("../../shared-style"));
+var _RGBELoader = require("three/examples/jsm/loaders/RGBELoader");
+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); }
+var params = {
+  envMap: 'HDR',
+  roughness: 0.9,
+  metalness: 0.8,
+  exposure: 1.0
+  // debug: false
+};
+
+/**
+ * Apply a texture to a wall face
+ * @param material: The material of the face
+ * @param texture: The texture to load
+ * @param length: The lenght of the face
+ * @param height: The height of the face
+ */
+var applyTexture = function applyTexture(material, texture, length, height) {
+  var loader = new _three.TextureLoader();
+  if (texture) {
+    material.map = loader.load(texture.uri);
+    material.map.colorSpace = Three.SRGBColorSpace;
+    material.needsUpdate = true;
+    material.map.wrapS = _three.RepeatWrapping;
+    material.map.wrapT = _three.RepeatWrapping;
+    material.map.repeat.set(length * texture.lengthRepeatScale, height * texture.heightRepeatScale);
+    if (texture.normal) {
+      material.normalMap = loader.load(texture.normal.uri);
+      material.normalScale = new _three.Vector2(texture.normal.normalScaleX, texture.normal.normalScaleY);
+      material.normalMap.wrapS = _three.RepeatWrapping;
+      material.normalMap.wrapT = _three.RepeatWrapping;
+      material.normalMap.repeat.set(length * texture.normal.lengthRepeatScale, height * texture.normal.heightRepeatScale);
+    }
+  }
+};
+
+/**
+ * Function that assign UV coordinates to a geometry
+ * @param geometry
+ */
+var assignUVs = function assignUVs(geometry) {
+  geometry.computeBoundingBox();
+  var _geometry$boundingBox = geometry.boundingBox,
+    min = _geometry$boundingBox.min,
+    max = _geometry$boundingBox.max;
+  var offset = new _three.Vector2(0 - min.x, 0 - min.y);
+  var range = new _three.Vector2(max.x - min.x, max.y - min.y);
+  var uvArray = [];
+  var position = geometry.attributes.position;
+  for (var i = 0; i < position.count; i += 3) {
+    var x1 = position.getX(i);
+    var y1 = position.getY(i);
+    var x2 = position.getX(i + 1);
+    var y2 = position.getY(i + 1);
+    var x3 = position.getX(i + 2);
+    var y3 = position.getY(i + 2);
+    uvArray.push((x1 + offset.x) / range.x, (y1 + offset.y) / range.y, (x2 + offset.x) / range.x, (y2 + offset.y) / range.y, (x3 + offset.x) / range.x, (y3 + offset.y) / range.y);
+  }
+  geometry.setAttribute('uv', new Three.BufferAttribute(new Float32Array(uvArray), 2));
+  geometry.needsUpdate = true;
+};
+function createArea(element, layer, scene, textures) {
+  var vertices = [];
+  element.vertices.forEach(function (vertexID) {
+    vertices.push(layer.vertices.get(vertexID));
+  });
+  var texture = element.texture;
+  texture.lengthRepeatScale = 0.01;
+  texture.heightRepeatScale = 0.01;
+  var color = element.properties.get('patternColor');
+  if (element.selected) {
+    color = SharedStyle.AREA_MESH_COLOR.selected;
+  } else {
+    color = SharedStyle.AREA_MESH_COLOR.unselected;
+  }
+  var shape = new _three.Shape();
+  shape.moveTo(vertices[0].x, vertices[0].y);
+  for (var i = 1; i < vertices.length; i++) {
+    shape.lineTo(vertices[i].x, vertices[i].y);
+  }
+  function loadFloorENV() {
+    return new _RGBELoader.RGBELoader().load('/assets/Window.hdr', function (texture) {
+      texture.mapping = Three.EquirectangularReflectionMapping;
+      return texture;
+    });
+  }
+  var floorENV = loadFloorENV();
+  var loader = new _three.TextureLoader();
+  var areaMaterial = new _three.MeshPhysicalMaterial({
+    side: Three.DoubleSide,
+    metalness: texture.metalness,
+    roughness: 0.3,
+    envMap: floorENV,
+    envMapIntensity: 1.8,
+    specularIntensity: 0.4,
+    map: loader.load(texture.uri)
+  });
+
+  /* Create holes for the area */
+  element.holes.forEach(function (holeID) {
+    var holeCoords = [];
+    layer.getIn(['areas', holeID, 'vertices']).forEach(function (vertexID) {
+      var _layer$getIn = layer.getIn(['vertices', vertexID]),
+        x = _layer$getIn.x,
+        y = _layer$getIn.y;
+      holeCoords.push([x, y]);
+    });
+    holeCoords = holeCoords.reverse();
+    var holeShape = createShape(holeCoords);
+    shape.holes.push(holeShape);
+  });
+
+  // This is extrude floor mesh
+
+  var extrudeSettings = {
+    depth: -3,
+    bevelEnabled: false
+  };
+  var shapeGeometry = new Three.ExtrudeGeometry(shape, extrudeSettings);
+  assignUVs(shapeGeometry);
+  var boundingBox = new _three.Box3().setFromObject(new _three.Mesh(shapeGeometry, new _three.MeshBasicMaterial()));
+  var width = boundingBox.max.x - boundingBox.min.x;
+  var height = boundingBox.max.y - boundingBox.min.y;
+  var texture_unit = 70 * 2.54; // 70 inch
+
+  applyTexture(areaMaterial, texture, width / texture_unit * 100, height / texture_unit * 100);
+  var area = new _three.Mesh(shapeGeometry, areaMaterial);
+  area.rotation.x -= Math.PI / 2;
+  area.receiveShadow = true;
+  area.name = 'floor';
+  // This mesh is use for creating ceiling mesh
+
+  var shapeGeometry2 = new Three.ShapeGeometry(shape);
+  var area2 = new _three.Mesh(shapeGeometry2, new _three.MeshBasicMaterial({
+    transparent: true,
+    opacity: 0.0
+  }));
+  area2.castShadow = true;
+  area2.rotation.x -= Math.PI / 2;
+  area2.receiveShadow = true;
+  area2.name = 'floorSupport';
+  var floorSupport = area2.clone();
+  area.userData.floorSupport = floorSupport;
+  return Promise.resolve(area);
+}
+function updatedArea(element, layer, scene, textures, mesh, oldElement, differences, selfDestroy, selfBuild) {
+  var noPerf = function noPerf() {
+    selfDestroy();
+    return selfBuild();
+  };
+  var floor = mesh.getObjectByName('floor');
+  floor.receiveShadow = true;
+  if (differences[0] == 'selected') {
+    var color = element.selected ? SharedStyle.AREA_MESH_COLOR.selected : SharedStyle.AREA_MESH_COLOR.unselected;
+    floor.material.color.set(color);
+  } else if (differences[0] == 'properties') {
+    if (differences[1] === 'texture') {
+      return noPerf();
+    }
+  } else return noPerf();
+  return Promise.resolve(mesh);
+}
+
+/**
+ * This function will create a shape given a list of coordinates
+ * @param shapeCoords
+ * @returns {Shape}
+ */
+var createShape = function createShape(shapeCoords) {
+  var shape = new _three.Shape();
+  shape.moveTo(shapeCoords[0][0], shapeCoords[0][1]);
+  for (var i = 1; i < shapeCoords.length; i++) {
+    shape.lineTo(shapeCoords[i][0], shapeCoords[i][1]);
+  }
+  return shape;
+};

package/lib/catalog/factories/area-factory.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = AreaFactory;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _areaFactory3d = require("./area-factory-3d");
+var SharedStyle = _interopRequireWildcard(require("../../shared-style"));
+var _translator = _interopRequireDefault(require("../../translator/translator"));
+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); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var translator = new _translator["default"]();
+function AreaFactory(name, info, textures) {
+  var areaElement = {
+    name: name,
+    prototype: 'areas',
+    info: _objectSpread(_objectSpread({}, info), {}, {
+      visibility: {
+        catalog: false,
+        layerElementsVisible: false
+      }
+    }),
+    properties: {
+      patternColor: {
+        label: translator.t('color'),
+        type: 'color',
+        defaultValue: 'rgba(175, 175, 175)'
+      },
+      thickness: {
+        label: translator.t('thickness'),
+        type: 'length-measure',
+        defaultValue: {
+          length: 0
+        }
+      }
+    },
+    render2D: function render2D(element, layer, scene) {
+      var path = '';
+
+      ///print area path
+      element.vertices.forEach(function (vertexID, ind) {
+        var vertex = layer.vertices.get(vertexID);
+        path += (ind ? 'L' : 'M') + vertex.x + ' ' + vertex.y + ' ';
+      });
+
+      //add holes
+      element.holes.forEach(function (areaID) {
+        var area = layer.areas.get(areaID);
+        area.vertices.reverse().forEach(function (vertexID, ind) {
+          var vertex = layer.vertices.get(vertexID);
+          path += (ind ? 'L' : 'M') + vertex.x + ' ' + vertex.y + ' ';
+        });
+      });
+      var fill = element.selected ? SharedStyle.AREA_MESH_COLOR.selected : SharedStyle.AREA_MESH_COLOR.unselected;
+      return /*#__PURE__*/_react["default"].createElement("path", {
+        d: path,
+        fill: fill
+      });
+    },
+    render3D: function render3D(element, layer, scene) {
+      return (0, _areaFactory3d.createArea)(element, layer, scene, textures);
+    },
+    updateRender3D: function updateRender3D(element, layer, scene, mesh, oldElement, differences, selfDestroy, selfBuild) {
+      return (0, _areaFactory3d.updatedArea)(element, layer, scene, textures, mesh, oldElement, differences, selfDestroy, selfBuild);
+    }
+  };
+  if (textures && textures !== {}) {
+    var textureValues = {
+      none: 'None'
+    };
+    for (var textureName in textures) {
+      textureValues[textureName] = textures[textureName].name;
+    }
+    areaElement.properties.texture = {
+      label: translator.t('texture'),
+      type: 'enum',
+      defaultValue: 'none',
+      values: textureValues
+    };
+  }
+  return areaElement;
+}
+module.exports = exports.default;