@jscad/modeling 2.7.2 → 2.9.1

package/src/geometries/poly3/isA.js

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a polygon.
- * @param {Object} object - the object to interogate
+ * Determine if the given object is a polygon.
+ * @param {Object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a poly3
  * @alias module:modeling/geometries/poly3.isA
  */

package/src/geometries/poly3/isConvex.js

@@ -3,11 +3,11 @@ const vec3 = require('../../maths/vec3')
 
 /**
  * Check whether the given polygon is convex.
- * @param {poly3} polygon - the polygon to interogate
+ * @param {poly3} polygon - the polygon to interrogate
  * @returns {Boolean} true if convex
  * @alias module:modeling/geometries/poly3.isConvex
  */
-const isConvex = (poly3) => areVerticesConvex(poly3.vertices)
+const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
 
 const areVerticesConvex = (vertices) => {
   const numvertices = vertices.length

package/src/geometries/poly3/measureArea.js

@@ -7,15 +7,15 @@ const plane = require('./plane')
  * @return {Number} area of the polygon
  * @alias module:modeling/geometries/poly3.measureArea
  */
-const measureArea = (poly3) => {
-  const n = poly3.vertices.length
+const measureArea = (polygon) => {
+  const n = polygon.vertices.length
   if (n < 3) {
     return 0 // degenerate polygon
   }
-  const vertices = poly3.vertices
+  const vertices = polygon.vertices
 
   // calculate a normal vector
-  const normal = plane(poly3)
+  const normal = plane(polygon)
 
   // determine direction of projection
   const ax = Math.abs(normal[0])

package/src/geometries/poly3/measureArea.test.js

@@ -62,10 +62,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   rotation = mat4.fromYRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)
@@ -76,10 +76,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   rotation = mat4.fromXRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)
@@ -90,10 +90,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   // inverted
   ply1 = invert(ply1)
@@ -104,8 +104,8 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON * 2)
 })

package/src/geometries/poly3/measureBoundingBox.js

@@ -5,8 +5,8 @@ const vec3 = require('../../maths/vec3')
  * @returns {Array} an array of two vectors (3D);  minimum and maximum coordinates
  * @alias module:modeling/geometries/poly3.measureBoundingBox
  */
-const measureBoundingBox = (poly3) => {
-  const vertices = poly3.vertices
+const measureBoundingBox = (polygon) => {
+  const vertices = polygon.vertices
   const numvertices = vertices.length
   const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0])
   const max = vec3.clone(min)

package/src/geometries/poly3/measureBoundingSphere.js

@@ -7,8 +7,8 @@ const measureBoundingBox = require('./measureBoundingBox')
  * @returns {Array} the computed bounding sphere; center point (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
-const measureBoundingSphere = (poly3) => {
-  const box = measureBoundingBox(poly3)
+const measureBoundingSphere = (polygon) => {
+  const box = measureBoundingBox(polygon)
   const center = box[0]
   vec3.add(center, box[0], box[1])
   vec3.scale(center, center, 0.5)

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -10,21 +10,21 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let exp1 = [[0, 0, 0], 0]
   let ret1 = measureBoundingSphere(ply1)
   t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(ret1[1], exp1[1], Number.EPSILON)
+  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
 
   // simple triangle
   let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [[0, 5, 5], 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
   t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(ret2[1], exp2[1], Number.EPSILON)
+  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
 
   // simple square
   let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let exp3 = [[0, 5, 5], 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
   t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(ret3[1], exp3[1], Number.EPSILON)
+  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
 
   // V-shape
   const points = [
@@ -43,7 +43,7 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let exp4 = [[0, 4.5, 3], 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
   t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(ret4[1], exp4[1], Number.EPSILON)
+  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
 
   // rotated to various angles
   const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
@@ -57,14 +57,14 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ret4 = measureBoundingSphere(ply4)
   exp1 = [[0, 0, 0], 0]
   t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(ret1[1], exp1[1], Number.EPSILON)
+  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
   exp2 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
   t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(ret2[1], exp2[1], Number.EPSILON)
+  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
   exp3 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
   t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(ret3[1], exp3[1], Number.EPSILON)
+  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
   exp4 = [[-3.181980515339464, 3.1819805153394642, 3], 4.6097722286464435]
   t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(ret4[1], exp4[1], Number.EPSILON)
+  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
 })

package/src/geometries/poly3/measureSignedVolume.js

@@ -2,17 +2,17 @@ const vec3 = require('../../maths/vec3')
 
 /**
  * Measure the signed volume of the given polygon, which must be convex.
- * The volume is that formed by the tetrahedon connected to the axis [0,0,0],
+ * The volume is that formed by the tetrahedron connected to the axis [0,0,0],
  * and will be positive or negative based on the rotation of the vertices.
  * @see http://chenlab.ece.cornell.edu/Publication/Cha/icip01_Cha.pdf
  * @param {poly3} polygon - the polygon to measure
  * @return {Number} volume of the polygon
  * @alias module:modeling/geometries/poly3.measureSignedVolume
  */
-const measureSignedVolume = (poly3) => {
+const measureSignedVolume = (polygon) => {
   let signedVolume = 0
-  const vertices = poly3.vertices
-  // calculate based on triangluar polygons
+  const vertices = polygon.vertices
+  // calculate based on triangular polygons
   const cross = vec3.create()
   for (let i = 0; i < vertices.length - 2; i++) {
     vec3.cross(cross, vertices[i + 1], vertices[i + 2])

package/src/geometries/poly3/toPoints.js

@@ -1,10 +1,10 @@
 /**
- * Return the given geometry as a list of points.
+ * Return the given polygon as a list of points.
  * NOTE: The returned array should not be modified as the points are shared with the geometry.
  * @param {poly3} polygon - the polygon
  * @return {Array} list of points (3D)
  * @alias module:modeling/geometries/poly3.toPoints
  */
-const toPoints = (geometry) => geometry.vertices
+const toPoints = (polygon) => polygon.vertices
 
 module.exports = toPoints

package/src/geometries/poly3/toString.js

@@ -5,9 +5,9 @@ const vec3 = require('../../maths/vec3/')
  * @return {String} the string representation
  * @alias module:modeling/geometries/poly3.toString
  */
-const toString = (poly3) => {
+const toString = (polygon) => {
   let result = 'poly3: vertices: ['
-  poly3.vertices.forEach((vertex) => {
+  polygon.vertices.forEach((vertex) => {
     result += `${vec3.toString(vertex)}, `
   })
   result += ']'

package/src/geometries/poly3/transform.js

@@ -10,8 +10,8 @@ const create = require('./create')
  * @returns {poly3} a new polygon
  * @alias module:modeling/geometries/poly3.transform
  */
-const transform = (matrix, poly3) => {
-  const vertices = poly3.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix))
+const transform = (matrix, polygon) => {
+  const vertices = polygon.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix))
   if (mat4.isMirroring(matrix)) {
     // reverse the order to preserve the orientation
     vertices.reverse()

package/src/geometries/poly3/validate.d.ts

@@ -0,0 +1,4 @@
+
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/poly3/validate.js

@@ -0,0 +1,50 @@
+const vec3 = require('../../maths/vec3')
+const isA = require('./isA')
+const isConvex = require('./isConvex')
+const measureArea = require('./measureArea')
+
+/**
+ * Determine if the given object is a valid polygon.
+ * Checks for valid data structure, convex polygons, and duplicate points.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/poly3.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid poly3 structure')
+  }
+
+  // check for empty polygon
+  if (object.vertices.length < 3) {
+    throw new Error(`poly3 not enough vertices ${object.vertices.length}`)
+  }
+  // check area
+  if (measureArea(object) <= 0) {
+    throw new Error('poly3 area must be greater than zero')
+  }
+
+  // check for duplicate points
+  for (let i = 0; i < object.vertices.length; i++) {
+    if (vec3.equals(object.vertices[i], object.vertices[(i + 1) % object.vertices.length])) {
+      throw new Error(`poly3 duplicate vertex ${object.vertices[i]}`)
+    }
+  }
+
+  // check convexity
+  if (!isConvex(object)) {
+    throw new Error('poly3 must be convex')
+  }
+
+  // check for infinity, nan
+  object.vertices.forEach((vertex) => {
+    if (!vertex.every(Number.isFinite)) {
+      throw new Error(`poly3 invalid vertex ${vertex}`)
+    }
+  })
+}
+
+module.exports = validate

package/src/maths/index.js

@@ -1,6 +1,6 @@
 /**
  * Maths are computational units for fundamental Euclidean geometry. All maths operate upon array data structures.
- * Note: Maths data structues are consider immutable, so never change the contents directly.
+ * Note: Maths data structures are considered immutable, so never change the contents directly.
  * @see Most computations are based upon the glMatrix library (glmatrix.net)
  * @module modeling/maths
  * @example

package/src/maths/line2/equals.js

@@ -1,8 +1,8 @@
 /**
  * Compare the given lines for equality.
  *
- * @param {line2} a - first line to compare
- * @param {line2} b - second line to compare
+ * @param {line2} line1 - first line to compare
+ * @param {line2} line2 - second line to compare
  * @return {Boolean} true if lines are equal
  * @alias module:modeling/maths/line2.equals
  */

package/src/maths/line2/fromValues.js

@@ -9,11 +9,11 @@ const create = require('./create')
  * @returns {line2} a new unbounded line
  * @alias module:modeling/maths/line2.fromValues
  */
-const fromValues = (x, y, w) => {
+const fromValues = (x, y, d) => {
   const out = create()
   out[0] = x
   out[1] = y
-  out[2] = w
+  out[2] = d
   return out
 }
 

package/src/maths/line2/intersectPointOfLines.js

@@ -5,7 +5,7 @@ const { solve2Linear } = require('../utils')
  * Return the point of intersection between the given lines.
  *
  * NOTES:
- * The point will have Infinity values if the lines are paralell.
+ * The point will have Infinity values if the lines are parallel.
  * The point will have NaN values if the lines are the same.
  *
  * @param {line2} line1 - line of reference

package/src/maths/line2/intersectPointOfLines.test.js

@@ -15,7 +15,7 @@ test('line2: intersectPointOfLines() should return proper points', (t) => {
   const int3 = intersectPointOfLines(line3, line2)
   t.true(compareVectors(int3, [NaN, NaN]))
 
-  // paralell lines
+  // parallel lines
   const line4 = fromPoints(create(), [0, 6], [6, 0])
   const int4 = intersectPointOfLines(line4, line3)
   t.true(compareVectors(int4, [Infinity, -Infinity]))

package/src/maths/line2/reverse.test.js

@@ -3,7 +3,7 @@ const { reverse, create, fromPoints } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('line2: reverse() called with two paramerters should update a line2 with proper values', (t) => {
+test('line2: reverse() called with two parameters should update a line2 with proper values', (t) => {
   const line1 = create()
   const obs1 = create()
   const ret1 = reverse(obs1, line1)

package/src/maths/line2/transform.test.js

@@ -3,7 +3,7 @@ const { transform, create, fromPoints } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('line2: transform() called with three paramerters should update a line2 with correct values', (t) => {
+test('line2: transform() called with three parameters should update a line2 with correct values', (t) => {
   const line1 = create()
   const line2 = fromPoints(create(), [0, 0], [0, 1])
   const line3 = fromPoints(create(), [-3, -3], [3, 3])

package/src/maths/line3/equals.js

@@ -3,8 +3,8 @@ const vec3 = require('../vec3')
 /**
  * Compare the given lines for equality.
  *
- * @param {line3} a - first line to compare
- * @param {line3} b - second line to compare
+ * @param {line3} line1 - first line to compare
+ * @param {line3} line2 - second line to compare
  * @return {Boolean} true if lines are equal
  * @alias module:modeling/maths/line3.equals
  */

package/src/maths/line3/reverse.test.js

@@ -3,7 +3,7 @@ const { reverse, create, fromPoints } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('line3: reverse() called with two paramerters should update a line3 with proper values', (t) => {
+test('line3: reverse() called with two parameters should update a line3 with proper values', (t) => {
   const line1 = create()
   const out = create()
   let rev = reverse(out, line1)

package/src/maths/line3/transform.test.js

@@ -3,7 +3,7 @@ const { transform, create, fromPoints } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('line3: transform() called with three paramerters should update a line3 with correct values', (t) => {
+test('line3: transform() called with three parameters should update a line3 with correct values', (t) => {
   const line1 = create()
   const line2 = fromPoints(create(), [1, 0, 0], [0, 1, 0])
   const line3 = fromPoints(create(), [-3, -3, -3], [3, 3, 3])

package/src/maths/mat4/fromVectorRotation.js

@@ -5,7 +5,7 @@ const fromRotation = require('./fromRotation')
 /**
  * Create a matrix that rotates the given source to the given target vector.
  *
- * Each vector must be a directional vector with a length greater then zero.
+ * Each vector must be a directional vector with a length greater than zero.
  * @see https://gist.github.com/kevinmoran/b45980723e53edeb8a5a43c49f134724
  * @param {mat4} out - receiving matrix
  * @param {vec3} source - source vector

package/src/maths/mat4/fromVectorRotation.test.js

@@ -96,7 +96,7 @@ test('mat4: fromVectorRotation() called with out parameter should return a mat4
   t.is(ret, out)
   t.true(compareVectors(out, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
 
-  // differnt units
+  // different units
   ret = fromVectorRotation(out, [11, 0, 0], [0, 33, 0])
   t.is(ret, out)
   t.true(compareVectors(out, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))

package/src/maths/mat4/identity.test.js

@@ -3,7 +3,7 @@ const { identity } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('mat4: identity() called with one paramerters should update a mat4 with correct values', (t) => {
+test('mat4: identity() called with one parameters should update a mat4 with correct values', (t) => {
   const obs1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   const ret1 = identity(obs1)
   t.true(compareVectors(obs1, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))

package/src/maths/mat4/invert.js

@@ -4,27 +4,27 @@
  * code from https://github.com/jlmakes/rematrix/blob/master/src/index.js
  *
  * @param {mat4} out - receiving matrix
- * @param {mat4} m - matrix to invert
+ * @param {mat4} matrix - matrix to invert
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.invert
  */
-const invert = (out, a) => {
-  const a00 = a[0]
-  const a01 = a[1]
-  const a02 = a[2]
-  const a03 = a[3]
-  const a10 = a[4]
-  const a11 = a[5]
-  const a12 = a[6]
-  const a13 = a[7]
-  const a20 = a[8]
-  const a21 = a[9]
-  const a22 = a[10]
-  const a23 = a[11]
-  const a30 = a[12]
-  const a31 = a[13]
-  const a32 = a[14]
-  const a33 = a[15]
+const invert = (out, matrix) => {
+  const a00 = matrix[0]
+  const a01 = matrix[1]
+  const a02 = matrix[2]
+  const a03 = matrix[3]
+  const a10 = matrix[4]
+  const a11 = matrix[5]
+  const a12 = matrix[6]
+  const a13 = matrix[7]
+  const a20 = matrix[8]
+  const a21 = matrix[9]
+  const a22 = matrix[10]
+  const a23 = matrix[11]
+  const a30 = matrix[12]
+  const a31 = matrix[13]
+  const a32 = matrix[14]
+  const a33 = matrix[15]
 
   const b00 = a00 * a11 - a01 * a10
   const b01 = a00 * a12 - a02 * a10

package/src/maths/mat4/isIdentity.js

@@ -1,5 +1,5 @@
 /**
- * Determine whether the given matris is the identity transform.
+ * Determine whether the given matrix is the identity transform.
  * This is equivalent to (but much faster than):
  *
  *     mat4.equals(mat4.create(), matrix)

package/src/maths/mat4/isMirroring.js

@@ -9,10 +9,10 @@ const fromValues = require('../vec3/fromValues')
  * @returns {Boolean} true if matrix is a mirroring transformation
  * @alias module:modeling/maths/mat4.isMirroring
  */
-const isMirroring = (mat) => {
-  const u = fromValues(mat[0], mat[4], mat[8])
-  const v = fromValues(mat[1], mat[5], mat[9])
-  const w = fromValues(mat[2], mat[6], mat[10])
+const isMirroring = (matrix) => {
+  const u = fromValues(matrix[0], matrix[4], matrix[8])
+  const v = fromValues(matrix[1], matrix[5], matrix[9])
+  const w = fromValues(matrix[2], matrix[6], matrix[10])
 
   // for a true orthogonal, non-mirrored base, u.cross(v) == w
   // If they have an opposite direction then we are mirroring

package/src/maths/mat4/isMirroring.test.js

@@ -4,7 +4,7 @@ const plane = require('../plane')
 
 const { isMirroring, fromScaling, create, mirrorByPlane, rotate, scale, translate } = require('./index')
 
-test('mat4: isMirroring() should determine correctlly', (t) => {
+test('mat4: isMirroring() should determine correctly', (t) => {
   let matrix = create()
   t.false(isMirroring(matrix))
 

package/src/maths/mat4/leftMultiplyVec3.js

@@ -8,7 +8,7 @@ const fromValues = require('../vec3/fromValues')
  * @param {mat4} matrix the input matrix
  * @returns {vec3} output
  */
-const lefttMultiplyVec3 = (vector, matrix) => {
+const leftMultiplyVec3 = (vector, matrix) => {
   const [v0, v1, v2] = vector
   const v3 = 1
   let x = v0 * matrix[0] + v1 * matrix[4] + v2 * matrix[8] + v3 * matrix[12]
@@ -26,4 +26,4 @@ const lefttMultiplyVec3 = (vector, matrix) => {
   return fromValues(x, y, z)
 }
 
-module.exports = lefttMultiplyVec3
+module.exports = leftMultiplyVec3

package/src/maths/mat4/toString.js

@@ -1,10 +1,10 @@
 /**
  * Return a string representing the given matrix.
  *
- * @param {mat4} matrix - matrix of reference
+ * @param {mat4} mat - matrix of reference
  * @returns {String} string representation
  * @alias module:modeling/maths/mat4.toString
  */
-const toString = (mat) => `[${mat[0].toFixed(7)}, ${mat[1].toFixed(7)}, ${mat[2].toFixed(7)}, ${mat[3].toFixed(7)}, ${mat[4].toFixed(7)}, ${mat[5].toFixed(7)}, ${mat[6].toFixed(7)}, ${mat[7].toFixed(7)}, ${mat[8].toFixed(7)}, ${mat[9].toFixed(7)}, ${mat[10].toFixed(7)}, ${mat[11].toFixed(7)}, ${mat[12].toFixed(7)}, ${mat[13].toFixed(7)}, ${mat[14].toFixed(7)}, ${mat[15].toFixed(7)}]`
+const toString = (mat) => mat.map((n) => n.toFixed(7)).toString()
 
 module.exports = toString

package/src/maths/mat4/translate.test.js

@@ -3,7 +3,7 @@ const { translate, create } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('mat4: translate() called with three paramerters should update a mat4 with correct values', (t) => {
+test('mat4: translate() called with three parameters should update a mat4 with correct values', (t) => {
   const identityMatrix = [
     1, 0, 0, 0,
     0, 1, 0, 0,

package/src/maths/plane/flip.test.js

@@ -3,7 +3,7 @@ const { create, flip } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('plane: flip() called with two paramerters should update a plane with correct values', (t) => {
+test('plane: flip() called with two parameters should update a plane with correct values', (t) => {
   const org1 = create()
   const ret1 = flip(org1, [0, 0, 0, 0])
   t.true(compareVectors(org1, [-0, -0, -0, -0]))

package/src/maths/plane/fromPoints.d.ts

@@ -3,4 +3,4 @@ import Vec3 from '../vec3/type'
 
 export default fromPoints
 
-declare function fromPoints(out: Plane, a: Vec3, b: Vec3, c: Vec3): Plane
+declare function fromPoints(out: Plane, ...vertices: Array<Vec3>): Plane

package/src/maths/plane/fromPoints.js

@@ -4,9 +4,7 @@ const vec3 = require('../vec3')
  * Create a plane from the given points.
  *
  * @param {plane} out - receiving plane
- * @param {vec3} a - 3D point
- * @param {vec3} b - 3D point
- * @param {vec3} c - 3D point
+ * @param {Array} vertices - points on the plane
  * @returns {plane} out
  * @alias module:modeling/maths/plane.fromPoints
  */

package/src/maths/plane/signedDistanceToPoint.js

@@ -8,6 +8,6 @@ const vec3 = require('../vec3')
  * @return {Number} signed distance to point
  * @alias module:modeling/maths/plane.signedDistanceToPoint
  */
-const signedDistanceToPoint = (plane, vector) => vec3.dot(plane, vector) - plane[3]
+const signedDistanceToPoint = (plane, point) => vec3.dot(plane, point) - plane[3]
 
 module.exports = signedDistanceToPoint

package/src/maths/plane/transform.test.js

@@ -3,7 +3,7 @@ const { transform, create, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('plane: transform() called with three paramerters should return a plane with correct values', (t) => {
+test('plane: transform() called with three parameters should return a plane with correct values', (t) => {
   const identityMatrix = [
     1, 0, 0, 0,
     0, 1, 0, 0,

package/src/maths/utils/aboutEqualNormals.js

@@ -1,5 +1,5 @@
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparision
-// This EPS is derived from a serieas of tests to determine the optimal precision for comparing coplanar polygons,
+// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
+// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
 // as provided by the sphere primitive at high segmentation
 // This EPS is for 64 bit Number values
 const NEPS = 1e-13

package/src/maths/vec2/abs.d.ts

@@ -2,4 +2,4 @@ import Vec2 from './type'
 
 export default abs
 
-declare function abs(out: Vec2, vec: Vec2): Vec2
+declare function abs(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/add.test.js

@@ -3,7 +3,7 @@ const { add, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec2: add() called with three paramerters should update a vec2 with correct values', (t) => {
+test('vec2: add() called with three parameters should update a vec2 with correct values', (t) => {
   const obs1 = fromValues(0, 0)
   const ret1 = add(obs1, [0, 0], [0, 0])
   t.true(compareVectors(obs1, [0, 0]))