@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/geometries/poly3/measureArea.js

@@ -1,13 +1,13 @@
-const plane = require('./plane')
+import { plane } from './plane.js'
 
 /**
  * Measure the area of the given polygon.
  * @see 2000 softSurfer http://geomalgorithms.com
- * @param {poly3} polygon - the polygon to measure
- * @return {Number} area of the polygon
+ * @param {Poly3} polygon - the polygon to measure
+ * @return {number} area of the polygon
  * @alias module:modeling/geometries/poly3.measureArea
  */
-const measureArea = (polygon) => {
+export const measureArea = (polygon) => {
   const n = polygon.vertices.length
   if (n < 3) {
     return 0 // degenerate polygon
@@ -79,5 +79,3 @@ const measureArea = (polygon) => {
   }
   return area
 }
-
-module.exports = measureArea

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

@@ -1,9 +1,10 @@
-const test = require('ava')
-const { measureArea, create, invert, fromPoints, transform } = require('./index')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { nearlyEqual } = require('../../../test/helpers/index')
+import { measureArea, create, invert, transform } from './index.js'
+
+import { nearlyEqual } from '../../../test/helpers/index.js'
 
 test('poly3: measureArea() should return correct values', (t) => {
   let ply1 = create()
@@ -11,17 +12,17 @@ test('poly3: measureArea() should return correct values', (t) => {
   t.is(ret1, 0.0)
 
   // simple triangle
-  let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
+  let ply2 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let ret2 = measureArea(ply2)
   t.is(ret2, 50.0)
 
   // simple square
-  let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
+  let ply3 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let ret3 = measureArea(ply3)
   t.is(ret3, 100.0)
 
   // V-shape
-  const points = [
+  const vertices = [
     [0, 3, 0],
     [0, 5, 0],
     [0, 8, 2],
@@ -33,22 +34,22 @@ test('poly3: measureArea() should return correct values', (t) => {
     [0, 1, 3],
     [0, 3, 3]
   ]
-  let ply4 = fromPoints(points)
+  let ply4 = create(vertices)
   let ret4 = measureArea(ply4)
   t.is(ret4, 19.5)
 
   // colinear vertices non-zero area
-  const ply5 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0]])
+  const ply5 = create([[0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0]])
   const ret5 = measureArea(ply5)
   t.is(ret5, 1)
 
   // colinear vertices empty area
-  const ply6 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
+  const ply6 = create([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
   const ret6 = measureArea(ply6)
   t.is(ret6, 0)
 
   // duplicate vertices empty area
-  const ply7 = fromPoints([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+  const ply7 = create([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
   const ret7 = measureArea(ply7)
   t.is(ret7, 0)
 

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

@@ -1,6 +1,4 @@
-import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import type { Poly3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
 
-export default measureBoundingBox
-
-declare function measureBoundingBox(polygon: Poly3): [Vec3, Vec3]
+export function measureBoundingBox(polygon: Poly3): [Vec3, Vec3]

package/src/geometries/poly3/measureBoundingBox.js

@@ -1,20 +1,18 @@
-const vec3 = require('../../maths/vec3')
+import * as vec3 from '../../maths/vec3/index.js'
 
 /**
- * @param {poly3} polygon - the polygon to measure
+ * @param {Poly3} polygon - the polygon to measure
  * @returns {Array} an array of two vectors (3D);  minimum and maximum coordinates
  * @alias module:modeling/geometries/poly3.measureBoundingBox
  */
-const measureBoundingBox = (polygon) => {
+export const measureBoundingBox = (polygon) => {
   const vertices = polygon.vertices
-  const numvertices = vertices.length
-  const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0])
+  const numVertices = vertices.length
+  const min = numVertices === 0 ? vec3.create() : vec3.clone(vertices[0])
   const max = vec3.clone(min)
-  for (let i = 1; i < numvertices; i++) {
+  for (let i = 1; i < numVertices; i++) {
     vec3.min(min, min, vertices[i])
     vec3.max(max, max, vertices[i])
   }
   return [min, max]
 }
-
-module.exports = measureBoundingBox

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

@@ -1,9 +1,10 @@
-const test = require('ava')
-const { measureBoundingBox, create, fromPoints, transform } = require('./index')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { measureBoundingBox, create, transform } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('poly3: measureBoundingBox() should return correct values', (t) => {
   let ply1 = create()
@@ -13,21 +14,21 @@ test('poly3: measureBoundingBox() should return correct values', (t) => {
   t.true(compareVectors(ret1[1], exp1[1]))
 
   // simple triangle
-  let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
+  let ply2 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [[0, 0, 0], [0, 10, 10]]
   let ret2 = measureBoundingBox(ply2)
   t.true(compareVectors(ret2[0], exp2[0]))
   t.true(compareVectors(ret2[1], exp2[1]))
 
   // simple square
-  let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
+  let ply3 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let exp3 = [[0, 0, 0], [0, 10, 10]]
   let ret3 = measureBoundingBox(ply3)
   t.true(compareVectors(ret3[0], exp3[0]))
   t.true(compareVectors(ret3[1], exp3[1]))
 
   // V-shape
-  const points = [
+  const vertices = [
     [0, 3, 0],
     [0, 5, 0],
     [0, 8, 2],
@@ -39,7 +40,7 @@ test('poly3: measureBoundingBox() should return correct values', (t) => {
     [0, 1, 3],
     [0, 3, 3]
   ]
-  let ply4 = fromPoints(points)
+  let ply4 = create(vertices)
   let exp4 = [[0, 1, 0], [0, 8, 6]]
   let ret4 = measureBoundingBox(ply4)
   t.true(compareVectors(ret4[0], exp4[0]))

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

@@ -1,6 +1,4 @@
-import Poly3 from './type'
-import Vec4 from '../../maths/vec4/type'
+import type { Poly3 } from './type.d.ts'
+import type { Vec4 } from '../../maths/vec4/type.d.ts'
 
-export default measureBoundingSphere
-
-declare function measureBoundingSphere(polygon: Poly3): Vec4
+export function measureBoundingSphere(polygon: Poly3): Vec4

package/src/geometries/poly3/measureBoundingSphere.js

@@ -1,16 +1,15 @@
-const vec3 = require('../../maths/vec3')
-const vec4 = require('../../maths/vec4')
+import * as vec4 from '../../maths/vec4/index.js'
 
 const cache = new WeakMap()
 
 /**
  * Measure the bounding sphere of the given polygon.
- * @param {poly3} polygon - the polygon to measure
- * @returns {vec4} the computed bounding sphere; center point (3D) and radius
+ * @param {Poly3} polygon - the polygon to measure
+ * @returns {Vec4} the computed bounding sphere; center vertex (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
-const measureBoundingSphere = (polygon) => {
-  let boundingSphere = cache.get(polygon)
+export const measureBoundingSphere = (polygon) => {
+  const boundingSphere = cache.get(polygon)
   if (boundingSphere) return boundingSphere
 
   const vertices = polygon.vertices
@@ -53,5 +52,3 @@ const measureBoundingSphere = (polygon) => {
 
   return out
 }
-
-module.exports = measureBoundingSphere

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

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { measureBoundingSphere, create, fromPoints, transform } = require('./index')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
+
+import { measureBoundingSphere, create, transform } from './index.js'
 
 test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let ply1 = create()
@@ -10,19 +11,19 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   t.deepEqual(ret1, exp1)
 
   // simple triangle
-  let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
+  let ply2 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [0, 5, 5, 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
   t.deepEqual(ret2, exp2)
 
   // simple square
-  let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
+  let ply3 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let exp3 = [0, 5, 5, 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
   t.deepEqual(ret3, exp3)
 
   // V-shape
-  const points = [
+  const vertices = [
     [0, 3, 0],
     [0, 5, 0],
     [0, 8, 2],
@@ -34,7 +35,7 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
     [0, 1, 3],
     [0, 3, 3]
   ]
-  let ply4 = fromPoints(points)
+  let ply4 = create(vertices)
   let exp4 = [0, 4.5, 3, 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
   t.deepEqual(ret4, exp4)

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

@@ -1,5 +1,3 @@
-import Poly3 from './type'
+import type { Poly3 } from './type.d.ts'
 
-export default measureSignedVolume
-
-declare function measureSignedVolume(polygon: Poly3): number
+export function measureSignedVolume(polygon: Poly3): number

package/src/geometries/poly3/measureSignedVolume.js

@@ -1,15 +1,15 @@
-const vec3 = require('../../maths/vec3')
+import * as vec3 from '../../maths/vec3/index.js'
 
 /**
  * Measure the signed volume of the given polygon, which must be convex.
  * 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
+ * @param {Poly3} polygon - the polygon to measure
+ * @return {number} volume of the polygon
  * @alias module:modeling/geometries/poly3.measureSignedVolume
  */
-const measureSignedVolume = (polygon) => {
+export const measureSignedVolume = (polygon) => {
   let signedVolume = 0
   const vertices = polygon.vertices
   // calculate based on triangular polygons
@@ -21,5 +21,3 @@ const measureSignedVolume = (polygon) => {
   signedVolume /= 6
   return signedVolume
 }
-
-module.exports = measureSignedVolume

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

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { measureSignedVolume, create, invert, fromPoints, transform } = require('./index')
+import { mat4 } from '../../maths/index.js'
 
-const mat4 = require('../../maths/mat4')
+import { measureSignedVolume, create, invert, transform } from './index.js'
 
-const { nearlyEqual } = require('../../../test/helpers/index')
+import { nearlyEqual } from '../../../test/helpers/index.js'
 
 test('poly3: measureSignedVolume() should return correct values', (t) => {
   let ply1 = create()
@@ -12,17 +12,17 @@ test('poly3: measureSignedVolume() should return correct values', (t) => {
   nearlyEqual(t, ret1, 0.0, Number.EPSILON)
 
   // simple triangle
-  let ply2 = fromPoints([[5, 5, 5], [5, 15, 5], [5, 15, 15]])
+  let ply2 = create([[5, 5, 5], [5, 15, 5], [5, 15, 15]])
   let ret2 = measureSignedVolume(ply2)
   nearlyEqual(t, ret2, 83.33333333333333, Number.EPSILON)
 
   // simple square
-  let ply3 = fromPoints([[5, 5, 5], [5, 15, 5], [5, 15, 15], [5, 5, 15]])
+  let ply3 = create([[5, 5, 5], [5, 15, 5], [5, 15, 15], [5, 5, 15]])
   let ret3 = measureSignedVolume(ply3)
   nearlyEqual(t, ret3, 166.66666666666666, Number.EPSILON)
 
   // V-shape
-  const points = [
+  const vertices = [
     [-50, 3, 0],
     [-50, 5, 0],
     [-50, 8, 2],
@@ -34,7 +34,7 @@ test('poly3: measureSignedVolume() should return correct values', (t) => {
     [-50, 1, 3],
     [-50, 3, 3]
   ]
-  let ply4 = fromPoints(points)
+  let ply4 = create(vertices)
   let ret4 = measureSignedVolume(ply4)
   nearlyEqual(t, ret4, -325.00000, Number.EPSILON)
 

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

@@ -1,6 +1,4 @@
-import Poly3 from './type'
-import Plane from '../../maths/plane/type'
+import type { Plane } from '../../maths/plane/type.d.ts'
+import type { Poly3 } from './type.d.ts'
 
-export default plane
-
-declare function plane(polygon: Poly3): Plane;
+export function plane(polygon: Poly3): Plane;

package/src/geometries/poly3/plane.js

@@ -1,10 +1,8 @@
-const mplane = require('../../maths/plane/')
+import * as mplane from '../../maths/plane/index.js'
 
-const plane = (polygon) => {
+export const plane = (polygon) => {
   if (!polygon.plane) {
     polygon.plane = mplane.fromPoints(mplane.create(), ...polygon.vertices)
   }
   return polygon.plane
 }
-
-module.exports = plane

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

@@ -1,5 +1,3 @@
-import Poly3 from './type'
+import type { Poly3 } from './type.d.ts'
 
-export default toString
-
-declare function toString(polygon: Poly3): string
+export function toString(polygon: Poly3): string

package/src/geometries/poly3/toString.js

@@ -1,17 +1,9 @@
-const vec3 = require('../../maths/vec3/')
+import * as vec3 from '../../maths/vec3/index.js'
 
 /**
- * @param {poly3} polygon - the polygon to measure
+ * Convert the given polygon to a readable string.
+ * @param {Poly3} polygon - the polygon to convert
  * @return {String} the string representation
  * @alias module:modeling/geometries/poly3.toString
  */
-const toString = (polygon) => {
-  let result = 'poly3: vertices: ['
-  polygon.vertices.forEach((vertex) => {
-    result += `${vec3.toString(vertex)}, `
-  })
-  result += ']'
-  return result
-}
-
-module.exports = toString
+export const toString = (polygon) => `poly3: [${polygon.vertices.map(vec3.toString).join(', ')}]`

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

@@ -0,0 +1,10 @@
+import test from 'ava'
+
+import { create, toString } from './index.js'
+
+test('toString: serialize poly3 into a string', (t) => {
+  const geometry = create([[0, 0, 3], [0, 1, 3], [2, 0, 3]])
+  const result = toString(geometry)
+  const expected = 'poly3: [[0.0000000, 0.0000000, 3.0000000], [0.0000000, 1.0000000, 3.0000000], [2.0000000, 0.0000000, 3.0000000]]'
+  t.is(result, expected)
+})

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

@@ -0,0 +1,4 @@
+import type { Poly3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+
+export function toVertices(polygon: Poly3): Array<Vec3>

package/src/geometries/poly3/toVertices.js

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

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

@@ -1,6 +1,4 @@
-import Poly3 from './type'
-import Mat4 from '../../maths/mat4/type'
+import type { Poly3 } from './type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
 
-export default transform
-
-declare function transform(matrix: Mat4, polygon: Poly3): Poly3
+export function transform(matrix: Mat4, polygon: Poly3): Poly3

package/src/geometries/poly3/transform.js

@@ -1,16 +1,16 @@
-const mat4 = require('../../maths/mat4')
-const vec3 = require('../../maths/vec3')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Transform the given polygon using the given matrix.
- * @param {mat4} matrix - the matrix to transform with
- * @param {poly3} polygon - the polygon to transform
- * @returns {poly3} a new polygon
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Poly3} polygon - the polygon to transform
+ * @returns {Poly3} a new polygon
  * @alias module:modeling/geometries/poly3.transform
  */
-const transform = (matrix, polygon) => {
+export 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
@@ -18,5 +18,3 @@ const transform = (matrix, polygon) => {
   }
   return create(vertices)
 }
-
-module.exports = transform

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { transform, fromPoints } = require('./index')
+import { create, transform } from './index.js'
 
-const { comparePolygons } = require('../../../test/helpers/index')
+import { comparePolygons } from '../../../test/helpers/index.js'
 
 test('poly3: transform() should return a new poly3 with correct values', (t) => {
   const identityMatrix = [
@@ -13,7 +13,7 @@ test('poly3: transform() should return a new poly3 with correct values', (t) =>
   ]
 
   const exp1 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
-  const org1 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const org1 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   const ret1 = transform(identityMatrix, org1)
   t.true(comparePolygons(ret1, exp1))
   t.not(org1, ret1)
@@ -29,7 +29,7 @@ test('poly3: transform() should return a new poly3 with correct values', (t) =>
   ]
 
   const exp2 = { vertices: [[1, 5, 7], [2, 5, 7], [2, 6, 7]] }
-  const org2 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const org2 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   const ret2 = transform(translationMatrix, org2)
   t.true(comparePolygons(ret2, exp2))
   t.not(org2, ret2)
@@ -43,7 +43,7 @@ test('poly3: transform() should return a new poly3 with correct values', (t) =>
   ]
 
   const exp3 = { vertices: [[0, 0, 0], [0, -1, 0], [1, -1, 0]] }
-  const org3 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const org3 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   const ret3 = transform(rotateZMatrix, org3)
   t.true(comparePolygons(ret3, exp3))
   t.not(org3, ret3)
@@ -55,7 +55,7 @@ test('poly3: transform() should return a new poly3 with correct values', (t) =>
     0, 0, 0, 1
   ]
   const exp4 = { vertices: [[-1, 1, 0], [-1, 0, 0], [0, 0, 0]] }
-  const org4 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const org4 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   const ret4 = transform(mirrorMatrix, org4)
   t.true(comparePolygons(ret4, exp4))
   t.not(org4, ret4)

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

@@ -1,9 +1,11 @@
-import Vec3 from '../../maths/vec3/type'
-import { Color } from '../types'
+import type { Plane } from '../../maths/plane/type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Color } from '../types.d.ts'
 
-export default Poly3
-
-declare interface Poly3 {
+export interface Poly3 {
   vertices: Array<Vec3>
   color?: Color
+
+  // used internally for caching:
+  plane?: Plane
 }

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

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

package/src/geometries/poly3/validate.js

@@ -1,22 +1,23 @@
-const signedDistanceToPoint = require('../../maths/plane/signedDistanceToPoint')
-const { NEPS } = require('../../maths/constants')
-const vec3 = require('../../maths/vec3')
-const isA = require('./isA')
-const isConvex = require('./isConvex')
-const measureArea = require('./measureArea')
-const plane = require('./plane')
+import { signedDistanceToPoint } from '../../maths/plane/index.js'
+import { NEPS } from '../../maths/constants.js'
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { isA } from './isA.js'
+import { isConvex } from './isConvex.js'
+import { measureArea } from './measureArea.js'
+import { plane } from './plane.js'
 
 /**
  * Determine if the given object is a valid polygon.
- * Checks for valid data structure, convex polygons, and duplicate points.
+ * Checks for valid data structure, convex polygons, and duplicate vertices.
  *
  * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
  *
- * @param {Object} object - the object to interrogate
+ * @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) => {
+export const validate = (object) => {
   if (!isA(object)) {
     throw new Error('invalid poly3 structure')
   }
@@ -30,10 +31,10 @@ const validate = (object) => {
     throw new Error('poly3 area must be greater than zero')
   }
 
-  // check for duplicate points
+  // check for duplicate vertices
   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]}`)
+      throw new Error(`poly3 has duplicate vertex ${object.vertices[i]}`)
     }
   }
 
@@ -49,7 +50,7 @@ const validate = (object) => {
     }
   })
 
-  // check that points are co-planar
+  // check that vertices are co-planar
   if (object.vertices.length > 3) {
     const normal = plane(object)
     object.vertices.forEach((vertex) => {
@@ -60,5 +61,3 @@ const validate = (object) => {
     })
   }
 }
-
-module.exports = validate

package/src/geometries/slice/calculatePlane.d.ts

@@ -0,0 +1,5 @@
+import type { Plane } from '../../maths/plane/type.d.ts'
+
+import type { Slice } from './type.d.ts'
+
+export function calculatePlane(slice: Slice): Plane