@jscad/modeling 3.0.4-alpha.0 → 3.0.5-alpha.0

package/src/measurements/measureCenterOfMass.js

@@ -95,9 +95,10 @@ export const measureCenterOfMass = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    // NOTE: center of mass for geometry path2 is not possible
-    if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry)
     if (geom3.isA(geometry)) return measureCenterOfMassGeom3(geometry)
+    if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry)
+    // TODO if (slice.isA(geometry)) return measureCenterOfMassSlice(geometry)
+    // NOTE: center of mass for geometry path2 and path3 is not possible
     return [0, 0, 0]
   })
   return results.length === 1 ? results[0] : results

package/src/measurements/measureEpsilon.js

@@ -3,6 +3,7 @@ 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 * as path3 from '../geometries/path3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
 import { calculateEpsilonFromBounds } from './calculateEpsilonFromBounds.js'
@@ -22,9 +23,10 @@ export const measureEpsilon = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-    if (geom2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
     if (geom3.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
+    if (geom2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
+    if (path2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
+    if (path3.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
     if (slice.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
     return 0
   })

package/src/operations/booleans/trees/splitPolygonByPlane.d.ts

@@ -28,6 +28,4 @@ interface SplitRes
 // In case the polygon is spanning, returns:
 // .front: a Polygon3 of the front part
 // .back: a Polygon3 of the back part
-declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;
-
-export default splitPolygonByPlane;
+export declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;

package/src/operations/booleans/union.js

@@ -37,7 +37,7 @@ export const union = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return unionPath(matrix, geometries)
+  // TODO if (path2.isA(geometry)) return unionPath(geometries)
   if (geom2.isA(geometry)) return unionGeom2(geometries)
   if (geom3.isA(geometry)) return unionGeom3(geometries)
   throw new Error('union unsupported geometry type')

package/src/operations/extrusions/extrudeFromSlices.js

@@ -9,7 +9,7 @@ import { extrudeWalls } from './extrudeWalls.js'
 
 const defaultCallback = (progress, index, base) => {
   let baseSlice = null
-  if (geom2.isA(base)) baseSlice = slice.fromGeom2(base)
+  if (geom2.isA(base)) baseSlice = slice.fromOutlines(geom2.toOutlines(base))
   if (poly3.isA(base)) baseSlice = slice.fromVertices(poly3.toVertices(base))
 
   return progress === 0 || progress === 1 ? slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, progress]), baseSlice) : null

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

@@ -111,7 +111,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
       numberOfSlices: 5,
       callback: (progress, count, base) => {
         const newShape = circle({ radius: 5 + count, segments: 4 + count })
-        let newSlice = slice.fromGeom2(newShape)
+        let newSlice = slice.fromOutlines(geom2.toOutlines(newShape))
         newSlice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 10]), newSlice)
         return newSlice
       }

package/src/operations/extrusions/extrudeHelical.js

@@ -1,4 +1,5 @@
 import { TAU } from '../../maths/constants.js'
+import * as geom2 from '../../geometries/geom2/index.js'
 import * as slice from '../../geometries/slice/index.js'
 import * as mat4 from '../../maths/mat4/index.js'
 import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
@@ -45,7 +46,7 @@ export const extrudeHelical = (options, geometry) => {
 
   if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
-  let baseSlice = slice.fromGeom2(geometry)
+  let baseSlice = slice.fromOutlines(geom2.toOutlines(geometry))
 
   const bounds = measureBoundingBox(geometry)
   if (bounds[1][0] <= 0) {

package/src/operations/extrusions/extrudeLinear.js

@@ -28,7 +28,7 @@ export const extrudeLinear = (options, ...objects) => {
   }
   const { height, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
-  options = { offset: [0, 0, height], twistAngle, twistSteps, repair }
+  options = { height, twistAngle, twistSteps, repair, offset: [0, 0, height] }
 
   const results = objects.map((object) => {
     if (path2.isA(object)) return extrudeLinearPath2(options, object)

package/src/operations/extrusions/extrudeLinearGeom2.js

@@ -1,6 +1,7 @@
 import * as mat4 from '../../maths/mat4/index.js'
 import * as vec3 from '../../maths/vec3/index.js'
 
+import * as geom2 from '../../geometries/geom2/index.js'
 import * as slice from '../../geometries/slice/index.js'
 
 import { extrudeFromSlices } from './extrudeFromSlices.js'
@@ -34,7 +35,7 @@ export const extrudeLinearGeom2 = (options, geometry) => {
   // convert to vector in order to perform transforms
   const offsetV = vec3.clone(offset)
 
-  let baseSlice = slice.fromGeom2(geometry)
+  let baseSlice = slice.fromOutlines(geom2.toOutlines(geometry))
   if (offsetV[2] < 0) baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()

package/src/operations/extrusions/extrudeRotate.js

@@ -106,7 +106,7 @@ export const extrudeRotate = (options, geometry) => {
 
   const rotationPerSlice = totalRotation / segments
   const isCapped = Math.abs(totalRotation) < TAU
-  let baseSlice = slice.fromGeom2(sliceGeometry)
+  let baseSlice = slice.fromOutlines(geom2.toOutlines(sliceGeometry))
   baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()

package/src/operations/hulls/hull.js

@@ -42,9 +42,10 @@ export const hull = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  if (path2.isA(geometry)) return hullPath2(geometries)
-  if (geom2.isA(geometry)) return hullGeom2(geometries)
   if (geom3.isA(geometry)) return hullGeom3(geometries)
+  if (geom2.isA(geometry)) return hullGeom2(geometries)
+  if (path2.isA(geometry)) return hullPath2(geometries)
+  // FIXME return geom3? if (path3.isA(geometry)) return hullPath3(geometries)
 
   // FIXME should this throw an error for unknown geometries?
   return geometry

package/src/operations/hulls/toUniquePoints.js

@@ -1,6 +1,7 @@
 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 * as path3 from '../../geometries/path3/index.js'
 
 /*
  * Return the unique vertices of a geometry
@@ -25,6 +26,8 @@ export const toUniquePoints = (geometries) => {
       geom3.toVertices(geometry).forEach((vertices) => vertices.forEach(addPoint))
     } else if (path2.isA(geometry)) {
       path2.toPoints(geometry).forEach(addPoint)
+    } else if (path3.isA(geometry)) {
+      path3.toVertices(geometry).forEach(addPoint)
     }
   })
 

package/src/operations/modifiers/generalize.js

@@ -3,6 +3,8 @@ import { measureEpsilon } from '../../measurements/measureEpsilon.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 * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 import { snapPolygons } from './snapPolygons.js'
 import { mergePolygons } from './mergePolygons.js'
@@ -13,6 +15,10 @@ import { triangulatePolygons } from './triangulatePolygons.js'
  */
 const generalizePath2 = (options, geometry) => geometry
 
+/*
+ */
+const generalizePath3 = (options, geometry) => geometry
+
 /*
  */
 const generalizeGeom2 = (options, geometry) => geometry
@@ -66,9 +72,10 @@ const generalizeGeom3 = (options, geometry) => {
  */
 export const generalize = (options, ...geometries) => {
   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)
+    if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
+    if (path2.isA(geometry)) return generalizePath2(options, geometry)
+    if (path3.isA(geometry)) return generalizePath3(options, geometry)
     if (Array.isArray(geometry)) return generalize(options, ...geometry)
     return geometry
   })

package/src/operations/modifiers/snap.js

@@ -1,22 +1,38 @@
 import * as vec2 from '../../maths/vec2/index.js'
+import * as vec3 from '../../maths/vec2/index.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 * as path3 from '../../geometries/path3/index.js'
 import * as poly2 from '../../geometries/poly2/index.js'
 
 import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
 import { snapPolygons } from './snapPolygons.js'
 
+/*
+ */
 const snapPath2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const points = path2.toPoints(geometry)
   const newPoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
   // snap can produce duplicate points, remove those
-  return path2.create(newPoints)
+  return path2.fromPoints({}, newPoints)
+}
+
+/*
+ */
+const snapPath3 = (geometry) => {
+  const epsilon = measureEpsilon(geometry)
+  const vertices = path3.toVertices(geometry)
+  const newVertices = vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon))
+  // snap can produce duplicate points, remove those
+  return path3.fromVertices({}, newVertices)
 }
 
+/*
+ */
 const snapGeom2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const outlines = geom2.toOutlines(geometry)
@@ -38,6 +54,8 @@ const snapGeom2 = (geometry) => {
   return geom2.create(newOutlines)
 }
 
+/*
+ */
 const snapGeom3 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const polygons = geom3.toPolygons(geometry)
@@ -54,9 +72,10 @@ const snapGeom3 = (geometry) => {
  */
 export const snap = (...geometries) => {
   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 (geom2.isA(geometry)) return snapGeom2(geometry)
+    if (path2.isA(geometry)) return snapPath2(geometry)
+    if (path3.isA(geometry)) return snapPath3(geometry)
     if (Array.isArray(geometry)) return snap(...geometry)
     return geometry
   })

package/src/operations/transforms/align.js

@@ -76,12 +76,13 @@ export const align = (options, ...geometries) => {
   options = validateOptions(options)
   let { modes, relativeTo, grouped } = options
 
+  geometries = coalesce(geometries)
+
   if (relativeTo.filter((val) => val == null).length) {
     const bounds = measureAggregateBoundingBox(geometries)
     relativeTo = populateRelativeToFromBounds(relativeTo, modes, bounds)
   }
   if (grouped) {
-    geometries = coalesce(geometries)
     geometries = alignGeometries(geometries, modes, relativeTo)
   } else {
     geometries = geometries.map((geometry) => alignGeometries(geometry, modes, relativeTo))

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

@@ -79,7 +79,7 @@ test('align: multiple objects ungrouped, relativeTo is nulls, returns geometry a
     cube({ size: 2, center: [4, 4, 4] }),
     cube({ size: 4, center: [10, 10, 10] })
   ]
-  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, ...original)
+  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[5.5, 3, 8], [9.5, 7, 12]]
   t.notThrows(() => geom3.validate(aligned[0]))

package/src/operations/transforms/mirror.js

@@ -4,6 +4,8 @@ import * as plane from '../../maths/plane/index.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 * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Mirror the given objects using the given options.
@@ -33,9 +35,11 @@ export const mirror = (options, ...objects) => {
   const matrix = mat4.mirrorByPlane(mat4.create(), planeOfMirror)
 
   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)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return mirror(options, ...object)
     return object

package/src/operations/transforms/rotate.js

@@ -3,6 +3,8 @@ import * as mat4 from '../../maths/mat4/index.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 * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Rotate the given objects using the given options.
@@ -28,9 +30,11 @@ export const rotate = (angles, ...objects) => {
   const matrix = mat4.fromTaitBryanRotation(mat4.create(), yaw, pitch, roll)
 
   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)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return rotate(angles, ...object)
     return object

package/src/operations/transforms/scale.js

@@ -3,6 +3,8 @@ import * as mat4 from '../../maths/mat4/index.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 * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Scale the given objects using the given options.
@@ -26,9 +28,11 @@ export const scale = (factors, ...objects) => {
   const matrix = mat4.fromScaling(mat4.create(), factors)
 
   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)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return scale(factors, ...object)
     return object

package/src/operations/transforms/transform.js

@@ -1,6 +1,8 @@
 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 * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Transform the given objects using the given matrix.
@@ -16,9 +18,11 @@ export const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?
 
   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)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return transform(matrix, ...object)
     return object

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

@@ -4,11 +4,11 @@ import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/in
 
 import { mat4 } from '../../maths/index.js'
 
-import { geom2, geom3, path2 } from '../../geometries/index.js'
+import { geom2, geom3, path2, path3 } from '../../geometries/index.js'
 
 import { transform } from './index.js'
 
-test('transform: transforming of a path2 produces expected changes to points', (t) => {
+test('transform: (path2)', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 0])
   let geometry = path2.fromPoints({}, [[0, 0], [1, 0]])
 
@@ -19,7 +19,18 @@ test('transform: transforming of a path2 produces expected changes to points', (
   t.true(comparePoints(obs, exp))
 })
 
-test('transform: transforming of a geom2 produces expected changes to sides', (t) => {
+test('transform: (path3)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 2])
+  let geometry = path3.fromVertices({ closed: true }, [[0, 0, 0], [1, 0, 1], [3, 2, 1]])
+
+  geometry = transform(matrix, geometry)
+  const obs = path3.toVertices(geometry)
+  const exp = [[2, 2, 2], [3, 2, 3], [5, 4, 3]]
+  t.notThrows(() => path3.validate(geometry))
+  t.true(comparePoints(obs, exp))
+})
+
+test('transform: (geom2)', (t) => {
   const matrix = mat4.fromScaling(mat4.create(), [5, 5, 5])
   let geometry = geom2.create([[[0, 0], [1, 0], [0, 1]]])
 
@@ -30,7 +41,7 @@ test('transform: transforming of a geom2 produces expected changes to sides', (t
   t.true(comparePoints(obs, exp))
 })
 
-test('transform: transforming of a geom3 produces expected changes to polygons', (t) => {
+test('transform: (geom3)', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [-3, -3, -3])
   const points = [
     [[-2, -7, -12], [-2, -7, 18], [-2, 13, 18], [-2, 13, -12]],
@@ -55,7 +66,7 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
-test('transform: transforming of multiple objects produces expected changes', (t) => {
+test('transform: (multiple objects)', (t) => {
   const junk = 'hello'
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
   const geometry2 = geom2.create([[[-5, -5], [0, 5], [10, -5]]])

package/src/operations/transforms/translate.js

@@ -3,6 +3,8 @@ import * as mat4 from '../../maths/mat4/index.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 * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Translate the given objects using the given options.
@@ -24,9 +26,11 @@ export const translate = (offset, ...objects) => {
   const matrix = mat4.fromTranslation(mat4.create(), offset)
 
   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)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return translate(offset, ...object)
     return object

package/src/primitives/arc.js

@@ -8,6 +8,7 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an arc in two dimensional space where all points are at the same distance from the center.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of arc
  * @param {number} [options.radius=1] - radius of arc
@@ -17,19 +18,19 @@ 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 = {
-    center: [0, 0],
-    radius: 1,
-    startAngle: 0,
-    endAngle: TAU,
-    makeTangent: false,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, makeTangent, segments } = Object.assign({}, defaults, options)
+export const arc = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = 1,
+    startAngle = 0,
+    endAngle = TAU,
+    makeTangent = false,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')

package/src/primitives/circle.js

@@ -6,6 +6,7 @@ import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a circle in two dimensional space where all points are at the same distance from the center.
+ *
  * @see [ellipse]{@link module:modeling/primitives.ellipse} for more options
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of circle
@@ -15,18 +16,18 @@ import { isGTE } from './commonChecks.js'
  * @param {number} [options.segments=32] - number of segments to create per full rotation
  * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.circle
+ *
  * @example
  * let myshape = circle({radius: 10})
  */
-export const circle = (options) => {
-  const defaults = {
-    center: [0, 0],
-    radius: 1,
-    startAngle: 0,
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+export const circle = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = 1,
+    startAngle = 0,
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 

package/src/primitives/cube.js

@@ -12,12 +12,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = cube({size: 10})
  */
-export const cube = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    size: 2
-  }
-  let { center, size } = Object.assign({}, defaults, options)
+export const cube = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    size = 2
+  } = options
 
   if (!isGTE(size, 0)) throw new Error('size must be positive')
 

package/src/primitives/cuboid.js

@@ -5,6 +5,7 @@ import { isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned solid cuboid in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cuboid
  * @param {Array} [options.size=[2,2,2]] - dimensions of cuboid; width, depth, height
@@ -14,12 +15,11 @@ import { isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = cuboid({size: [5, 10, 5]})
  */
-export const cuboid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    size: [2, 2, 2]
-  }
-  const { center, size } = Object.assign({}, defaults, options)
+export const cuboid = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    size = [2, 2, 2]
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of width, depth and height values')

package/src/primitives/cylinder.js

@@ -4,6 +4,7 @@ import * as geom3 from '../geometries/geom3/index.js'
 
 /**
  * Construct a Z axis-aligned cylinder in three dimensional space.
+ *
  * @see [cylinderElliptic]{@link module:modeling/primitives.cylinderElliptic} for more options
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
@@ -16,14 +17,13 @@ import * as geom3 from '../geometries/geom3/index.js'
  * @example
  * let myshape = cylinder({height: 2, radius: 10})
  */
-export const cylinder = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    height: 2,
-    radius: 1,
-    segments: 32
-  }
-  const { center, height, radius, segments } = Object.assign({}, defaults, options)
+export const cylinder = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    height = 2,
+    radius = 1,
+    segments = 32
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 

package/src/primitives/cylinderElliptic.js

@@ -11,6 +11,7 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct a Z axis-aligned elliptic cylinder in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
  * @param {number} [options.height=2] - height of cylinder
@@ -25,17 +26,16 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = cylinderElliptic({height: 2, startRadius: [10,5], endRadius: [8,3]})
  */
-export const cylinderElliptic = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    height: 2,
-    startRadius: [1, 1],
-    startAngle: 0,
-    endRadius: [1, 1],
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, height, startRadius, startAngle, endRadius, endAngle, segments } = Object.assign({}, defaults, options)
+export const cylinderElliptic = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    height = 2,
+    startRadius = [1, 1],
+    startAngle = 0,
+    endRadius = [1, 1],
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isGT(height, 0)) throw new Error('height must be greater then zero')