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

package/src/utils/name-generator.js

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

package/src/utils/objects-utils.js

@@ -1,56 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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 }));
-}