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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.2-alpha.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -64,5 +64,5 @@
     "rollup": "^2.79.1",
     "rollup-plugin-banner": "^0.2.1"
   },
-  "gitHead": "3656d36ed9cd738ab884e86aae5a2ce08d52adf7"
+  "gitHead": "ac80d1a7cb0a8efb21aff9193d4a8bccb6e31f1c"
 }

package/rollup.config.js

@@ -16,6 +16,6 @@ export default {
   ],
   plugins: [
     banner('<%= pkg.description %>\n@module <%= pkg.name %>\n@version <%= pkg.version %>\n@license <%= pkg.license %>'),
-    terser({ compress: { module: true }, mangle: false, format: { comments: 'some'} })
+    terser({ compress: { module: true }, mangle: false, format: { comments: 'some' } })
   ]
 }

package/src/colors/colorize.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'
@@ -47,14 +45,12 @@ export const colorize = (color, ...objects) => {
   if (color.length < 3) throw new Error('color must contain R, G and B values')
   if (color.length === 3) color = [color[0], color[1], color[2], 1.0] // add alpha
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     if (geom2.isA(object)) return colorGeom2(color, object)
     if (geom3.isA(object)) return colorGeom3(color, object)
     if (path2.isA(object)) return colorPath2(color, object)
     if (poly3.isA(object)) return colorPoly3(color, object)
+    if (Array.isArray(object)) return colorize(color, ...object)
 
     object.color = color
     return object

package/src/colors/colorize.test.js

@@ -11,14 +11,12 @@ test('color (rgb on objects)', (t) => {
   const obs = colorize([1, 0, 0], obj1, obj2)
   const exp1 = { color: [1, 0, 0, 1] }
   const exp2 = { id: 'a', color: [1, 0, 0, 1] }
+  const exp3 = { id: 'b', color: [1, 0, 0, 1] }
 
-  t.is(obs.length, 3)
+  t.is(obs.length, 2)
   t.deepEqual(obs[0], exp1)
-  t.deepEqual(obs[1], exp2)
-
-  const obs3 = colorize([1, 0, 0], obj1)
-  const exp3 = { color: [1, 0, 0, 1] }
-  t.deepEqual(obs3, exp3)
+  t.deepEqual(obs[1][0], exp2)
+  t.deepEqual(obs[1][1], exp3)
 })
 
 test('color (rgba on objects)', (t) => {
@@ -28,10 +26,12 @@ test('color (rgba on objects)', (t) => {
   const obs = colorize([1, 1, 0.5, 0.8], obj1, obj2)
   const exp1 = { color: [1, 1, 0.5, 0.8] }
   const exp2 = { id: 'a', color: [1, 1, 0.5, 0.8] }
+  const exp3 = { id: 'b', color: [1, 1, 0.5, 0.8] }
 
-  t.is(obs.length, 3)
+  t.is(obs.length, 2)
   t.deepEqual(obs[0], exp1)
-  t.deepEqual(obs[1], exp2)
+  t.deepEqual(obs[1][0], exp2)
+  t.deepEqual(obs[1][1], exp3)
 })
 
 test('color (rgba on geometry)', (t) => {

package/src/geometries/geom2/transform.js

@@ -1,5 +1,7 @@
 import * as mat4 from '../../maths/mat4/index.js'
 
+import { reverse } from './reverse.js'
+
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the outlines, as this function only adjusts the transforms.
@@ -14,5 +16,11 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
-  return Object.assign({}, geometry, { transforms })
+  const transformed = Object.assign({}, geometry, { transforms })
+  // determine if the transform is mirroring in 2D
+  if (matrix[0] * matrix[5] - matrix[4] * matrix[1] < 0) {
+    // reverse the order to preserve the orientation
+    return reverse(transformed)
+  }
+  return transformed
 }

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

@@ -2,6 +2,12 @@ import test from 'ava'
 
 import { mat4 } from '../../maths/index.js'
 
+import { measureArea } from '../../measurements/index.js'
+
+import { mirrorX, mirrorY, mirrorZ } from '../../operations/transforms/index.js'
+
+import { square } from '../../primitives/index.js'
+
 import { create, transform, toOutlines, toSides } from './index.js'
 
 import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
@@ -50,3 +56,54 @@ test('transform: adjusts the transforms of geom2', (t) => {
   t.true(comparePoints(another.outlines[0], expected.outlines[0]))
   t.true(compareVectors(another.transforms, expected.transforms))
 })
+
+test('transform: geom2 mirrorX', (t) => {
+  const geometry = square()
+  const transformed = mirrorX(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[1, 1], [-1, 1], [-1, -1], [1, -1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]],
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]]
+  ])
+})
+
+test('transform: geom2 mirrorY', (t) => {
+  const geometry = square()
+  const transformed = mirrorY(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]]
+  ])
+})
+
+test('transform: geom2 mirrorZ', (t) => {
+  const geometry = square()
+  const transformed = mirrorZ(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we DIDN'T reverse the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]]
+  ])
+})

package/src/geometries/geom3/fromPointsConvex.d.ts

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

package/src/geometries/geom3/fromPointsConvex.js

@@ -0,0 +1,25 @@
+import { runner } from '../../operations/hulls/quickhull/index.js'
+import { create } from './create.js'
+import * as poly3 from '../poly3/index.js'
+
+/**
+ * Construct a new convex 3D geometry from a list of unique points.
+ *
+ * @param {Array} uniquePoints - list of points to construct convex 3D geometry
+ * @returns {geom3} a new geometry
+ * @alias module:modeling/geometries/geom3.fromPointsConvex
+ */
+export const fromPointsConvex = (uniquePoints) => {
+  if (!Array.isArray(uniquePoints)) {
+    throw new Error('the given points must be an array')
+  }
+
+  const faces = runner(uniquePoints, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniquePoints[index])
+    return poly3.create(vertices)
+  })
+
+  return create(polygons)
+}

package/src/geometries/geom3/fromPointsConvex.test.js

@@ -0,0 +1,32 @@
+import test from 'ava'
+
+import { fromPointsConvex, validate } from './index.js'
+
+test('fromPointsConvex (uniquePoints)', (t) => {
+  const out = []
+  for (let x = -9; x <= 9; ++x) {
+    for (let y = -9; y <= 9; ++y) {
+      for (let z = -9; z <= 9; ++z) {
+        if (x * x + y * y + z * z <= 96) {
+          out.push([x, y, z])
+        }
+      }
+    }
+  }
+
+  const obs = fromPointsConvex(out)
+  validate(obs)
+  t.is(obs.polygons.length, 170)
+  t.true(obs.polygons.every((f) => ([3, 4, 8, 9].indexOf(f.vertices.length) !== -1)))
+
+  const c = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  obs.polygons.forEach((f) => c[f.vertices.length]++)
+  t.is(c[3], 120)
+  t.is(c[4], 24)
+  t.is(c[8], 18)
+  t.is(c[9], 8)
+
+  let edges2 = 336 * 2
+  obs.polygons.forEach((f) => { edges2 -= f.vertices.length })
+  t.is(edges2, 0)
+})

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

@@ -1,6 +1,7 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { fromPoints } from './fromPoints.js'
+export { fromPointsConvex } from './fromPointsConvex.js'
 export { fromCompactBinary } from './fromCompactBinary.js'
 export { invert } from './invert.js'
 export { isA } from './isA.js'

package/src/geometries/geom3/index.js

@@ -17,6 +17,7 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { fromPoints } from './fromPoints.js'
+export { fromPointsConvex } from './fromPointsConvex.js'
 export { fromCompactBinary } from './fromCompactBinary.js'
 export { invert } from './invert.js'
 export { isA } from './isA.js'

package/src/geometries/index.js

@@ -5,14 +5,13 @@
  * @see {@link geom2} - 2D geometry consisting of 2D outlines
  * @see {@link geom3} - 3D geometry consisting of polygons
  * @see {@link path2} - 2D geometry consisting of ordered points
- * @see {@link poly2} - 2D polygon consisting of ordered vertices
+ * @see {@link poly2} - 2D polygon consisting of ordered points
  * @see {@link poly3} - 3D polygon consisting of ordered vertices
- * @see {@link slice} - 3D geometry consisting of 3D outlines
+ * @see {@link slice} - 3D geometry consisting of 3D contours
  *
  * @module modeling/geometries
  * @example
- * import { geometries } from '@jscad/modeling'
- * const { geom2, geom3, path2, poly2, poly3 } = geometries
+ * import { geom2, geom3, path2, poly2, poly3, slice } from '@jscad/modeling'
  */
 export * as geom2 from './geom2/index.js'
 export * as geom3 from './geom3/index.js'

package/src/geometries/path2/appendBezier.js

@@ -14,7 +14,7 @@ import { toPoints } from './toPoints.js'
  * In other words, the trailing gradient of the geometry matches the new gradient of the curve.
  * @param {object} options - options for construction
  * @param {Array} options.controlPoints - list of control points (2D) for the Bézier curve
- * @param {number} [options.segment=16] - number of segments per 360 rotation
+ * @param {number} [options.segments=16] - number of segments per 360 rotation
  * @param {Path2} geometry - the path of which to append points
  * @returns {Path2} a new path with the appended points
  * @alias module:modeling/geometries/path2.appendBezier

package/src/geometries/poly3/index.js

@@ -15,7 +15,7 @@ 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 { measureBoundingSphere, measureBoundingSphereAndCache } from './measureBoundingSphere.js'
 export { measureSignedVolume } from './measureSignedVolume.js'
 export { plane } from './plane.js'
 export { toVertices } from './toVertices.js'

package/src/geometries/poly3/measureBoundingBox.js

@@ -1,6 +1,8 @@
 import * as vec3 from '../../maths/vec3/index.js'
 
 /**
+ * Measure the bounding box of the given polygon.
+ *
  * @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

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

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

package/src/geometries/poly3/measureBoundingSphere.js

@@ -4,16 +4,14 @@ const cache = new WeakMap()
 
 /**
  * Measure the bounding sphere of the given polygon.
+ *
+ * @param {Vec4} out - receiving vector
  * @param {Poly3} polygon - the polygon to measure
  * @returns {Vec4} the computed bounding sphere; center vertex (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
-export const measureBoundingSphere = (polygon) => {
-  const boundingSphere = cache.get(polygon)
-  if (boundingSphere) return boundingSphere
-
+export const measureBoundingSphere = (out, polygon) => {
   const vertices = polygon.vertices
-  const out = vec4.create()
 
   if (vertices.length === 0) {
     out[0] = 0
@@ -31,14 +29,15 @@ export const measureBoundingSphere = (polygon) => {
   let maxy = minx
   let maxz = minx
 
-  vertices.forEach((v) => {
+  for (let i = 0; i < vertices.length; i++) {
+    const v = vertices[i]
     if (minx[0] > v[0]) minx = v
     if (miny[1] > v[1]) miny = v
     if (minz[2] > v[2]) minz = v
     if (maxx[0] < v[0]) maxx = v
     if (maxy[1] < v[1]) maxy = v
     if (maxz[2] < v[2]) maxz = v
-  })
+  }
 
   out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
   out[1] = (miny[1] + maxy[1]) * 0.5
@@ -48,7 +47,25 @@ export const measureBoundingSphere = (polygon) => {
   const z = out[2] - maxz[2]
   out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
 
-  cache.set(polygon, out)
+  return out
+}
+
+/**
+ * Measure the bounding sphere of the given polygon.
+ *
+ * This version maintains a cache, retrievning previously calculated bounds if found.
+ *
+ * @param {Poly3} polygon - the polygon to measure
+ * @returns {Vec4} the computed bounding sphere; center vertex (3D) and radius
+ * @alias module:modeling/geometries/poly3.measureBoundingSphere
+ */
+export const measureBoundingSphereAndCache = (polygon) => {
+  const boundingSphere = cache.get(polygon)
+  if (boundingSphere) return boundingSphere
 
+  const out = [0, 0, 0, 0]
+  measureBoundingSphere(out, polygon)
+
+  cache.set(polygon, out)
   return out
 }

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

@@ -7,19 +7,22 @@ import { measureBoundingSphere, create, transform } from './index.js'
 test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let ply1 = create()
   let exp1 = [0, 0, 0, 0]
-  let ret1 = measureBoundingSphere(ply1)
+  let ret1 = [0, 0, 0, 0]
+  ret1 = measureBoundingSphere(ret1, ply1)
   t.deepEqual(ret1, exp1)
 
   // simple triangle
   let ply2 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [0, 5, 5, 7.0710678118654755]
-  let ret2 = measureBoundingSphere(ply2)
+  let ret2 = [0, 0, 0, 0]
+  ret2 = measureBoundingSphere(ret2, ply2)
   t.deepEqual(ret2, exp2)
 
   // simple square
   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)
+  let ret3 = [0, 0, 0, 0]
+  ret3 = measureBoundingSphere(ret3, ply3)
   t.deepEqual(ret3, exp3)
 
   // V-shape
@@ -37,7 +40,8 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ]
   let ply4 = create(vertices)
   let exp4 = [0, 4.5, 3, 4.6097722286464435]
-  let ret4 = measureBoundingSphere(ply4)
+  let ret4 = [0, 0, 0, 0]
+  ret4 = measureBoundingSphere(ret4, ply4)
   t.deepEqual(ret4, exp4)
 
   // rotated to various angles
@@ -46,10 +50,10 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ply2 = transform(rotation, ply2)
   ply3 = transform(rotation, ply3)
   ply4 = transform(rotation, ply4)
-  ret1 = measureBoundingSphere(ply1)
-  ret2 = measureBoundingSphere(ply2)
-  ret3 = measureBoundingSphere(ply3)
-  ret4 = measureBoundingSphere(ply4)
+  ret1 = measureBoundingSphere(ret1, ply1)
+  ret2 = measureBoundingSphere(ret2, ply2)
+  ret3 = measureBoundingSphere(ret3, ply3)
+  ret4 = measureBoundingSphere(ret4, ply4)
   exp1 = [0, 0, 0, 0]
   t.deepEqual(ret1, exp1)
   exp2 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]

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

@@ -6,6 +6,6 @@ export interface Poly3 {
   vertices: Array<Vec3>
   color?: Color
 
-  // used internally for caching:
+  // used internally for calculations
   plane?: Plane
 }

package/src/geometries/slice/validate.js

@@ -28,10 +28,9 @@ export const validate = (object) => {
     // contours must be coplanar
     const contourPlane = poly3.plane(poly3.create(contour))
     if (!plane.equals(slicePlane, contourPlane)) {
-      throw new Error(`slice contours must be coplanar`)
+      throw new Error('slice contours must be coplanar')
     }
 
-
     for (let i = 0; i < contour.length; i++) {
       const vertex = contour[i]
       // check for infinity, nan

package/src/index.js

@@ -13,3 +13,44 @@ export * from './operations/hulls/index.js'
 export * from './operations/modifiers/index.js'
 export * from './operations/offsets/index.js'
 export * from './operations/transforms/index.js'
+
+// V2 API compatibility:
+export * as colors from './colors/index.js'
+export * as curves from './curves/index.js'
+import { geom2, geom3, path2, poly2, poly3 } from './geometries/index.js'
+export const geometries = {
+  geom2: {
+    ...geom2,
+    create: (sides) => geom2.fromSides(sides),
+    fromPoints: (points) => geometries.geom2.create([points])
+  },
+  geom3,
+  path2,
+  poly2,
+  poly3: {
+    ...poly3,
+    fromPoints: (points) => poly3.create([points]),
+    fromPointsAndPlane: poly3.fromVerticesAndPlane,
+    toPoints: poly3.toVertices
+  }
+}
+export * as maths from './maths/index.js'
+export * as measurements from './measurements/index.js'
+export * as primitives from './primitives/index.js'
+export * as text from './text/index.js'
+export * as booleans from './operations/booleans/index.js'
+import * as extrusion from './operations/extrusions/index.js'
+import * as offsets from './operations/offsets/index.js'
+export const extrusions = {
+  ...extrusion,
+  extrudeRectangular: (opt, geom) => extrusions.extrudeLinear(opt, offsets.offset(opt, geom)),
+  slice: geometries.slice
+}
+export * as hulls from './operations/hulls/index.js'
+export * as modifiers from './operations/modifiers/index.js'
+export const expansions = {
+  ...offsets,
+  expand: offsets.offset
+}
+export * as transforms from './operations/transforms/index.js'
+export * as utils from './utils/index.js'

package/src/maths/index.js

@@ -15,3 +15,4 @@ export * as vec2 from './vec2/index.js'
 export * as vec3 from './vec3/index.js'
 export * as vec4 from './vec4/index.js'
 export { cos, sin } from './utils/trigonometry.js'
+export { area } from './utils/area.js'

package/src/maths/mat4/isOnlyTransformScale.js

@@ -18,7 +18,7 @@ export const isOnlyTransformScale = (matrix) => (
 )
 
 /**
- * @param {number} num 
+ * @param {number} num
  * @returns {boolean}
  */
 const isZero = (num) => Math.abs(num) < Number.EPSILON

package/src/measurements/measureAggregateArea.js

@@ -14,7 +14,6 @@ import { measureArea } from './measureArea.js'
  */
 export const measureAggregateArea = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateArea: no geometries supplied')
   const areas = measureArea(geometries)
   if (geometries.length === 1) {
     return areas

package/src/measurements/measureAggregateBoundingBox.js

@@ -15,7 +15,6 @@ import { measureBoundingBox } from './measureBoundingBox.js'
  */
 export const measureAggregateBoundingBox = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateBoundingBox: no geometries supplied')
   const bounds = measureBoundingBox(geometries)
   if (geometries.length === 1) {
     return bounds

package/src/measurements/measureAggregateEpsilon.js

@@ -18,7 +18,6 @@ import { calculateEpsilonFromBounds } from './calculateEpsilonFromBounds.js'
  */
 export const measureAggregateEpsilon = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateEpsilon: no geometries supplied')
   const bounds = measureAggregateBoundingBox(geometries)
 
   let dimensions = 0

package/src/measurements/measureAggregateVolume.js

@@ -14,7 +14,6 @@ import { measureVolume } from './measureVolume.js'
  */
 export const measureAggregateVolume = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateVolume: no geometries supplied')
   const volumes = measureVolume(geometries)
   if (geometries.length === 1) {
     return volumes

package/src/measurements/measureArea.js

@@ -85,7 +85,6 @@ const measureAreaOfSlice = (geometry) => {
  */
 export const measureArea = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return measureAreaOfPath2(geometry)

package/src/measurements/measureBoundingBox.js

@@ -121,7 +121,6 @@ const measureBoundingBoxOfSlice = (geometry) => {
  */
 export const measureBoundingBox = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath2)

package/src/measurements/measureBoundingSphere.js

@@ -64,17 +64,13 @@ const measureBoundingSphereOfPoints = (points) => {
  * Measure the bounding sphere of the given (path2) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
  */
-const measureBoundingSphereOfPath2 = (points) => {
-  return measureBoundingSphereOfPoints(path2.toPoints(points))
-}
+const measureBoundingSphereOfPath2 = (geometry) => measureBoundingSphereOfPoints(path2.toPoints(geometry))
 
 /*
  * Measure the bounding sphere of the given (geom2) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
  */
-const measureBoundingSphereOfGeom2 = (geometry) => {
-  return measureBoundingSphereOfPoints(geom2.toPoints(geometry))
-}
+const measureBoundingSphereOfGeom2 = (geometry) => measureBoundingSphereOfPoints(geom2.toPoints(geometry))
 
 /*
  * Measure the bounding sphere of the given (geom3) geometry.

package/src/measurements/measureEpsilon.js

@@ -20,7 +20,6 @@ import { measureBoundingBox } from './measureBoundingBox.js'
  */
 export const measureEpsilon = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)

package/src/measurements/measureVolume.js

@@ -34,7 +34,6 @@ const measureVolumeOfGeom3 = (geometry) => {
  */
 export const measureVolume = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (geom3.isA(geometry)) return measureVolumeOfGeom3(geometry)

package/src/operations/booleans/index.d.ts

@@ -1,3 +1,4 @@
 export { intersect } from './intersect.js'
 export { subtract } from './subtract.js'
 export { union } from './union.js'
+export { scission } from './scission.js'

package/src/operations/booleans/intersect.js

@@ -1,5 +1,5 @@
 import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
-import { flatten } from '../../utils/flatten.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
@@ -13,11 +13,11 @@ import { intersectGeom3 } from './intersectGeom3.js'
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {Geom2|geom3} a new geometry
+ * @returns {Geom2|Geom3} a new geometry
  * @alias module:modeling/booleans.intersect
  *
  * @example
- * let myshape = intersect(cube({size: [5,5,5]}), cube({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = intersect(cube({size: 5}), cube({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+
@@ -30,9 +30,9 @@ import { intersectGeom3 } from './intersectGeom3.js'
  *      +-------+
  */
 export const intersect = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('intersect wrong number of arguments')
+  geometries = coalesce(geometries)
 
+  if (geometries.length === 0) return undefined
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('intersect arguments must be the same geometry type')
   }