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

package/src/operations/extrusions/extrudeRotate.test.js

@@ -8,7 +8,7 @@ import { colorize } from '../../colors/index.js'
 
 import { geom2, geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { square } from '../../primitives/index.js'
 
@@ -20,6 +20,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
   const geometry3 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7033.914479497244)
   t.is(measureVolume(geometry3), 27648.000000000007)
   t.is(pts.length, 96)
 })
@@ -51,6 +52,7 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
     [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1360.144820048035)
   t.is(measureVolume(geometry3), 3258.3480477076105)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -58,12 +60,14 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 4525.850393739846)
   t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 4525.8503937398455)
   t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 })
@@ -80,6 +84,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [-11.803752993228215, 23.166169628897567, 8]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 6124.6858201346895)
   t.is(measureVolume(geometry3), 21912.342135440336)
   t.is(pts.length, 40)
   t.true(comparePoints(pts[6], exp))
@@ -92,6 +97,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [23.166169628897567, 11.803752993228215, 8]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 6124.685820134688)
   t.is(measureVolume(geometry3), 21912.342135440336)
   t.is(pts.length, 40)
   t.true(comparePoints(pts[6], exp))
@@ -104,12 +110,14 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 5562.34804770761)
   t.is(measureVolume(geometry3), 18432)
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7230.965353920782)
   t.is(measureVolume(geometry3), 28906.430888871357)
   t.is(pts.length, 512)
 
@@ -118,6 +126,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 84.28200374166053)
   t.is(measureVolume(geometry3), 33.94112549695427)
   t.is(pts.length, 64)
 
@@ -126,6 +135,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 17692.315375839215)
   t.is(measureVolume(geometry3), 147078.2104868019)
   t.is(pts.length, 80)
 })
@@ -147,6 +157,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[7, 0, -8], [7, 0, 8], [0, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 431.3919189857867)
   t.is(measureVolume(obs), 391.99999999999994)
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -177,6 +188,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[2, 0, 4], [0, 0, 8], [0, 0, -8]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 86.47516025670329)
   t.is(measureVolume(obs), 26.398653164297773)
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/extrusions/project.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { aboutEqualNormals } from '../../maths/utils/aboutEqualNormals.js'
 
 import * as plane from '../../maths/plane/index.js'
@@ -80,15 +78,13 @@ export const project = (options, ...objects) => {
   }
   const { axis, origin } = Object.assign({ }, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   options = { axis, origin }
 
   const results = objects.map((object) => {
     // if (path.isA(object)) return project(options, object)
     // if (geom2.isA(object)) return project(options, object)
     if (geom3.isA(object)) return projectGeom3(options, object)
+    if (Array.isArray(object)) return project(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/hulls/hull.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'
@@ -12,8 +12,8 @@ import { hullGeom3 } from './hullGeom3.js'
 /**
  * Create a convex hull of the given geometries.
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
- * @param {...Objects} geometries - list of geometries from which to create a hull
- * @returns {Geom2|Geom3} new geometry
+ * @param {...Object} geometries - list of geometries from which to create a hull
+ * @returns {Geom2|Geom3|Path2} new geometry
  * @alias module:modeling/hulls.hull
  *
  * @example
@@ -33,8 +33,9 @@ import { hullGeom3 } from './hullGeom3.js'
  *       +-------+           +-------+
  */
 export const hull = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  geometries = coalesce(geometries)
+
+  if (geometries.length === 0) return undefined
 
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('only hulls of the same type are supported')

package/src/operations/hulls/hull.test.js

@@ -1,8 +1,11 @@
 import test from 'ava'
 
 import { geom2, geom3, path2 } from '../../geometries/index.js'
-import { measureArea } from '../../measurements/measureArea.js'
-import { sphere, cuboid, ellipsoid } from '../../primitives/index.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+import { cuboid, ellipsoid, sphere, square, torus } from '../../primitives/index.js'
+
 import { center } from '../transforms/index.js'
 
 import { hull } from './index.js'
@@ -41,6 +44,7 @@ test('hull (single, geom2)', (t) => {
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 232.09469999999993)
   t.is(pts.length, 7)
 })
 
@@ -68,6 +72,7 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   let pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 100)
   t.is(pts.length, 4)
 
   // one inside another
@@ -75,6 +80,7 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 100)
   t.is(pts.length, 4)
 
   // one overlapping another
@@ -82,12 +88,14 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 116)
   t.is(pts.length, 8)
 
   obs = hull(geometry2, geometry4)
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 232.09469999999993)
   t.is(pts.length, 7)
 })
 
@@ -114,26 +122,31 @@ test('hull (multiple, various, geom2)', (t) => {
   let obs = hull(geometry1, geometry2)
   let pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 99)
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry3)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 308)
   t.is(pts.length, 5)
 
   obs = hull(geometry2, geometry3)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 308)
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry2, geometry3)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 341)
   t.is(pts.length, 6)
 
   obs = hull(geometry5, geometry4)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 513.39595)
   t.is(pts.length, 8)
 })
 
@@ -215,7 +228,9 @@ test('hull (single, geom3)', (t) => {
   obs = hull(geometry)
   pts = geom3.toPoints(obs)
 
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 44.05375630658983)
+  t.is(measureVolume(obs), 25.75161133197968)
   t.is(pts.length, 32)
 })
 
@@ -234,6 +249,8 @@ test('hull (multiple, geom3)', (t) => {
   ]
 
   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))
 
@@ -257,6 +274,8 @@ test('hull (multiple, geom3)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 145.59502802663923)
+  t.is(measureVolume(obs), 112.49999999999999)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -270,5 +289,39 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 282.26819685563686)
+  t.is(measureVolume(obs), 366.67641200012866)
   t.is(pts.length, 92)
 })
+
+test('hull (multiple with undefined/null values)', (t) => {
+  const square1 = square({ size: 4 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 8 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = hull(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 64)
+  t.is(pts.length, 4)
+})
+
+test('hull (multiple with nested arrays)', (t) => {
+  const square1 = square({ size: 4 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 8 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = hull(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 64)
+  t.is(pts.length, 4)
+})
+
+test('hull (single, unconvex, geom3)', (t) => {
+  const geometry = torus()
+  const obs = hull(geometry)
+  t.assert(measureVolume(obs) > measureVolume(geometry))
+})

package/src/operations/hulls/hullChain.js

@@ -1,4 +1,5 @@
-import { flatten } from '../../utils/flatten.js'
+import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import { union } from '../booleans/union.js'
 
@@ -10,7 +11,7 @@ import { hull } from './hull.js'
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
  *
  * @param {...Objects} geometries - list of geometries from which to create a hull
- * @returns {Geom2|Geom3} new geometry
+ * @returns {Geom2|Geom3|Path2} new geometry
  * @alias module:modeling/hulls.hullChain
  *
  * @example
@@ -30,12 +31,16 @@ import { hull } from './hull.js'
  *       +-------+                +-------+
  */
 export const hullChain = (...geometries) => {
-  geometries = flatten(geometries)
-  const hulls = []
+  geometries = coalesce(geometries)
+
+  if (geometries.length === 0) return undefined
+  if (geometries.length === 1) return geometries[0]
 
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
-  if (geometries.length === 1) hulls.push(geometries[0])
+  if (!areAllShapesTheSameType(geometries)) {
+    throw new Error('only hulls of the same type are supported')
+  }
 
+  const hulls = []
   for (let i = 1; i < geometries.length; i++) {
     hulls.push(hull(geometries[i - 1], geometries[i]))
   }

package/src/operations/hulls/hullChain.test.js

@@ -1,13 +1,15 @@
 import test from 'ava'
 
 import { geom2, geom3 } from '../../geometries/index.js'
-import { measureArea } from '../../measurements/measureArea.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
 import { square } from '../../primitives/square.js'
 
 import { hullChain } from './index.js'
 
 test('hullChain: hullChain single geometry', (t) => {
-  const result = hullChain([ square({ size: 1 }) ])
+  const result = hullChain([square({ size: 1 })])
   t.notThrows(() => geom2.validate(result))
   t.is(measureArea(result), 1)
   t.is(geom2.toPoints(result).length, 4)
@@ -22,6 +24,7 @@ test('hullChain (two, geom2)', (t) => {
   let pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 9)
   t.is(pts.length, 4)
 
   // different
@@ -29,6 +32,7 @@ test('hullChain (two, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 81)
   t.is(pts.length, 6)
 })
 
@@ -43,6 +47,7 @@ test('hullChain (three, geom2)', (t) => {
 
   // the sides change based on the bestplane chosen in trees/Node.js
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 126)
   t.is(pts.length, 10)
 
   // closed
@@ -51,6 +56,7 @@ test('hullChain (three, geom2)', (t) => {
 
   // the sides change based on the bestplane chosen in trees/Node.js
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 148.21875)
   t.is(pts.length, 10)
 })
 
@@ -85,6 +91,8 @@ test('hullChain (three, geom3)', (t) => {
   let pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 266.1454764345133)
+  t.is(measureVolume(obs), 239.2012987012987)
   t.is(pts.length, 23)
 
   // closed
@@ -92,5 +100,7 @@ test('hullChain (three, geom3)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 272.2887171436021)
+  t.is(measureVolume(obs), 261.96982218883045)
   t.is(pts.length, 28)
 })

package/src/operations/hulls/hullGeom2.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 
 import { hullPoints2 } from './hullPoints2.js'
@@ -7,12 +5,13 @@ import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geom2 geometries.
- * @param {...geometries} geometries - list of geom2 geometries
+ *
+ * NOTE: The given geometries must be valid geom2 geometries.
+ *
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
  * @returns {Geom2} new geometry
  */
-export const hullGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullGeom2 = (geometries) => {
   // extract the unique points from the geometries
   const unique = toUniquePoints(geometries)
 

package/src/operations/hulls/hullGeom3.js

@@ -1,30 +1,21 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom3 from '../../geometries/geom3/index.js'
-import * as poly3 from '../../geometries/poly3/index.js'
 
-import { runner } from './quickhull/index.js'
+import { hullPoints3 } from './hullPoints3.js'
 import { toUniquePoints } from './toUniquePoints.js'
 
 /*
- * Create a convex hull of the given geometries (geom3).
- * @param {...geometries} geometries - list of geom3 geometries
+ * Create a convex hull of the given geom3 geometries.
+ *
+ * NOTE: The given geometries must be valid geom3 geometries.
+ *
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
  * @returns {Geom3} new geometry
  */
-export const hullGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
-  if (geometries.length === 1) return geometries[0]
-
+export const hullGeom3 = (geometries) => {
   // extract the unique vertices from the geometries
   const unique = toUniquePoints(geometries)
 
-  const faces = runner(unique, { skipTriangulation: true })
-
-  const polygons = faces.map((face) => {
-    const vertices = face.map((index) => unique[index])
-    return poly3.create(vertices)
-  })
+  if (unique.length === 0) return geom3.create()
 
-  return geom3.create(polygons)
+  return geom3.create(hullPoints3(unique))
 }

package/src/operations/hulls/hullPath2.js

@@ -1,18 +1,17 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as path2 from '../../geometries/path2/index.js'
 
 import { hullPoints2 } from './hullPoints2.js'
 import { toUniquePoints } from './toUniquePoints.js'
 
 /*
- * Create a convex hull of the given geometries (path2).
- * @param {...geometries} geometries - list of path2 geometries
+ * Create a convex hull of the given path2 geometries.
+ *
+ * NOTE: The given geometries must be valid path2 geometry.
+ *
+ * @param {Path2[]} geometries - a flat list of path2 geometries
  * @returns {Path2} new geometry
  */
-export const hullPath2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullPath2 = (geometries) => {
   // extract the unique points from the geometries
   const unique = toUniquePoints(geometries)
 

package/src/operations/hulls/hullPath2.test.js

@@ -9,7 +9,7 @@ test('hullPath2', (t) => {
   const geometry1 = path2.fromPoints({ closed }, [[0, 0], [-4, 4], [-4, -4]])
   const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
 
-  const obs = hullPath2(geometry1, geometry2)
+  const obs = hullPath2([geometry1, geometry2])
   t.notThrows(() => path2.validate(obs))
   const pts = path2.toPoints(obs)
   t.is(pts.length, 4)

package/src/operations/hulls/hullPoints2.d.ts

@@ -0,0 +1,3 @@
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+
+export function hullPoints2(uniquePoints: Array<Vec2>): Array<Vec2>

package/src/operations/hulls/hullPoints2.js

@@ -1,10 +1,12 @@
 import * as vec2 from '../../maths/vec2/index.js'
 
-/*
+/**
  * Create a convex hull of the given set of points, where each point is an array of [x,y].
- * Uses https://en.wikipedia.org/wiki/Graham_scan
+ *
+ * @see https://en.wikipedia.org/wiki/Graham_scan
  * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
  * @returns {Array} a list of points that form the hull
+ * @alias module:modeling/hulls.hullPoints2
  */
 export const hullPoints2 = (uniquePoints) => {
   // find min point

package/src/operations/hulls/hullPoints3.d.ts

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

package/src/operations/hulls/hullPoints3.js

@@ -0,0 +1,21 @@
+import * as poly3 from '../../geometries/poly3/index.js'
+
+import { runner } from './quickhull/index.js'
+
+/**
+ * Create a convex hull of the given set of points, where each point is an array of [x,y,z].
+ *
+ * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
+ * @returns {Array} a list of polygons (poly3)
+ * @alias module:modeling/hulls.hullPoints3
+ */
+export const hullPoints3 = (uniquePoints) => {
+  const faces = runner(uniquePoints, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniquePoints[index])
+    return poly3.create(vertices)
+  })
+
+  return polygons
+}

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

@@ -1,2 +1,4 @@
 export { hull } from './hull.js'
 export { hullChain } from './hullChain.js'
+export { hullPoints2 } from './hullPoints2.js'
+export { hullPoints3 } from './hullPoints3.js'

package/src/operations/hulls/index.js

@@ -4,7 +4,9 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/hulls
  * @example
- * import { hull, hullChain } from '@jscad/modeling'
+ * import { hull, hullChain, hullPoints2, hullPoints3 } from '@jscad/modeling'
  */
 export { hull } from './hull.js'
 export { hullChain } from './hullChain.js'
+export { hullPoints2 } from './hullPoints2.js'
+export { hullPoints3 } from './hullPoints3.js'

package/src/operations/modifiers/generalize.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -67,14 +65,12 @@ const generalizeGeom3 = (options, geometry) => {
  * @alias module:modeling/modifiers.generalize
  */
 export const generalize = (options, ...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 generalizePath2(options, geometry)
     if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
     if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)
-    throw new Error('invalid geometry')
+    if (Array.isArray(geometry)) return generalize(options, ...geometry)
+    return geometry
   })
   return results.length === 1 ? results[0] : results
 }

package/src/operations/modifiers/index.js

@@ -3,7 +3,7 @@
  * In all cases, these functions returns the results, and never changes the original geometry.
  * @module modeling/modifiers
  * @example
- * import { generalize, snap } from '@jscad/modeling'
+ * import { generalize, snap, retessellate } from '@jscad/modeling'
  */
 export { generalize } from './generalize.js'
 export { snap } from './snap.js'

package/src/operations/modifiers/snap.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as vec2 from '../../maths/vec2/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -48,20 +46,18 @@ const snapGeom3 = (geometry) => {
 }
 
 /**
- * Snap the given geometries to the overall precision (epsilon) of the geometry.
+ * Snap the given geometries to the precision (calculated epsilon) of the geometry.
  * @see measurements.measureEpsilon()
  * @param {...Object} geometries - the geometries to snap
  * @return {Object|Array} the snapped geometry, or a list of snapped geometries
  * @alias module:modeling/modifiers.snap
  */
 export const snap = (...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 snapPath2(geometry)
     if (geom2.isA(geometry)) return snapGeom2(geometry)
     if (geom3.isA(geometry)) return snapGeom3(geometry)
+    if (Array.isArray(geometry)) return snap(...geometry)
     return geometry
   })
   return results.length === 1 ? results[0] : results

package/src/operations/offsets/offset.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'
@@ -23,13 +21,11 @@ import { offsetPath2 } from './offsetPath2.js'
  * let small = offset({ delta: -4, corners: 'chamfer' }, square({size: 40})) // contract
  */
 export const offset = (options, ...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     if (path2.isA(object)) return offsetPath2(options, object)
     if (geom2.isA(object)) return offsetGeom2(options, object)
     if (geom3.isA(object)) return offsetGeom3(options, object)
+    if (Array.isArray(object)) return offset(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/offsets/offsetFromPoints.test.js

@@ -200,7 +200,6 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
 
 test('offset (corners: round): offset of a path2 produces expected offset path2', (t) => {
   const openline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]]
-  const closeline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]]
 
   let pts = offsetFromPoints({ delta: 1, corners: 'round', segments: 16 }, openline)
   let obs = path2.create(pts)