@jscad/modeling 2.7.0 → 2.8.0

package/src/operations/hulls/hullPoints2.test.js

@@ -42,7 +42,7 @@ test('hullPoints2 bug #114 2 circles with 18 segments', (t) => {
     [7.298133329356933, -1.9283628290596186]
   ]
 
-  // we just want to bwe sure no err happens for this case
+  // we just want to be sure no err happens for this case
   const out = hullPoints2(points)
   t.is(out.length, 19)
 })

package/src/operations/hulls/quickhull/QuickHull.js

@@ -722,7 +722,7 @@ class QuickHull {
     for (let i = 0; i < this.newFaces.length; i += 1) {
       const face = this.newFaces[i]
       if (face.mark === VISIBLE) {
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {}
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {} // eslint-disable-line no-empty
       }
     }
 
@@ -733,7 +733,7 @@ class QuickHull {
       const face = this.newFaces[i]
       if (face.mark === NON_CONVEX) {
         face.mark = VISIBLE
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {}
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {} // eslint-disable-line no-empty
       }
     }
 

package/src/operations/modifiers/edges.js

@@ -99,9 +99,7 @@ const splitPolygon = (openedge, polygon, eps) => {
 /*
  * TBD This should be part of vec3.
  */
-const almostEquals = (eps, v1, v2) => {
-  return (Math.abs(v1[0] - v2[0]) <= eps && Math.abs(v1[1] - v2[1]) <= eps && Math.abs(v1[2] - v2[2]) <= eps)
-}
+const almostEquals = (eps, v1, v2) => (Math.abs(v1[0] - v2[0]) <= eps && Math.abs(v1[1] - v2[1]) <= eps && Math.abs(v1[2] - v2[2]) <= eps)
 
 const enclosedEdge = (openedge, edge, eps) => {
   if (openedge.distance < edge.distance) {
@@ -151,7 +149,7 @@ const splitEdge = (openedges, edge, eps) => {
  */
 const cullOpenEdges = (edges) => {
   const openedges = []
-  edges.forEach((edge, i) => {
+  edges.forEach((edge) => {
     const polygons = edge.polygons
     if (polygons.length === 1) {
       // console.log('open edge: ',edge[0],'<-->',edge[1])

package/src/operations/modifiers/generalize.js

@@ -15,15 +15,11 @@ const repairTjunctions = require('./repairTjunctions')
 
 /*
  */
-const generalizePath2 = (options, geometry) => {
-  return geometry
-}
+const generalizePath2 = (options, geometry) => geometry
 
 /*
  */
-const generalizeGeom2 = (options, geometry) => {
-  return geometry
-}
+const generalizeGeom2 = (options, geometry) => geometry
 
 /*
  */
@@ -77,6 +73,7 @@ const generalizeGeom3 = (options, geometry) => {
  * @param {Boolean} [options.simplify=false] the geometries should be simplified
  * @param {Boolean} [options.triangulate=false] the geometries should be triangulated
  * @param {Boolean} [options.repair=false] the geometries should be repaired
+ * @param {...Object} geometries - the geometries to generalize
  * @return {Object|Array} the modified geometry, or a list of modified geometries
  * @alias module:modeling/modifiers.generalize
  */
@@ -84,7 +81,7 @@ const generalize = (options, ...geometries) => {
   geometries = flatten(geometries)
   if (geometries.length === 0) throw new Error('wrong number of arguments')
 
-  const results = geometries.map((geometry, i) => {
+  const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return generalizePath2(options, geometry)
     if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
     if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)

package/src/operations/modifiers/snap.test.js

@@ -11,7 +11,7 @@ const { snap } = require('./index')
 test('snap: snap of a path2 produces an expected path2', (t) => {
   const geometry1 = path2.create()
   const geometry2 = arc({ radius: 1 / 2, segments: 8 })
-  const geometry3 = arc({ radius: 1.3333333333333333333 / 2, segments: 8 })
+  const geometry3 = arc({ radius: 1.3333333333333333 / 2, segments: 8 })
   const geometry4 = arc({ radius: Math.PI * 1000 / 2, segments: 8 })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
@@ -55,7 +55,7 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
 test('snap: snap of a geom2 produces an expected geom2', (t) => {
   const geometry1 = geom2.create()
   const geometry2 = rectangle({ size: [1, 1, 1] })
-  const geometry3 = rectangle({ size: [1.3333333333333333333, 1.3333333333333333333, 1.3333333333333333333] })
+  const geometry3 = rectangle({ size: [1.3333333333333333, 1.3333333333333333, 1.3333333333333333] })
   const geometry4 = rectangle({ size: [Math.PI * 1000, Math.PI * 1000, Math.PI * 1000] })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
@@ -87,7 +87,7 @@ test('snap: snap of a geom2 produces an expected geom2', (t) => {
 test('snap: snap of a geom3 produces an expected geom3', (t) => {
   const geometry1 = geom3.create()
   const geometry2 = cuboid({ size: [1, 1, 1] })
-  const geometry3 = cuboid({ size: [1.3333333333333333333, 1.3333333333333333333, 1.3333333333333333333] })
+  const geometry3 = cuboid({ size: [1.3333333333333333, 1.3333333333333333, 1.3333333333333333] })
   const geometry4 = cuboid({ size: [Math.PI * 1000, Math.PI * 1000, Math.PI * 1000] })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)

package/src/operations/transforms/align.d.ts

@@ -7,7 +7,7 @@ type NullableNumber = null | number
 
 export interface AlignOptions {
   modes?: Array<'center' | 'max' | 'min' | 'none'>
-  relativeTo?: [NullableNumber] | [NullableNumber | NullableNumber] | [NullableNumber | NullableNumber | NullableNumber]
+  relativeTo?: [NullableNumber] | [NullableNumber, NullableNumber] | [NullableNumber, NullableNumber, NullableNumber]
   grouped?: boolean
 }
 

package/src/operations/transforms/center.js

@@ -24,18 +24,18 @@ const centerGeometry = (options, object) => {
 }
 
 /**
- * Center the given geometries using the given options.
+ * Center the given objects using the given options.
  * @param {Object} options - options for centering
  * @param {Array} [options.axes=[true,true,true]] - axis of which to center, true or false
- * @param {Array} [options.relativeTo=[0,0,0]] - relative point of which to center the geometries
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometries
+ * @param {Array} [options.relativeTo=[0,0,0]] - relative point of which to center the objects
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.center
  *
  * @example
  * let myshape = center({axes: [true,false,false]}, sphere()) // center about the X axis
  */
-const center = (options, ...geometries) => {
+const center = (options, ...objects) => {
   const defaults = {
     axes: [true, true, true],
     relativeTo: [0, 0, 0]
@@ -43,13 +43,13 @@ const center = (options, ...geometries) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
   if (relativeTo.length !== 3) throw new Error('relativeTo must be an array of length 3')
 
   options = { axes, relativeTo }
 
-  const results = geometries.map((object) => {
+  const results = objects.map((object) => {
     if (path2.isA(object)) return centerGeometry(options, object)
     if (geom2.isA(object)) return centerGeometry(options, object)
     if (geom3.isA(object)) return centerGeometry(options, object)
@@ -59,25 +59,25 @@ const center = (options, ...geometries) => {
 }
 
 /**
- * Center the given geometries about the X axis.
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometry
+ * Center the given objects about the X axis.
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerX
  */
 const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
 
 /**
- * Center the given geometries about the Y axis.
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometry
+ * Center the given objects about the Y axis.
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerY
  */
 const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
 
 /**
- * Center the given geometries about the Z axis.
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometry
+ * Center the given objects about the Z axis.
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerZ
  */
 const centerZ = (...objects) => center({ axes: [false, false, true] }, objects)

package/src/operations/transforms/mirror.js

@@ -8,12 +8,12 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Mirror the given geometries using the given options.
+ * Mirror the given objects using the given options.
  * @param {Object} options - options for mirror
  * @param {Array} [options.origin=[0,0,0]] - the origin of the plane
  * @param {Array} [options.normal=[0,0,1]] - the normal vector of the plane
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * @param {...Object} objects - the objects to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirror
  *
  * @example
@@ -47,25 +47,25 @@ const mirror = (options, ...objects) => {
 }
 
 /**
- * Mirror the given geometries about the X axis.
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * Mirror the given objects about the X axis.
+ * @param {...Object} objects - the objects to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorX
  */
 const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
 
 /**
- * Mirror the given geometries about the Y axis.
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * Mirror the given objects about the Y axis.
+ * @param {...Object} objects - the geometries to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorY
  */
 const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
 
 /**
- * Mirror the given object(s) about the Z axis.
+ * Mirror the given objects about the Z axis.
  * @param {...Object} objects - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorZ
  */
 const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, objects)

package/src/operations/transforms/rotate.js

@@ -7,10 +7,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Rotate the given geometries using the given options.
+ * Rotate the given objects using the given options.
  * @param {Array} angles - angle (RADIANS) of rotations about X, Y, and Z axis
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotate
  *
  * @example
@@ -42,28 +42,28 @@ const rotate = (angles, ...objects) => {
 }
 
 /**
- * Rotate the given object(s) about the X axis, using the given options.
+ * Rotate the given objects about the X axis, using the given options.
  * @param {Number} angle - angle (RADIANS) of rotations about X
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateX
  */
 const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
 
 /**
- * Rotate the given object(s) about the Y axis, using the given options.
+ * Rotate the given objects about the Y axis, using the given options.
  * @param {Number} angle - angle (RADIANS) of rotations about Y
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateY
  */
 const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
 
 /**
- * Rotate the given object(s) about the Z axis, using the given options.
+ * Rotate the given objects about the Z axis, using the given options.
  * @param {Number} angle - angle (RADIANS) of rotations about Z
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateZ
  */
 const rotateZ = (angle, ...objects) => rotate([0, 0, angle], objects)

package/src/operations/transforms/scale.js

@@ -7,10 +7,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Scale the given geometries using the given options.
- * @param {Array} factors - X, Y, Z factors by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects using the given options.
+ * @param {Array} factors - X, Y, Z factors by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scale
  *
  * @example
@@ -40,31 +40,31 @@ const scale = (factors, ...objects) => {
 }
 
 /**
- * Scale the given geometries about the X axis using the given options.
- * @param {Number} factor - X factor by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects about the X axis using the given options.
+ * @param {Number} factor - X factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleX
  */
-const scaleX = (offset, ...objects) => scale([offset, 1, 1], objects)
+const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
 
 /**
- * Scale the given geometries about the Y axis using the given options.
- * @param {Number} factor - Y factor by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects about the Y axis using the given options.
+ * @param {Number} factor - Y factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleY
  */
-const scaleY = (offset, ...objects) => scale([1, offset, 1], objects)
+const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
 
 /**
- * Scale the given geometries about the Z axis using the given options.
- * @param {Number} factor - Z factor by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects about the Z axis using the given options.
+ * @param {Number} factor - Z factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleZ
  */
-const scaleZ = (offset, ...objects) => scale([1, 1, offset], objects)
+const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)
 
 module.exports = {
   scale,

package/src/operations/transforms/transform.js

@@ -5,10 +5,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Transform the given geometries using the given matrix.
+ * Transform the given objects using the given matrix.
  * @param {mat4} matrix - a transformation matrix
- * @param {...Object} geometries - the geometries to transform
- * @return {Object|Array} the transformed geometry, or a list of transformed geometries
+ * @param {...Object} objects - the objects to transform
+ * @return {Object|Array} the transformed object, or a list of transformed objects
  * @alias module:modeling/transforms.transform
  *
  * @example

package/src/operations/transforms/translate.js

@@ -7,10 +7,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Translate the given geometries using the given options.
- * @param {Array} offset - offset (vector) of which to translate the geometries
- * @param {...Object} geometries - the geometries to translate
- * @return {Object|Array} the translated geometry, or a list of translated geometries
+ * Translate the given objects using the given options.
+ * @param {Array} offset - offset (vector) of which to translate the objects
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translate
  *
  * @example
@@ -38,28 +38,28 @@ const translate = (offset, ...objects) => {
 }
 
 /**
- * Translate the given geometries along the X axis using the given options.
- * @param {Number} offset - X offset of which to translate the geometries
- * @param {...Object} geometries - the geometries to translate
- * @return {Object|Array} the translated geometry, or a list of translated geometries
+ * Translate the given objects along the X axis using the given options.
+ * @param {Number} offset - X offset of which to translate the objects
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateX
  */
 const translateX = (offset, ...objects) => translate([offset, 0, 0], objects)
 
 /**
- * Translate the given geometries along the Y axis using the given options.
+ * Translate the given objects along the Y axis using the given options.
  * @param {Number} offset - Y offset of which to translate the geometries
- * @param {...Object} geometries - the geometries to translate
- * @return {Object|Array} the translated geometry, or a list of translated geometries
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateY
  */
 const translateY = (offset, ...objects) => translate([0, offset, 0], objects)
 
 /**
- * Translate the given geometries along the Z axis using the given options.
+ * Translate the given objects along the Z axis using the given options.
  * @param {Number} offset - Z offset of which to translate the geometries
- * @param {...Object} geometries - the geometries to translate
- * @return {Object|Array} the translated geometry, or a list of translated geometries
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateZ
  */
 const translateZ = (offset, ...objects) => translate([0, 0, offset], objects)

package/src/primitives/arc.js

@@ -78,7 +78,7 @@ const arc = (options) => {
       pointArray.push(point)
     }
   }
-  return path2.fromPoints({ close: false }, pointArray)
+  return path2.fromPoints({ closed: false }, pointArray)
 }
 
 module.exports = arc

package/src/primitives/cylinderElliptic.test.js

@@ -131,8 +131,6 @@ test('cylinderElliptic (options)', (t) => {
   // test startAngle and endAngle
   obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: Math.PI / 2, endAngle: Math.PI * 2 * 0.75, segments: 12 })
   pts = geom3.toPoints(obs)
-  exp = [
-  ]
 
   t.is(pts.length, 28)
   // t.true(comparePolygonsAsPoints(pts, exp))

package/src/primitives/ellipse.js

@@ -7,7 +7,7 @@ const geom2 = require('../geometries/geom2')
 const { isGTE, isNumberArray } = require('./commonChecks')
 
 /**
- * Construct an axis-aligned ellispe in two dimensional space.
+ * Construct an axis-aligned ellipse in two dimensional space.
  * @see https://en.wikipedia.org/wiki/Ellipse
  * @param {Object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of ellipse

package/src/primitives/ellipsoid.js

@@ -10,7 +10,7 @@ const { isGTE, isNumberArray } = require('./commonChecks')
  * @param {Object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of ellipsoid
  * @param {Array} [options.radius=[1,1,1]] - radius of ellipsoid, along X, Y and Z
- * @param {Number} [options.segments=32] - number of segements to create per full rotation
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
  * @param {Array} [options.axes] -  an array with three vectors for the x, y and z base vectors
  * @returns {geom3} new 3D geometry
  * @alias module:modeling/primitives.ellipsoid

package/src/primitives/ellipsoid.test.js

@@ -145,8 +145,6 @@ test('ellipsoid (options)', (t) => {
   // test segments
   obs = ellipsoid({ segments: 8 })
   pts = geom3.toPoints(obs)
-  exp = [
-  ]
   t.is(pts.length, 32)
 
   obs = ellipsoid({ center: [-3, 5, 7], segments: 8 })

package/src/primitives/geodesicSphere.d.ts

@@ -1,4 +1,3 @@
-import Vec3 from '../maths/vec3/type'
 import Geom3 from '../geometries/geom3/type'
 
 export default geodesicSphere

package/src/primitives/geodesicSphere.js

@@ -79,7 +79,7 @@ const geodesicSphere = (options) => {
 
         // -- normalize
         for (let k = 0; k < 3; k++) {
-          const r = Math.sqrt(q[k][0] * q[k][0] + q[k][1] * q[k][1] + q[k][2] * q[k][2])
+          const r = Math.hypot(q[k][0], q[k][1], q[k][2])
           for (let l = 0; l < 3; l++) {
             q[k][l] /= r
           }
@@ -95,7 +95,7 @@ const geodesicSphere = (options) => {
 
           // -- normalize
           for (let k = 0; k < 3; k++) {
-            const r = Math.sqrt(q[k][0] * q[k][0] + q[k][1] * q[k][1] + q[k][2] * q[k][2])
+            const r = Math.hypot(q[k][0], q[k][1], q[k][2])
             for (let l = 0; l < 3; l++) {
               q[k][l] /= r
             }

package/src/primitives/polyhedron.js

@@ -11,7 +11,7 @@ const { isNumberArray } = require('./commonChecks')
  * @param {Array} options.points - list of points in 3D space
  * @param {Array} options.faces - list of faces, where each face is a set of indexes into the points
  * @param {Array} [options.colors=undefined] - list of RGBA colors to apply to each face
- * @param {Array} [options.orientation='outward'] - orientation of faces
+ * @param {String} [options.orientation='outward'] - orientation of faces
  * @returns {geom3} new 3D geometry
  * @alias module:modeling/primitives.polyhedron
  *

package/src/primitives/roundedCylinder.js

@@ -11,7 +11,7 @@ const { isGT, isGTE, isNumberArray } = require('./commonChecks')
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
  * @param {Object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
- * @param {Array} [options.height=2] - height of cylinder
+ * @param {Number} [options.height=2] - height of cylinder
  * @param {Number} [options.radius=1] - radius of cylinder
  * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
  * @param {Number} [options.segments=32] - number of segments to create per full rotation

package/src/primitives/torus.d.ts

@@ -1,4 +1,3 @@
-import Vec3 from '../maths/vec3/type'
 import Geom3 from '../geometries/geom3/type'
 
 export default torus

package/src/primitives/triangle.js

@@ -119,13 +119,13 @@ const createTriangle = (A, B, C, a, b, c) => {
  * The triangle is always constructed CCW from the origin, [0, 0, 0].
  * @see https://www.mathsisfun.com/algebra/trig-solving-triangles.html
  * @param {Object} [options] - options for construction
- * @param {String} [options.type='SSS' - type of triangle to construct; A ~ angle, S ~ side
+ * @param {String} [options.type='SSS'] - type of triangle to construct; A ~ angle, S ~ side
  * @param {Array} [options.values=[1,1,1]] - angle (radians) of corners or length of sides
  * @returns {geom2} new 2D geometry
  * @alias module:modeling/primitives.triangle
  *
  * @example
- * let myshape = triangle({type: 'AAS', values: [values: [degToRad(62), degToRad(35), 7]})
+ * let myshape = triangle({type: 'AAS', values: [degToRad(62), degToRad(35), 7]})
  */
 const triangle = (options) => {
   const defaults = {

package/src/text/vectorText.js

@@ -26,7 +26,7 @@ const translateLine = (options, line) => {
  * @param {Float} [options.height=21] - font size (uppercase height)
  * @param {Float} [options.lineSpacing=1.4] - line spacing expressed as a percentage of font size
  * @param {Float} [options.letterSpacing=1] - extra letter spacing expressed as a percentage of font size
- * @param {String} [options.align='left'] - multi-line text alignement: left, center or right
+ * @param {String} [options.align='left'] - multi-line text alignment: left, center, right
  * @param {Float} [options.extrudeOffset=0] - width of the extrusion that will be applied (manually) after the creation of the character
  * @param {String} [options.input='?'] - ascii string (ignored/overwrited if provided as seconds parameter)
  * @param {String} [text='?'] - ascii string
@@ -47,7 +47,7 @@ const vectorText = (options, text) => {
     xOffset, yOffset, input, font, height, align, extrudeOffset, lineSpacing, letterSpacing
   } = vectorParams(options, text)
   let [x, y] = [xOffset, yOffset]
-  let [i, il, char, vect, width, diff] = []
+  let i, il, char, vect, width, diff
   let line = { width: 0, segments: [] }
   const lines = []
   let output = []

package/src/utils/insertSorted.js

@@ -1,4 +1,5 @@
 /**
+ * Insert the given element into the give array using the compareFunction.
  * @alias module:modeling/utils.insertSorted
  */
 const insertSorted = (array, element, comparefunc) => {

package/src/utils/padArrayToLength.js

@@ -3,7 +3,7 @@
  * @param {Array} anArray - the source array to copy into the result.
  * @param {*} padding - the value to add to the new array to reach the desired length.
  * @param {Number} targetLength - The desired length of the return array.
- * @returns {Array} an array of at least 'targetLength" length
+ * @returns {Array} an array of at least 'targetLength' length
  * @alias module:modeling/utils.padArrayToLength
  */
 const padArrayToLength = (anArray, padding, targetLength) => {

package/test/helpers/comparePolygons.js

@@ -8,9 +8,7 @@ const compareVectors = require('./compareVectors')
  */
 const comparePolygons = (poly1, poly2) => {
   if (poly1.vertices.length === poly2.vertices.length) {
-    return poly1.vertices.reduce((valid, vertex, index) => {
-      return valid && compareVectors(poly1.vertices[index], poly2.vertices[index])
-    }, true)
+    return poly1.vertices.reduce((valid, vertex, index) => valid && compareVectors(poly1.vertices[index], poly2.vertices[index]), true)
   }
   return false
 }

package/test/helpers/nearlyEqual.js

@@ -1,7 +1,6 @@
 // Compare two numeric values for near equality.
 // the given test is fails if the numeric values are outside the given epsilon
 const nearlyEqual = (t, a, b, epsilon, failMessage) => {
-// console.log('nearEqual(t,'+a+','+b+','+epsilon+')')
   if (a === b) { // shortcut, also handles infinities and NaNs
     return true
   }
@@ -10,11 +9,9 @@ const nearlyEqual = (t, a, b, epsilon, failMessage) => {
   const absB = Math.abs(b)
   const diff = Math.abs(a - b)
   if (Number.isNaN(diff)) {
-    return false
+    failMessage = failMessage === undefined ? 'difference is not a number' : failMessage
+    t.fail(failMessage + '(' + a + ',' + b + ')')
   }
-  // console.log(absA)
-  // console.log(absB)
-  // console.log(diff)
   if (a === 0 || b === 0 || diff < Number.EPSILON) {
   // a or b is zero or both are extremely close to it
   // relative error is less meaningful here
@@ -25,7 +22,6 @@ const nearlyEqual = (t, a, b, epsilon, failMessage) => {
   }
   // use relative error
   const relative = (diff / Math.min((absA + absB), Number.MAX_VALUE))
-  // console.log(relative)
   if (relative > epsilon) {
     failMessage = failMessage === undefined ? 'Numbers outside of epsilon' : failMessage
     t.fail(failMessage + '(' + a + ',' + b + ')')