fix lint issues

Author: erossignon

bin/STEPtoBREP.js

@@ -1,26 +1,27 @@
+const occ = require("../lib/occ");
 
-var occ = require('../lib/occ');
+const pace = require("pace")(1000);
 
-var pace = require("pace")(1000);
+const filename = process.argv[2];
+let message;
 
-filename = process.argv[2];
+occ.readSTEP(filename, function (err, solids) {
+    pace.op(100000);
+    if (!err) {
+        console.log(" \n\ndone y----> ", solids.length, " solids read");
 
-occ.readSTEP(filename,function (err,solids) {
-   pace.op(100000);
-   if (!err) {
-      console.log( " \n\ndone y----> ", solids.length , " solids read");
+        // write to BREP
+        occ.writeBREP(filename + ".brep", solids, function done() {
+        });
+    } else {
+        message = solids
+        console.log("\n\n ERROR =", message);
+    }
 
-      // write to BREP
-      occ.writeBREP(filename+".brep",solids,function done() { });
-   } else {
-      message = solids
-      console.log("\n\n ERROR =" , message);
-   }
-   
-}, function progress(percent,incr) { 
- pace.op(percent*100*10)
- // console.log("tick ", incr,bar1.step)
- //  bar1.tick(incr);
+}, function progress(percent, incr) {
+    pace.op(percent * 100 * 10)
+    // console.log("tick ", incr,bar1.step)
+    //  bar1.tick(incr);
 });
 
 console.log(process.argv[0]);

lib/fastbuilder.js

@@ -4,9 +4,7 @@ const occ = require("./occ");
 const shapeFactory = require("../lib/shapeFactory");
 const assert = require("assert");
 
-const verboseOutput = false;
 function debugLog() {
-    arguments;
     /* implement me*/
 }
 
@@ -41,7 +39,7 @@ class Cache {
 
         }
 
-        Object.defineProperty(obj, methodName, { value: performOperation, enumerable: false });
+        Object.defineProperty(obj, methodName, {value: performOperation, enumerable: false});
 
         // xx obj[methodName] = performOperation;=
 
@@ -106,11 +104,7 @@ class Cache {
 
     }
 
-    __performedCachedOperation(originalObject,
-                               originalMethod,
-                               methodName,
-                               theArguments,
-                               callAsConstructor) {
+    __performedCachedOperation(originalObject, originalMethod, methodName, theArguments, callAsConstructor) {
 
         assert(theArguments.hasOwnProperty("length"));
 
@@ -232,9 +226,7 @@ function replaceObjectsByGUUID(arg) {
     }
 }
 
-function calculateOperationHash(methodName, theArguments, callAsConstructor) {
-
-    callAsConstructor;
+function calculateOperationHash(methodName, theArguments) {
 
 
     // build the signature of the function + arguments
@@ -274,7 +266,7 @@ function replaceFunc(proxyObj, Obj, methodName) {
     if (isFunction(Obj[methodName])) {
 
         assert(isFunction(Obj[methodName]), `methodName = ${methodName} ${typeof Obj[methodName]}`);
-        const fn = function() {
+        const fn = function () {
 
             // http://stackoverflow.com/questions/367768/how-to-detect-if-a-function-is-called-as-constructor
             // Xx console.log(this.constructor.name == methodName, (this.constructor === fn), this.constructor.name);

lib/occ.js

@@ -30,6 +30,7 @@ exports.demo = function () {
 function f(a, w, p) {
     return ("          " + (a + 0).toFixed(p)).substr(-w);
 }
+
 occ.Point3D.prototype.toString = function () {
 
     return "{" +
@@ -49,9 +50,9 @@ occ.Edge.prototype.toString = function () {
 
     return "Edge => { \n" +
       "  numVertices: " + this.numVertices + "\n" +
-      "  vertices: " + this.getVertices().map(function (f) {
+      "  vertices: " +
+      this.getVertices().map(function (f) {
           return f.toString();
-      }).join(" ") +
-      "}";
+      }).join(" ") + "}";
 };
 

lib/shapeFactory.js

@@ -109,10 +109,9 @@ exports.makePan = function (csg, _height, _radius) {
     const s4 = csg.fuse(s1, s2);
     const s5 = csg.common(s4, s3);
 
-    const handle = csg.makeCylinder(
-      [radius - 2 * thickness, 0, height - handleRadius * 1.1],
-      [handleLength + radius - 2 * thickness, 0, height - handleRadius * 1.1],
-      handleRadius);
+    const pt1 = [radius - 2 * thickness, 0, height - handleRadius * 1.1];
+    const pt2 = [handleLength + radius - 2 * thickness, 0, height - handleRadius * 1.1];
+    const handle = csg.makeCylinder(pt1, pt2, handleRadius);
 
     const s6 = csg.fuse(s5, handle);
 
@@ -195,7 +194,7 @@ exports.makeRoundedPlate = function (csg, R1, R2, L, thickness) {
     v = csg.cut(v, csg.makeBox(q0, p1).rotate(p2, [0, 0, 1], -angle));
     v = csg.cut(v, csg.makeBox(q3, p3).rotate(p2, [0, 0, 1], angle));
 
-//    return v;
+    //    return v;
     const c1 = csg.makeCylinder([0, 0, 0], [0, 0, thickness], R1);
     v = csg.fuse(v, c1);
     const c2 = csg.makeCylinder([0, L, 0], [0, L, thickness], R2);
@@ -430,15 +429,14 @@ exports.makeLegoBrickSlow = function (csg, nX, nY, h) {
     let innerBlock = csg.makeBox([0, 0, 0], [innerWidth, innerLength, innerHeight]);
     innerBlock = innerBlock.translate([u, u, 0]);
     let hollowBlock = csg.cut(outerBlock, innerBlock);
-    let h1 = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, outerHeight - 3 * u],
-      [2.5 * u, 2.5 * u, outerHeight + 3 * u],
-      0.75 * u);
 
-    let h2 = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, outerHeight],
-      [2.5 * u, 2.5 * u, outerHeight + u],
-      1.5 * u);
+    const pt1 = [2.5 * u, 2.5 * u, outerHeight - 3 * u];
+    const pt2 = [2.5 * u, 2.5 * u, outerHeight + 3 * u];
+    let h1 = csg.makeCylinder(pt1, pt2, 0.75 * u);
+
+    const pt3 = [2.5 * u, 2.5 * u, outerHeight];
+    const pt4 = [2.5 * u, 2.5 * u, outerHeight + u];
+    let h2 = csg.makeCylinder(pt3, pt4, 1.5 * u);
 
     // installer la grille
     for (let y = 0; y < nY; y++) {
@@ -455,16 +453,14 @@ exports.makeLegoBrickSlow = function (csg, nX, nY, h) {
         h2 = h2.translate([0, 5 * u, 0]);
     }
 
-    let pinOuter = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, 0],
-      [2.5 * u, 2.5 * u, outerHeight - u],
-      u
-    );
-    let pinInner = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, 0],
-      [2.5 * u, 2.5 * u, outerHeight - u],
-      0.5 * u
-    );
+    const pt5 = [2.5 * u, 2.5 * u, 0];
+    const pt6 = [2.5 * u, 2.5 * u, outerHeight - u];
+    let pinOuter = csg.makeCylinder(pt5, pt6, u);
+
+    const pt7 = [2.5 * u, 2.5 * u, 0];
+    const pt8 = [2.5 * u, 2.5 * u, outerHeight - u];
+    let pinInner = csg.makeCylinder(pt7, pt8, 0.5 * u);
+
     let p = csg.cut(pinOuter, pinInner);
     let pp;
     if (nY == 1) {
@@ -484,16 +480,14 @@ exports.makeLegoBrickSlow = function (csg, nX, nY, h) {
     }
     if (nX > 1 && nY > 1) {
 
-        pinOuter = csg.makeCylinder(
-          [5 * u, 5 * u, 0],
-          [5 * u, 5 * u, outerHeight - u],
-          4.07 / 2.0 * u
-        );
-        pinInner = csg.makeCylinder(
-          [5 * u, 5 * u, 0],
-          [5 * u, 5 * u, outerHeight - u],
-          1.5 * u
-        );
+        const pt9 = [5 * u, 5 * u, 0];
+        const pt10 = [5 * u, 5 * u, outerHeight - u];
+        pinOuter = csg.makeCylinder(pt9, pt10, 4.07 / 2.0 * u);
+
+        const pt11 = [5 * u, 5 * u, 0];
+        const pt12 = [5 * u, 5 * u, outerHeight - u];
+        pinInner = csg.makeCylinder(pt11, pt12, 1.5 * u);
+
         let pin = csg.cut(pinOuter, pinInner);
 
         for (let x = 0; x < nX - 1; x++) {
@@ -546,34 +540,29 @@ exports.makeLegoBrick = function (csg, nX, nY, h) {
     let brick = csg.makeBox([0, 0, 0], [outerWidth, outerLength, outerHeight]);
     brick = csg.makeThickSolid(brick, brick.faces.bottom, -u);
 
-    const h2 = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, outerHeight],
-      [2.5 * u, 2.5 * u, outerHeight + u],
-      1.5 * u);
+    const pt1 = [2.5 * u, 2.5 * u, outerHeight];
+    const pt2 = [2.5 * u, 2.5 * u, outerHeight + u];
+    const h2 = csg.makeCylinder(pt1, pt2, 1.5 * u);
 
     let tetons = makeRepetition(csg, h2, 5 * u, nX, 5 * u, nY);
     brick = csg.fuse(brick, tetons);
 
-    const h1 = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, outerHeight - 3 * u],
-      [2.5 * u, 2.5 * u, outerHeight + 0.75],
-      0.74 * u);
+    const pt3 = [2.5 * u, 2.5 * u, outerHeight - 3 * u];
+    const pt4 = [2.5 * u, 2.5 * u, outerHeight + 0.75];
+    const h1 = csg.makeCylinder(pt3, pt4, 0.74 * u);
     tetons = makeRepetition(csg, h1, 5 * u, nX, 5 * u, nY);
     brick = csg.cut(brick, tetons);
 
     //xx console.log(Object.keys(brick.faces));//.bottom);
 
     // small pins
-    let pinOuter = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, 0],
-      [2.5 * u, 2.5 * u, outerHeight - u],
-      u
-    );
-    let pinInner = csg.makeCylinder(
-      [2.5 * u, 2.5 * u, 0],
-      [2.5 * u, 2.5 * u, outerHeight - u],
-      0.5 * u
-    );
+    const pt5 = [2.5 * u, 2.5 * u, 0];
+    const pt6 = [2.5 * u, 2.5 * u, outerHeight - u];
+    let pinOuter = csg.makeCylinder(pt5, pt6, u);
+
+    const pt7 = [2.5 * u, 2.5 * u, 0];
+    const pt8 = [2.5 * u, 2.5 * u, outerHeight - u];
+    let pinInner = csg.makeCylinder(pt7, pt8, 0.5 * u);
 
     let pin = csg.cut(pinOuter, pinInner);
 
@@ -748,8 +737,7 @@ exports.makeTutorialPart = function (occ) {
             const lastVertex = edge.lastVertex;
             return ( samePoint(firstVertex, p) || samePoint(lastVertex, p)) &&
               same(firstVertex.x, lastVertex.x, 0.01) &&
-              same(firstVertex.y, lastVertex.y, 0.01)
-              ;
+              same(firstVertex.y, lastVertex.y, 0.01);
         });
         return results[0];
     }