kitchen-simulator 5.0.0-test.5 → 5.0.0-test.6

package/src/utils/name-generator.js

@@ -0,0 +1,5 @@
+export default class NameGenerator {
+  static generateName(prototype, type) {
+    return type.substr(0, 1).toUpperCase() + type.substr(1);
+  }
+}

package/src/utils/objects-utils.js

@@ -0,0 +1,56 @@
+import * as Three from 'three';
+String.prototype.isLeftPlaceholder = function () {
+  return this.match(/_L$|_L_\d$/) != null;
+};
+
+String.prototype.isRightPlaceholder = function () {
+  return this.match(/_R$|_R_\d$/) != null;
+};
+
+export function objectsMap(object, func) {
+  let mappedObject = {};
+  for (let key in object) {
+    mappedObject[key] = func(key, mappedObject[key]);
+  }
+  return mappedObject;
+}
+
+export function objectsCompare(x, y) {
+  if (x === y) return true;
+  if (!(x instanceof Object) || !(y instanceof Object)) return false;
+  if (x.constructor !== y.constructor) return false;
+
+  for (let p in x) {
+    if (!x.hasOwnProperty(p)) continue;
+    if (!y.hasOwnProperty(p)) return false;
+    if (x[p] === y[p]) continue;
+    if (typeof x[p] !== 'object') return false;
+    if (!objectsCompare(x[p], y[p])) return false;
+  }
+
+  for (let p in y) {
+    if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) return false;
+  }
+
+  return true;
+}
+export function getAllMeshes(objects) {
+  const meshes = [];
+  objects.forEach(object => {
+    if (!object) return;
+    object.traverse(o => {
+      if (o.isMesh && o.geometry) {
+        meshes.push(o);
+      }
+    });
+  });
+  return meshes;
+}
+
+export function vectorIntersectWithMesh(origin, target) {
+  const vectorDir = new Three.Vector3(origin.x, origin.y - 1000, origin.z);
+  const ray = new Three.Raycaster();
+  ray.set(origin, vectorDir);
+  const intersects = ray.intersectObject(target, true);
+  return intersects.length > 0;
+}

package/src/utils/phone-validator.js

@@ -0,0 +1,4 @@
+export let phoneValidation = phone => {
+  const result = /^(\+1\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}$/;
+  return result.test(String(phone).toLowerCase());
+};

package/src/utils/process-black-list.js

@@ -0,0 +1,10 @@
+export const buildCurrentCabinetObject = (cabinet, texture) => {
+  return {
+    type: cabinet.name, // e.g. "B09"
+    name: cabinet.name,
+    category: cabinet.type, // "cabinet"
+    doorStyle: { ...texture },
+    itemID: cabinet.itemID,
+    sku_number: cabinet.name
+  };
+};

package/src/utils/react-if.jsx

@@ -0,0 +1,20 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+/**
+ * @return {null}
+ */
+export default function If({ condition, style, children }) {
+  return condition ? (
+    Array.isArray(children) ? (
+      <div style={style}>{children}</div>
+    ) : (
+      children
+    )
+  ) : null;
+}
+
+If.propTypes = {
+  condition: PropTypes.bool.isRequired,
+  style: PropTypes.object
+};

package/src/utils/snap-scene.js

@@ -0,0 +1,102 @@
+import {
+  SNAP_POINT,
+  SNAP_LINE,
+  SNAP_SEGMENT,
+  SNAP_GRID,
+  SNAP_GUIDE,
+  addPointSnap,
+  addLineSnap,
+  addLineSegmentSnap,
+  addGridSnap
+} from './snap';
+import { GeometryUtils } from './export';
+import { Map, List } from 'immutable';
+
+export function sceneSnapElements(
+  scene,
+  snapElements = new List(),
+  snapMask = new Map()
+) {
+  let { width, height } = scene;
+
+  let a, b, c;
+  return snapElements.withMutations(snapElements => {
+    scene.layers.forEach(layer => {
+      let { lines, vertices } = layer;
+
+      vertices.forEach(({ id: vertexID, x, y }) => {
+        if (snapMask.get(SNAP_POINT)) {
+          addPointSnap(snapElements, x, y, 10, 10, vertexID);
+        }
+
+        if (snapMask.get(SNAP_LINE)) {
+          ({ a, b, c } = GeometryUtils.horizontalLine(y));
+          addLineSnap(snapElements, a, b, c, 10, 1, vertexID);
+          ({ a, b, c } = GeometryUtils.verticalLine(x));
+          addLineSnap(snapElements, a, b, c, 10, 1, vertexID);
+          ({ a, b, c } = GeometryUtils.upcrossLine(x, y));
+          addLineSnap(snapElements, a, b, c, 10, 3, null);
+          ({ a, b, c } = GeometryUtils.downcrossLine(x, y));
+          addLineSnap(snapElements, a, b, c, 10, 3, null);
+        }
+      });
+
+      if (snapMask.get(SNAP_SEGMENT)) {
+        lines.forEach(({ id: lineID, vertices: [v0, v1] }) => {
+          let { x: x1, y: y1 } = vertices.get(v0);
+          let { x: x2, y: y2 } = vertices.get(v1);
+
+          addLineSegmentSnap(snapElements, x1, y1, x2, y2, 20, 1, lineID);
+        });
+      }
+    });
+
+    if (snapMask.get(SNAP_GRID)) {
+      let divider = 5;
+      let gridCellSize = 100 / divider;
+      let xCycle = width / gridCellSize;
+      let yCycle = height / gridCellSize;
+
+      for (let x = 0; x < xCycle; x++) {
+        let xMul = x * gridCellSize;
+
+        for (let y = 0; y < yCycle; y++) {
+          let yMul = y * gridCellSize;
+
+          let onXCross = !(x % divider) ? true : false;
+          let onYCross = !(y % divider) ? true : false;
+
+          addGridSnap(
+            snapElements,
+            xMul,
+            yMul,
+            10,
+            onXCross && onYCross ? 15 : 10,
+            null
+          );
+        }
+      }
+    }
+
+    if (snapMask.get(SNAP_GUIDE)) {
+      let horizontal = scene.getIn(['guides', 'horizontal']);
+      let vertical = scene.getIn(['guides', 'vertical']);
+
+      let hValues = horizontal.valueSeq();
+      let vValues = vertical.valueSeq();
+
+      hValues.forEach(hVal => {
+        vValues.forEach(vVal => {
+          addPointSnap(snapElements, vVal, hVal, 10, 10);
+        });
+      });
+
+      hValues.forEach(hVal =>
+        addLineSegmentSnap(snapElements, 0, hVal, width, hVal, 20, 1)
+      );
+      vValues.forEach(vVal =>
+        addLineSegmentSnap(snapElements, vVal, 0, vVal, height, 20, 1)
+      );
+    }
+  });
+}

package/src/utils/snap.js

@@ -0,0 +1,184 @@
+import { Map, List, Record } from 'immutable';
+import * as Geometry from './geometry';
+
+export const SNAP_POINT = 'SNAP_POINT';
+export const SNAP_LINE = 'SNAP_LINE';
+export const SNAP_SEGMENT = 'SNAP_SEGMENT';
+export const SNAP_GRID = 'SNAP_GRID';
+export const SNAP_GUIDE = 'SNAP_GUIDE';
+
+export const SNAP_MASK = new Map({
+  SNAP_POINT: true,
+  SNAP_LINE: true,
+  SNAP_SEGMENT: true,
+  SNAP_GRID: false,
+  SNAP_GUIDE: true
+});
+
+class PointSnap extends Record({
+  type: 'point',
+  x: -1,
+  y: -1,
+  radius: 1,
+  priority: 1,
+  related: new List()
+}) {
+  nearestPoint(x, y) {
+    return {
+      x: this.x,
+      y: this.y,
+      distance: Geometry.pointsDistance(this.x, this.y, x, y)
+    };
+  }
+  isNear(x, y, distance) {
+    return ~(this.x - x) + 1 < distance && ~(this.y - y) + 1 < distance;
+  }
+}
+
+class LineSnap extends Record({
+  type: 'line',
+  a: -1,
+  b: -1,
+  c: -1,
+  radius: 1,
+  priority: 1,
+  related: new List()
+}) {
+  nearestPoint(x, y) {
+    return {
+      ...Geometry.closestPointFromLine(this.a, this.b, this.c, x, y),
+      distance: Geometry.distancePointFromLine(this.a, this.b, this.c, x, y)
+    };
+  }
+  isNear(x, y, distance) {
+    return true;
+  }
+}
+
+class LineSegmentSnap extends Record({
+  type: 'line-segment',
+  x1: -1,
+  y1: -1,
+  x2: -1,
+  y2: -1,
+  radius: 1,
+  priority: 1,
+  related: new List()
+}) {
+  nearestPoint(x, y) {
+    return {
+      ...Geometry.closestPointFromLineSegment(
+        this.x1,
+        this.y1,
+        this.x2,
+        this.y2,
+        x,
+        y
+      ),
+      distance: Geometry.distancePointFromLineSegment(
+        { x: this.x1, y: this.y1 },
+        { x: this.x2, y: this.y2 },
+        x,
+        y
+      )
+    };
+  }
+  isNear(x, y, distance) {
+    return true;
+  }
+}
+
+class GridSnap extends Record({
+  type: 'grid',
+  x: -1,
+  y: -1,
+  radius: 1,
+  priority: 1,
+  related: new List()
+}) {
+  nearestPoint(x, y) {
+    return {
+      x: this.x,
+      y: this.y,
+      distance: Geometry.pointsDistance(this.x, this.y, x, y)
+    };
+  }
+  isNear(x, y, distance) {
+    return ~(this.x - x) + 1 < distance && ~(this.y - y) + 1 < distance;
+  }
+}
+
+export function nearestSnap(snapElements, x, y, snapMask) {
+  let filter = {
+    point: snapMask.get(SNAP_POINT),
+    line: snapMask.get(SNAP_LINE),
+    'line-segment': snapMask.get(SNAP_SEGMENT),
+    grid: snapMask.get(SNAP_GRID)
+  };
+
+  return snapElements
+    .valueSeq()
+    .filter(el => filter[el.type] && el.isNear(x, y, el.radius))
+    .map(snap => {
+      return { snap, point: snap.nearestPoint(x, y) };
+    })
+    .filter(({ snap: { radius }, point: { distance } }) => distance < radius)
+    .min(
+      (
+        { snap: { priority: p1 }, point: { distance: d1 } },
+        { snap: { priority: p2 }, point: { distance: d2 } }
+      ) => (p1 === p2 ? (d1 < d2 ? -1 : 1) : p1 > p2 ? -1 : 1)
+    );
+}
+
+export function addPointSnap(snapElements, x, y, radius, priority, related) {
+  related = new List([related]);
+  return snapElements.push(new PointSnap({ x, y, radius, priority, related }));
+}
+
+export function addLineSnap(snapElements, a, b, c, radius, priority, related) {
+  related = new List([related]);
+
+  return snapElements.withMutations(snapElements => {
+    let alreadyPresent = snapElements.some(
+      lineSnap =>
+        lineSnap.type === 'line' &&
+        a === lineSnap.a &&
+        b === lineSnap.b &&
+        c === lineSnap.c
+    );
+    if (alreadyPresent) return snapElements;
+
+    let intersections = snapElements
+      .valueSeq()
+      .filter(snap => snap.type === 'line')
+      .map(snap =>
+        Geometry.twoLinesIntersection(snap.a, snap.b, snap.c, a, b, c)
+      )
+      .filter(intersection => intersection !== undefined)
+      .forEach(({ x, y }) => addPointSnap(snapElements, x, y, 20, 40));
+
+    snapElements.push(new LineSnap({ a, b, c, radius, priority, related }));
+  });
+}
+
+export function addLineSegmentSnap(
+  snapElements,
+  x1,
+  y1,
+  x2,
+  y2,
+  radius,
+  priority,
+  related
+) {
+  related = new List([related]);
+  return snapElements.push(
+    new LineSegmentSnap({ x1, y1, x2, y2, radius, priority, related })
+  );
+}
+
+export function addGridSnap(snapElements, x, y, radius, priority, related) {
+  related = new List([related]);
+  return snapElements.push(new GridSnap({ x, y, radius, priority, related }));
+}