@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/geometries/poly2/validate.test.js

@@ -0,0 +1,31 @@
+import test from 'ava'
+
+import { validate, create } from './index.js'
+
+test('validate: identifies polygons', (t) => {
+  const ply1 = create()
+  t.throws(() => validate(ply1), { message: 'poly2 not enough points 0' })
+
+  const ply2 = create([[0, 0], [1, 0], [1, 1]])
+  t.notThrows(() => validate(ply2))
+
+  // Clockwise
+  const ply3 = create([[5, 5], [5, -5], [-5, -5], [-5, 5]])
+  t.throws(() => validate(ply3), { message: 'poly2 area must be greater than zero' })
+
+  // Counterclockwise
+  const ply4 = create([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  t.notThrows(() => validate(ply4))
+
+  // CCW With V-side
+  const ply5 = create([[5, 5], [-5, 5], [0, 0], [-5, -5], [5, -5]])
+  t.notThrows(() => validate(ply5))
+
+  // STAR
+  const ply6 = create([[0, 0], [5, 5], [5, -5], [0, 0], [-5, -5], [-5, 5]])
+  t.throws(() => validate(ply6), { message: 'poly2 area must be greater than zero' })
+
+  // Counterclockwise with duplicate points
+  const ply7 = create([[5, 5], [-5, 5], [-5, 5], [-5, -5], [5, -5]])
+  t.throws(() => validate(ply7), { message: 'poly2 duplicate point at 1: [-5,5]' })
+})

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

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

package/src/geometries/poly3/clone.js

@@ -1,16 +1,16 @@
-const create = require('./create')
+import * as vec3 from '../../maths/vec3/index.js'
 
-const vec3 = require('../../maths/vec3')
+import { create } from './create.js'
 
 /**
  * Create a deep clone of the given polygon
  *
- * @param {poly3} [out] - receiving polygon
- * @param {poly3} polygon - polygon to clone
- * @returns {poly3} a new polygon
+ * @param {Poly3} [out] - receiving polygon
+ * @param {Poly3} polygon - polygon to clone
+ * @returns {Poly3} a new polygon
  * @alias module:modeling/geometries/poly3.clone
  */
-const clone = (...params) => {
+export const clone = (...params) => {
   let out
   let poly3
   if (params.length === 1) {
@@ -24,5 +24,3 @@ const clone = (...params) => {
   out.vertices = poly3.vertices.map((vec) => vec3.clone(vec))
   return out
 }
-
-module.exports = clone

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

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { create, clone, fromPoints } = require('./index')
+import test from 'ava'
 
-const { comparePolygons } = require('../../../test/helpers/index')
+import { create, clone } from './index.js'
+
+import { comparePolygons } from '../../../test/helpers/index.js'
 
 test('poly3: clone() should return a new poly3 with same values', (t) => {
   const org1 = create()
@@ -9,7 +10,7 @@ test('poly3: clone() should return a new poly3 with same values', (t) => {
   t.true(comparePolygons(ret1, org1))
   t.not(ret1, org1)
 
-  const org2 = fromPoints([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
+  const org2 = create([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
   const ret2 = clone(org2)
   t.true(comparePolygons(ret2, org2))
   t.not(ret2, org2)
@@ -25,7 +26,7 @@ test('poly3: clone() with two params should update a poly3 with same values', (t
   t.not(ret1, org1)
   t.is(ret1, out1)
 
-  const org2 = fromPoints([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
+  const org2 = create([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
   const out2 = create()
   const ret2 = clone(out2, org2)
   t.true(comparePolygons(ret2, org2))

package/src/geometries/poly3/create.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 create
-
-declare function create(vertices?: Array<Vec3>): Poly3
+export function create(vertices?: Array<Vec3>): Poly3

package/src/geometries/poly3/create.js

@@ -1,24 +1,24 @@
-
 /**
  * Represents a convex 3D polygon. The vertices used to initialize a polygon must
  * be coplanar and form a convex shape. The vertices do not have to be `vec3`
  * instances but they must behave similarly.
- * @typedef {Object} poly3
  * @property {Array} vertices - list of ordered vertices (3D)
+ * @example
+ * {"vertices": [[0,0,0], [4,0,0], [4,3,12]]}
  */
 
 /**
  * Creates a new 3D polygon with initial values.
  *
  * @param {Array} [vertices] - a list of vertices (3D)
- * @returns {poly3} a new polygon
+ * @returns {Poly3} a new polygon
  * @alias module:modeling/geometries/poly3.create
+ * @example
+ * const polygon = create([[1, 0], [0, 1], [0, 0]])
  */
-const create = (vertices) => {
+export const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
   return { vertices }
 }
-
-module.exports = create

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

@@ -1,9 +1,21 @@
-const test = require('ava')
+import test from 'ava'
 
-const { create } = require('./index')
+import { create } from './index.js'
 
-test('poly3: create() should return a poly3 with initial values', (t) => {
+import { comparePolygons } from '../../../test/helpers/index.js'
+
+test('poly3: create() should return an empty poly3', (t) => {
   const obs = create()
   const exp = { vertices: [] }
   t.deepEqual(obs, exp)
 })
+
+test('poly3: create() should return a new poly3 with correct values', (t) => {
+  const exp1 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
+  const obs1 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  t.true(comparePolygons(obs1, exp1))
+
+  const exp2 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 0]] }
+  const obs2 = create([[1, 1, 0], [1, 0, 0], [0, 0, 0]]) // opposite orientation
+  t.true(comparePolygons(obs2, exp2))
+})

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

@@ -0,0 +1,5 @@
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Plane } from '../../maths/plane/type.d.ts'
+import type { Poly3 } from './type.d.ts'
+
+export function fromVerticesAndPlane(vertices: Array<Vec3>, plane: Plane): Poly3

package/src/geometries/poly3/{fromPointsAndPlane.js → fromVerticesAndPlane.js}

@@ -1,17 +1,15 @@
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Create a polygon from the given vertices and plane.
  * NOTE: No checks are performed on the parameters.
  * @param {Array} vertices - list of vertices (3D)
- * @param {plane} plane - plane of the polygon
- * @returns {poly3} a new polygon
- * @alias module:modeling/geometries/poly3.fromPointsAndPlane
+ * @param {Plane} plane - plane of the polygon
+ * @returns {Poly3} a new polygon
+ * @alias module:modeling/geometries/poly3.fromVerticesAndPlane
  */
-const fromPointsAndPlane = (vertices, plane) => {
+export const fromVerticesAndPlane = (vertices, plane) => {
   const poly = create(vertices)
   poly.plane = plane // retain the plane for later use
   return poly
 }
-
-module.exports = fromPointsAndPlane

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

@@ -1,19 +1,17 @@
-export { default as clone } from './clone'
-export { default as create } from './create'
-export { default as fromPoints } from './fromPoints'
-export { default as fromPointsAndPlane } from './fromPointsAndPlane'
-export { default as invert } from './invert'
-export { default as isA } from './isA'
-export { default as isConvex } from './isConvex'
-export { default as measureArea } from './measureArea'
-export { default as measureBoundingBox } from './measureBoundingBox'
-export { default as measureBoundingSphere } from './measureBoundingSphere'
-export { default as measureSignedVolume } from './measureSignedVolume'
-export { default as plane } from './plane'
-export { default as toPoints } from './toPoints'
-export { default as toString } from './toString'
-export { default as transform } from './transform'
-export { default as validate } from './validate'
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromVerticesAndPlane } from './fromVerticesAndPlane.js'
+export { invert } from './invert.js'
+export { isA } from './isA.js'
+export { isConvex } from './isConvex.js'
+export { measureArea } from './measureArea.js'
+export { measureBoundingBox } from './measureBoundingBox.js'
+export { measureBoundingSphere } from './measureBoundingSphere.js'
+export { measureSignedVolume } from './measureSignedVolume.js'
+export { plane } from './plane.js'
+export { toVertices } from './toVertices.js'
+export { toString } from './toString.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
 
-export { default as Poly3 } from './type'
-export as namespace poly3
+export type { Poly3 } from './type.d.ts'

package/src/geometries/poly3/index.js

@@ -4,26 +4,21 @@
  * @module modeling/geometries/poly3
  *
  * @example
- * poly3.create([[0,0,0], [4,0,0], [4,3,12]])
- *
- * @example
- * {"vertices": [[0,0,0], [4,0,0], [4,3,12]]}
+ * import { geometries } from '@jscad/modeling'
+ * const polygon = geometries.poly3.create([[0,0,0], [4,0,0], [4,3,12]])
  */
-module.exports = {
-  clone: require('./clone'),
-  create: require('./create'),
-  fromPoints: require('./fromPoints'),
-  fromPointsAndPlane: require('./fromPointsAndPlane'),
-  invert: require('./invert'),
-  isA: require('./isA'),
-  isConvex: require('./isConvex'),
-  measureArea: require('./measureArea'),
-  measureBoundingBox: require('./measureBoundingBox'),
-  measureBoundingSphere: require('./measureBoundingSphere'),
-  measureSignedVolume: require('./measureSignedVolume'),
-  plane: require('./plane'),
-  toPoints: require('./toPoints'),
-  toString: require('./toString'),
-  transform: require('./transform'),
-  validate: require('./validate')
-}
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromVerticesAndPlane } from './fromVerticesAndPlane.js'
+export { invert } from './invert.js'
+export { isA } from './isA.js'
+export { isConvex } from './isConvex.js'
+export { measureArea } from './measureArea.js'
+export { measureBoundingBox } from './measureBoundingBox.js'
+export { measureBoundingSphere } from './measureBoundingSphere.js'
+export { measureSignedVolume } from './measureSignedVolume.js'
+export { plane } from './plane.js'
+export { toVertices } from './toVertices.js'
+export { toString } from './toString.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

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

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

package/src/geometries/poly3/invert.js

@@ -1,14 +1,15 @@
-const plane = require('../../maths/plane')
-const create = require('./create')
+import * as plane from '../../maths/plane/index.js'
+
+import { create } from './create.js'
 
 /**
  * Invert the give polygon to face the opposite direction.
  *
- * @param {poly3} polygon - the polygon to invert
- * @returns {poly3} a new poly3
+ * @param {Poly3} polygon - the polygon to invert
+ * @returns {Poly3} a new poly3
  * @alias module:modeling/geometries/poly3.invert
  */
-const invert = (polygon) => {
+export const invert = (polygon) => {
   const vertices = polygon.vertices.slice().reverse()
   const inverted = create(vertices)
   if (polygon.plane) {
@@ -17,5 +18,3 @@ const invert = (polygon) => {
   }
   return inverted
 }
-
-module.exports = invert

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

@@ -1,17 +1,17 @@
-const test = require('ava')
+import test from 'ava'
 
-const { invert, fromPoints } = require('./index')
+import { create, invert } from './index.js'
 
-const { comparePolygons } = require('../../../test/helpers/index')
+import { comparePolygons } from '../../../test/helpers/index.js'
 
 test('poly3: invert() should return a new poly3 with correct values', (t) => {
   const exp1 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 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 = invert(org1)
   t.true(comparePolygons(ret1, exp1))
 
   const exp2 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
-  const org2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
+  const org2 = create([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
   const ret2 = invert(org2)
   t.true(comparePolygons(ret2, exp2))
   t.false(comparePolygons(ret2, org2)) // the original should NOT change

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

@@ -1,5 +1,3 @@
-import Poly3 from './type'
+import type { Poly3 } from './type.d.ts'
 
-export default isA
-
-declare function isA(object: any): object is Poly3
+export function isA(object: any): object is Poly3

package/src/geometries/poly3/isA.js

@@ -1,10 +1,10 @@
 /**
  * Determine if the given object is a polygon.
- * @param {Object} object - the object to interrogate
+ * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a poly3
  * @alias module:modeling/geometries/poly3.isA
  */
-const isA = (object) => {
+export const isA = (object) => {
   if (object && typeof object === 'object') {
     if ('vertices' in object) {
       if (Array.isArray(object.vertices)) {
@@ -14,5 +14,3 @@ const isA = (object) => {
   }
   return false
 }
-
-module.exports = isA

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

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isA, create, fromPoints } = require('./index')
+import { isA, create } from './index.js'
 
 test('isA: identifies created poly3', (t) => {
   const p1 = create()
-  const p2 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const p2 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   t.true(isA(p1))
   t.true(isA(p2))
 })

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

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

package/src/geometries/poly3/isConvex.js

@@ -1,44 +1,42 @@
-const plane = require('../../maths/plane')
-const vec3 = require('../../maths/vec3')
+import * as plane from '../../maths/plane/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
 /**
  * Check whether the given polygon is convex.
- * @param {poly3} polygon - the polygon to interrogate
+ * @param {Poly3} polygon - the polygon to interrogate
  * @returns {Boolean} true if convex
  * @alias module:modeling/geometries/poly3.isConvex
  */
-const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
+export const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
 
 const areVerticesConvex = (vertices) => {
-  const numvertices = vertices.length
-  if (numvertices > 2) {
-    // note: plane ~= normal point
+  const numVertices = vertices.length
+  if (numVertices > 2) {
+    // note: plane ~= normal vertex
     const normal = plane.fromPoints(plane.create(), ...vertices)
-    let prevprevpos = vertices[numvertices - 2]
-    let prevpos = vertices[numvertices - 1]
-    for (let i = 0; i < numvertices; i++) {
+    let prevPrevPos = vertices[numVertices - 2]
+    let prevPos = vertices[numVertices - 1]
+    for (let i = 0; i < numVertices; i++) {
       const pos = vertices[i]
-      if (!isConvexPoint(prevprevpos, prevpos, pos, normal)) {
+      if (!isConvexVertex(prevPrevPos, prevPos, pos, normal)) {
         return false
       }
-      prevprevpos = prevpos
-      prevpos = pos
+      prevPrevPos = prevPos
+      prevPos = pos
     }
   }
   return true
 }
 
-// calculate whether three points form a convex corner
-//  prevpoint, point, nextpoint: the 3 coordinates (Vector3D instances)
+// calculate whether three vertices form a convex corner
+//  prevVertex, vertex, nextVertex: the 3 coordinates (Vector3D instances)
 //  normal: the normal vector of the plane
-const isConvexPoint = (prevpoint, point, nextpoint, normal) => {
-  const crossproduct = vec3.cross(
+const isConvexVertex = (prevVertex, vertex, nextVertex, normal) => {
+  const crossProduct = vec3.cross(
     vec3.create(),
-    vec3.subtract(vec3.create(), point, prevpoint),
-    vec3.subtract(vec3.create(), nextpoint, point)
+    vec3.subtract(vec3.create(), vertex, prevVertex),
+    vec3.subtract(vec3.create(), nextVertex, vertex)
   )
-  const crossdotnormal = vec3.dot(crossproduct, normal)
-  return crossdotnormal >= 0
+  const crossDotNormal = vec3.dot(crossProduct, normal)
+  return crossDotNormal >= 0
 }
-
-module.exports = isConvex

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

@@ -1,24 +1,24 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isConvex, create, fromPoints } = require('./index')
+import { create, isConvex } from './index.js'
 
 test('poly3: isConvex() should return correct values', (t) => {
   const ply1 = create()
   t.true(isConvex(ply1))
 
-  const ply2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
+  const ply2 = create([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
   t.true(isConvex(ply2))
 
-  const points2ccw = [[0, 0, 3], [10, 10, 3], [0, 5, 3]]
-  const ply3 = fromPoints(points2ccw)
+  const vertices2ccw = [[0, 0, 3], [10, 10, 3], [0, 5, 3]]
+  const ply3 = create(vertices2ccw)
   t.true(isConvex(ply3))
 
-  const points2cw = [[0, 0, 3], [-10, 10, 3], [0, 5, 3]]
-  const ply4 = fromPoints(points2cw)
+  const vertices2cw = [[0, 0, 3], [-10, 10, 3], [0, 5, 3]]
+  const ply4 = create(vertices2cw)
   t.true(isConvex(ply4))
 
   // V-shape
-  const pointsV = [[0, 0, 3], [-10, 10, 3], [0, 5, 3], [10, 10, 3]]
-  const ply5 = fromPoints(pointsV)
+  const verticesV = [[0, 0, 3], [-10, 10, 3], [0, 5, 3], [10, 10, 3]]
+  const ply5 = create(verticesV)
   t.false(isConvex(ply5))
 })

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

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

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