@jscad/modeling 3.0.0-alpha.0 → 3.0.2-alpha.0

package/src/operations/transforms/center.js

@@ -1,10 +1,8 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
 
-import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
+import { measureAggregateBoundingBox } from '../../measurements/measureAggregateBoundingBox.js'
 
 import { translate } from './translate.js'
 
@@ -15,7 +13,7 @@ const centerGeometry = (options, object) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  const bounds = measureBoundingBox(object)
+  const bounds = measureAggregateBoundingBox(object)
   const offset = [0, 0, 0]
   if (axes[0]) offset[0] = relativeTo[0] - (bounds[0][0] + ((bounds[1][0] - bounds[0][0]) / 2))
   if (axes[1]) offset[1] = relativeTo[1] - (bounds[0][1] + ((bounds[1][1] - bounds[0][1]) / 2))
@@ -43,8 +41,6 @@ export const center = (options, ...objects) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  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 }
@@ -53,6 +49,7 @@ export const center = (options, ...objects) => {
     if (path2.isA(object)) return centerGeometry(options, object)
     if (geom2.isA(object)) return centerGeometry(options, object)
     if (geom3.isA(object)) return centerGeometry(options, object)
+    if (Array.isArray(object)) return centerGeometry(options, object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -64,7 +61,7 @@ export const center = (options, ...objects) => {
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerX
  */
-export const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
+export const centerX = (...objects) => center({ axes: [true, false, false] }, ...objects)
 
 /**
  * Center the given objects about the Y axis.
@@ -72,7 +69,7 @@ export const centerX = (...objects) => center({ axes: [true, false, false] }, ob
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerY
  */
-export const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
+export const centerY = (...objects) => center({ axes: [false, true, false] }, ...objects)
 
 /**
  * Center the given objects about the Z axis.
@@ -80,4 +77,4 @@ export const centerY = (...objects) => center({ axes: [false, true, false] }, ob
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerZ
  */
-export const centerZ = (...objects) => center({ axes: [false, false, true] }, objects)
+export const centerZ = (...objects) => center({ axes: [false, false, true] }, ...objects)

package/src/operations/transforms/center.test.js

@@ -4,7 +4,9 @@ import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/in
 
 import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-import { measureArea, measureVolume } from '../../measurements/index.js'
+import { measureArea, measureAggregateBoundingBox, measureVolume } from '../../measurements/index.js'
+
+import { square } from '../../primitives/index.js'
 
 import { center, centerX, centerY, centerZ } from './index.js'
 
@@ -136,3 +138,19 @@ test('center: centering of multiple objects produces expected changes', (t) => {
   t.notThrows(() => geom2.validate(centered[2]))
   t.true(comparePoints(pts2, exp2))
 })
+
+test('center multiple separate', (t) => {
+  const square1 = square({ size: 4, center: [10, 10] })
+  const square2 = square({ size: 6, center: [-10, -10] })
+  const obs = center({}, square1, square2)
+  t.notThrows(() => obs.map(geom2.validate))
+  t.deepEqual([[-3, -3, 0], [3, 3, 0]], measureAggregateBoundingBox(obs))
+})
+
+test('center multiple grouped', (t) => {
+  const square1 = square({ size: 4, center: [10, 10] })
+  const square2 = square({ size: 6, center: [-10, -10] })
+  const obs = center({}, [square1, square2])
+  t.notThrows(() => obs.map(geom2.validate))
+  t.deepEqual([[-12.5, -12.5, 0], [12.5, 12.5, 0]], measureAggregateBoundingBox(obs))
+})

package/src/operations/transforms/mirror.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 import * as plane from '../../maths/plane/index.js'
 
@@ -26,9 +24,6 @@ export const mirror = (options, ...objects) => {
   }
   const { origin, normal } = Object.assign({}, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const planeOfMirror = plane.fromNormalAndPoint(plane.create(), normal, origin)
   // verify the plane, i.e. check that the given normal was valid
   if (Number.isNaN(planeOfMirror[0])) {
@@ -41,6 +36,8 @@ export const mirror = (options, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return mirror(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -52,7 +49,7 @@ export const mirror = (options, ...objects) => {
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorX
  */
-export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
+export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, ...objects)
 
 /**
  * Mirror the given objects about the Y axis.
@@ -60,7 +57,7 @@ export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorY
  */
-export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
+export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, ...objects)
 
 /**
  * Mirror the given objects about the Z axis.
@@ -68,4 +65,4 @@ export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorZ
  */
-export const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, objects)
+export const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, ...objects)

package/src/operations/transforms/mirror.test.js

@@ -42,29 +42,29 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
-  let exp = [[5, -5], [0, 5], [-10, -5]]
+  let exp = [[-10, -5], [0, 5], [5, -5]]
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = geom2.toPoints(mirrored)
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[10, 5], [0, -5], [-5, 5]]
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -158,7 +158,7 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[10, 5], [0, -5], [-5, 5]]
   t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/operations/transforms/rotate.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -19,9 +17,6 @@ import * as path2 from '../../geometries/path2/index.js'
 export const rotate = (angles, ...objects) => {
   if (!Array.isArray(angles)) throw new Error('angles must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the angles if necessary
   angles = angles.slice() // don't modify the original
   while (angles.length < 3) angles.push(0)
@@ -36,6 +31,8 @@ export const rotate = (angles, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return rotate(angles, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -48,7 +45,7 @@ export const rotate = (angles, ...objects) => {
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateX
  */
-export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
+export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], ...objects)
 
 /**
  * Rotate the given objects about the Y axis, using the given options.
@@ -57,7 +54,7 @@ export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateY
  */
-export const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
+export const rotateY = (angle, ...objects) => rotate([0, angle, 0], ...objects)
 
 /**
  * Rotate the given objects about the Z axis, using the given options.
@@ -66,4 +63,4 @@ export const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateZ
  */
-export const rotateZ = (angle, ...objects) => rotate([0, 0, angle], objects)
+export const rotateZ = (angle, ...objects) => rotate([0, 0, angle], ...objects)

package/src/operations/transforms/scale.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -19,9 +17,6 @@ import * as path2 from '../../geometries/path2/index.js'
 export const scale = (factors, ...objects) => {
   if (!Array.isArray(factors)) throw new Error('factors must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the factors if necessary
   factors = factors.slice() // don't modify the original
   while (factors.length < 3) factors.push(1)
@@ -34,6 +29,8 @@ export const scale = (factors, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return scale(factors, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -46,7 +43,7 @@ export const scale = (factors, ...objects) => {
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleX
  */
-export const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
+export const scaleX = (factor, ...objects) => scale([factor, 1, 1], ...objects)
 
 /**
  * Scale the given objects about the Y axis using the given options.
@@ -55,7 +52,7 @@ export const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleY
  */
-export const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
+export const scaleY = (factor, ...objects) => scale([1, factor, 1], ...objects)
 
 /**
  * Scale the given objects about the Z axis using the given options.
@@ -64,4 +61,4 @@ export const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleZ
  */
-export const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)
+export const scaleZ = (factor, ...objects) => scale([1, 1, factor], ...objects)

package/src/operations/transforms/transform.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
@@ -17,13 +15,12 @@ import * as path2 from '../../geometries/path2/index.js'
 export const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return transform(matrix, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/transforms/translate.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -19,9 +17,6 @@ import * as path2 from '../../geometries/path2/index.js'
 export const translate = (offset, ...objects) => {
   if (!Array.isArray(offset)) throw new Error('offset must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the offset if necessary
   offset = offset.slice() // don't modify the original
   while (offset.length < 3) offset.push(0)
@@ -32,6 +27,8 @@ export const translate = (offset, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return translate(offset, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -44,7 +41,7 @@ export const translate = (offset, ...objects) => {
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateX
  */
-export const translateX = (offset, ...objects) => translate([offset, 0, 0], objects)
+export const translateX = (offset, ...objects) => translate([offset, 0, 0], ...objects)
 
 /**
  * Translate the given objects along the Y axis using the given options.
@@ -53,7 +50,7 @@ export const translateX = (offset, ...objects) => translate([offset, 0, 0], obje
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateY
  */
-export const translateY = (offset, ...objects) => translate([0, offset, 0], objects)
+export const translateY = (offset, ...objects) => translate([0, offset, 0], ...objects)
 
 /**
  * Translate the given objects along the Z axis using the given options.
@@ -62,4 +59,4 @@ export const translateY = (offset, ...objects) => translate([0, offset, 0], obje
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateZ
  */
-export const translateZ = (offset, ...objects) => translate([0, 0, offset], objects)
+export const translateZ = (offset, ...objects) => translate([0, 0, offset], ...objects)

package/src/primitives/arc.js

@@ -17,6 +17,8 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
  * @param {boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
  * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.arc
+ * @example
+ * let myshape = arc({ center: [-1, -1], radius: 2, endAngle: (TAU / 4)})
  */
 export const arc = (options) => {
   const defaults = {

package/src/primitives/arc.test.js

@@ -13,7 +13,7 @@ test('arc (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 33)
+  t.is(obs.length, 33)
 })
 
 test('arc (options)', (t) => {
@@ -41,7 +41,7 @@ test('arc (options)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
   // test radius
@@ -68,7 +68,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
   // test startAngle
@@ -92,7 +92,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 14)
+  t.is(obs.length, 14)
   t.true(comparePoints(obs, exp))
 
   // test endAngle
@@ -108,7 +108,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   // test makeTangent
@@ -137,7 +137,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 19)
+  t.is(obs.length, 19)
   t.true(comparePoints(obs, exp))
 
   // test segments
@@ -156,7 +156,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 9)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 })
 
@@ -173,7 +173,7 @@ test('arc (rotations)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   exp = [
@@ -192,7 +192,7 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
   exp = [
@@ -211,7 +211,7 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
   exp = [[-1.8369701987210297e-16, -1]]
@@ -219,6 +219,6 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 1)
+  t.is(obs.length, 1)
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/circle.test.js

@@ -1,8 +1,10 @@
 import test from 'ava'
 
+import { geom2 } from '../geometries/index.js'
+
 import { TAU } from '../maths/constants.js'
 
-import { geom2 } from '../geometries/index.js'
+import { measureArea } from '../measurements/measureArea.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
 
@@ -13,7 +15,8 @@ test('circle (defaults)', (t) => {
   const pts = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 32)
+  t.is(measureArea(geometry), 3.1214451522580537)
+  t.is(pts.length, 32)
 })
 
 test('circle (options)', (t) => {
@@ -56,7 +59,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 32)
+  t.is(measureArea(geometry), 38.23770311516116)
+  t.is(pts.length, 32)
   t.true(comparePoints(pts, exp))
 
   // test radius
@@ -82,7 +86,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 37.5029763717788)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test startAngle
@@ -106,7 +111,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 14)
+  t.is(measureArea(geometry), 28.127232278834093)
+  t.is(pts.length, 14)
   t.true(comparePoints(pts, exp))
 
   // test endAngle
@@ -122,7 +128,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 6)
+  t.is(measureArea(geometry), 9.3757440929447)
+  t.is(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
   // test full rotation with non-zero startAngle
@@ -130,7 +137,8 @@ test('circle (options)', (t) => {
   pts = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 32)
+  t.is(measureArea(geometry), 3.1214451522580537)
+  t.is(pts.length, 32)
 
   // test segments
   geometry = circle({ radius: 3.5, segments: 5 })
@@ -144,7 +152,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 5)
+  t.is(measureArea(geometry), 29.126105811539073)
+  t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })
 
@@ -152,5 +161,6 @@ test('circle (radius zero)', (t) => {
   const geometry = circle({ radius: 0 })
   const pts = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 0)
   t.is(pts.length, 0)
 })

package/src/primitives/cube.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { cube } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -10,6 +12,8 @@ test('cube (defaults)', (t) => {
   const obs = cube()
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
   t.is(pts.length, 6)
 })
 
@@ -27,6 +31,8 @@ test('cube (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 294)
+  t.is(measureVolume(obs), 343)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -43,6 +49,8 @@ test('cube (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 294)
+  t.is(measureVolume(obs), 343)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -51,5 +59,7 @@ test('cube (zero size)', (t) => {
   const obs = cube({ size: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })

package/src/primitives/cuboid.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { cuboid } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -18,6 +20,8 @@ test('cuboid (defaults)', (t) => {
     [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -36,6 +40,8 @@ test('cuboid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 216)
+  t.is(measureVolume(obs), 216)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -52,6 +58,8 @@ test('cuboid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 97.5)
+  t.is(measureVolume(obs), 47.25)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -60,5 +68,7 @@ test('cuboid (zero size)', (t) => {
   const obs = cuboid({ size: [1, 1, 0] })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })