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

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')
@@ -60,8 +61,8 @@ export const arc = (options) => {
     vec2.add(point, point, centerV)
     pointArray.push(point)
   } else {
-    // note: add one additional step to achieve full rotation
-    const numSteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1
+    const numSteps = Math.floor(segments * (Math.abs(rotation) / TAU))
+
     let edgeStepSize = numSteps * 0.5 / rotation // step size for half a degree
     if (edgeStepSize > 0.25) edgeStepSize = 0.25
 

package/src/primitives/arc.test.js

@@ -13,205 +13,196 @@ test('arc (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 33)
+  t.is(obs.length, 32)
 })
 
 test('arc (options)', (t) => {
   // test center
   let exp = [
     [3, 2],
-    [2.9324722294043557, 2.361241666187153],
-    [2.739008917220659, 2.6736956436465573],
-    [2.4457383557765384, 2.8951632913550625],
-    [2.092268359463302, 2.9957341762950342],
-    [1.7263370099279172, 2.961825643172819],
-    [1.3973653636207437, 2.7980172272802397],
-    [1.1497828642703858, 2.526432162877356],
-    [1.017026900316098, 2.1837495178165702],
-    [1.017026900316098, 1.8162504821834298],
-    [1.149782864270386, 1.4735678371226442],
-    [1.3973653636207435, 1.2019827727197605],
-    [1.726337009927917, 1.0381743568271808],
-    [2.0922683594633016, 1.0042658237049653],
-    [2.4457383557765384, 1.1048367086449378],
-    [2.739008917220659, 1.326304356353443],
-    [2.9324722294043557, 1.6387583338128469]
+    [2.923879532511287, 2.3826834323650896],
+    [2.7071067811865475, 2.7071067811865475],
+    [2.3826834323650896, 2.923879532511287],
+    [2, 3],
+    [1.6173165676349104, 2.923879532511287],
+    [1.2928932188134525, 2.7071067811865475],
+    [1.0761204674887133, 2.38268343236509],
+    [1, 2],
+    [1.076120467488713, 1.6173165676349104],
+    [1.2928932188134523, 1.2928932188134525],
+    [1.6173165676349097, 1.0761204674887135],
+    [2, 1],
+    [2.38268343236509, 1.0761204674887135],
+    [2.7071067811865475, 1.2928932188134523],
+    [2.9238795325112865, 1.6173165676349095]
   ]
   let geometry = arc({ center: [2, 2], segments: 16 })
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 17)
+  t.is(obs.length, 16)
   t.true(comparePoints(obs, exp))
 
   // test radius
   exp = [
     [2, 0],
-    [1.8649444588087116, 0.7224833323743058],
-    [1.4780178344413182, 1.3473912872931144],
-    [0.8914767115530766, 1.7903265827101247],
-    [0.18453671892660403, 1.991468352590069],
-    [-0.5473259801441658, 1.923651286345638],
-    [-1.2052692727585126, 1.5960344545604792],
-    [-1.7004342714592284, 1.0528643257547114],
-    [-1.9659461993678036, 0.36749903563314074],
-    [-1.9659461993678036, -0.36749903563314024],
-    [-1.7004342714592282, -1.0528643257547117],
-    [-1.205269272758513, -1.596034454560479],
-    [-0.5473259801441662, -1.923651286345638],
-    [0.1845367189266031, -1.9914683525900692],
-    [0.8914767115530771, -1.7903265827101245],
-    [1.4780178344413184, -1.3473912872931142],
-    [1.8649444588087116, -0.7224833323743061]
+    [1.8477590650225735, 0.7653668647301796],
+    [1.4142135623730951, 1.414213562373095],
+    [0.7653668647301797, 1.8477590650225735],
+    [0, 2],
+    [-0.7653668647301795, 1.8477590650225735],
+    [-1.414213562373095, 1.4142135623730951],
+    [-1.8477590650225735, 0.7653668647301798],
+    [-2, 0],
+    [-1.8477590650225737, -0.7653668647301793],
+    [-1.4142135623730954, -1.414213562373095],
+    [-0.7653668647301807, -1.847759065022573],
+    [0, -2],
+    [0.76536686473018, -1.8477590650225733],
+    [1.4142135623730947, -1.4142135623730954],
+    [1.847759065022573, -0.7653668647301808]
   ]
   geometry = arc({ radius: 2, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 17)
+  t.is(obs.length, 16)
   t.true(comparePoints(obs, exp))
 
   // test startAngle
   exp = [
-    [6.123233995736766e-17, 1],
-    [-0.3546048870425357, 0.9350162426854148],
-    [-0.6631226582407953, 0.748510748171101],
-    [-0.8854560256532098, 0.4647231720437687],
-    [-0.992708874098054, 0.12053668025532308],
-    [-0.970941817426052, -0.23931566428755788],
-    [-0.8229838658936566, -0.5680647467311556],
-    [-0.5680647467311559, -0.8229838658936564],
-    [-0.23931566428755774, -0.970941817426052],
-    [0.1205366802553232, -0.992708874098054],
-    [0.4647231720437688, -0.8854560256532098],
-    [0.7485107481711007, -0.6631226582407955],
-    [0.9350162426854147, -0.35460488704253595],
-    [1, -2.4492935982947064e-16]
+    [0, 1],
+    [-0.3826834323650897, 0.9238795325112867],
+    [-0.7071067811865475, 0.7071067811865476],
+    [-0.9238795325112867, 0.3826834323650899],
+    [-1, 0],
+    [-0.9238795325112868, -0.38268343236508967],
+    [-0.7071067811865477, -0.7071067811865475],
+    [-0.38268343236509034, -0.9238795325112865],
+    [0, -1],
+    [0.38268343236509, -0.9238795325112866],
+    [0.7071067811865474, -0.7071067811865477],
+    [0.9238795325112865, -0.3826834323650904],
+    [1, 0]
   ]
   geometry = arc({ startAngle: TAU / 4, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 14)
+  t.is(obs.length, 13)
   t.true(comparePoints(obs, exp))
 
   // test endAngle
   exp = [
     [1, 0],
-    [0.9510565162951535, 0.3090169943749474],
-    [0.8090169943749475, 0.5877852522924731],
-    [0.5877852522924731, 0.8090169943749475],
-    [0.30901699437494745, 0.9510565162951535],
-    [6.123233995736766e-17, 1]
+    [0.9238795325112867, 0.3826834323650898],
+    [0.7071067811865476, 0.7071067811865475],
+    [0.38268343236508984, 0.9238795325112867],
+    [0, 1]
   ]
   geometry = arc({ endAngle: TAU / 4, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 6)
+  t.is(obs.length, 5)
   t.true(comparePoints(obs, exp))
 
   // test makeTangent
   exp = [
     [1, 0],
-    [0.9957341762950345, 0.09226835946330199],
-    [0.8999557329057603, 0.43598128263728936],
-    [0.6896020498551045, 0.7241885202318785],
-    [0.391453692861967, 0.9201978082699006],
-    [0.04346855052920052, 0.9990547958520045],
-    [-0.31005066355011174, 0.9507200355689026],
-    [-0.6240966815770753, 0.781347126470996],
-    [-0.858687650595474, 0.5124992865505523],
-    [-0.9839573055048071, 0.1784040945262181],
-    [-0.9839573055048071, -0.1784040945262183],
-    [-0.8586876505954741, -0.5124992865505521],
-    [-0.6240966815770755, -0.7813471264709959],
-    [-0.3100506635501122, -0.9507200355689025],
-    [0.04346855052920005, -0.9990547958520045],
-    [0.39145369286196696, -0.9201978082699006],
-    [0.6896020498551043, -0.7241885202318787],
-    [0.8999557329057604, -0.435981282637289],
-    [0.9957341762950345, -0.09226835946330197]
+    [0.9951847266721969, 0.0980171403295606],
+    [0.8876396204028539, 0.46053871095824],
+    [0.6531728429537769, 0.7572088465064846],
+    [0.325310292162263, 0.9456073253805213],
+    [-0.04906767432741801, 0.9987954562051724],
+    [-0.416429560097637, 0.9091679830905225],
+    [-0.7242470829514668, 0.689540544737067],
+    [-0.9285060804732155, 0.3713171939518377],
+    [-1, 0],
+    [-0.9285060804732156, -0.37131719395183743],
+    [-0.724247082951467, -0.6895405447370668],
+    [-0.4164295600976372, -0.9091679830905224],
+    [-0.04906767432741803, -0.9987954562051724],
+    [0.3253102921622629, -0.9456073253805213],
+    [0.6531728429537768, -0.7572088465064846],
+    [0.8876396204028539, -0.46053871095823995],
+    [0.9951847266721969, -0.0980171403295605]
   ]
   geometry = arc({ makeTangent: true, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 19)
+  t.is(obs.length, 18)
   t.true(comparePoints(obs, exp))
 
   // test segments
   exp = [
     [1, 0],
-    [0.766044443118978, 0.6427876096865393],
-    [0.17364817766693041, 0.984807753012208],
-    [-0.4999999999999998, 0.8660254037844387],
-    [-0.9396926207859083, 0.3420201433256689],
-    [-0.9396926207859084, -0.34202014332566866],
-    [-0.5000000000000004, -0.8660254037844385],
-    [0.17364817766692997, -0.9848077530122081],
-    [0.7660444431189778, -0.6427876096865396]
+    [0.7071067811865476, 0.7071067811865475],
+    [0, 1],
+    [-0.7071067811865475, 0.7071067811865476],
+    [-1, 0],
+    [-0.7071067811865477, -0.7071067811865475],
+    [0, -1],
+    [0.7071067811865474, -0.7071067811865477]
   ]
   geometry = arc({ segments: 8 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 9)
+  t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 })
 
 test('arc (rotations)', (t) => {
   let exp = [
-    [6.123233995736766e-17, 1],
-    [-0.30901699437494734, 0.9510565162951536],
-    [-0.587785252292473, 0.8090169943749475],
-    [-0.8090169943749473, 0.5877852522924732],
-    [-0.9510565162951535, 0.3090169943749475],
-    [-1, 1.2246467991473532e-16]
+    [0, 1],
+    [-0.3826834323650897, 0.9238795325112867],
+    [-0.7071067811865475, 0.7071067811865476],
+    [-0.9238795325112867, 0.3826834323650899],
+    [-1, 0]
   ]
   let geometry = arc({ startAngle: TAU / 4, endAngle: TAU / 2, segments: 16 })
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 6)
+  t.is(obs.length, 5)
   t.true(comparePoints(obs, exp))
 
   exp = [
-    [-1, 1.2246467991473532e-16],
-    [-0.9396926207859084, -0.34202014332566866],
-    [-0.7660444431189781, -0.6427876096865393],
-    [-0.5000000000000004, -0.8660254037844385],
-    [-0.17364817766693033, -0.984807753012208],
-    [0.17364817766692997, -0.9848077530122081],
-    [0.49999999999999933, -0.866025403784439],
-    [0.7660444431189778, -0.6427876096865396],
-    [0.9396926207859084, -0.3420201433256686],
-    [1, -2.4492935982947064e-16]
+    [-1, 0],
+    [-0.9238795325112868, -0.38268343236508967],
+    [-0.7071067811865477, -0.7071067811865475],
+    [-0.38268343236509034, -0.9238795325112865],
+    [0, -1],
+    [0.38268343236509, -0.9238795325112866],
+    [0.7071067811865474, -0.7071067811865477],
+    [0.9238795325112865, -0.3826834323650904],
+    [1, 0]
   ]
   geometry = arc({ startAngle: TAU / 2, endAngle: TAU, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 10)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 
   exp = [
-    [-1.8369701987210297e-16, -1],
-    [0.34202014332566816, -0.9396926207859085],
-    [0.6427876096865393, -0.7660444431189781],
-    [0.8660254037844384, -0.5000000000000004],
-    [0.984807753012208, -0.1736481776669304],
-    [0.9848077530122081, 0.17364817766692991],
-    [0.866025403784439, 0.4999999999999993],
-    [0.6427876096865396, 0.7660444431189778],
-    [0.34202014332566866, 0.9396926207859084],
-    [3.061616997868383e-16, 1]
+    [0, -1],
+    [0.38268343236509, -0.9238795325112866],
+    [0.7071067811865474, -0.7071067811865477],
+    [0.9238795325112865, -0.3826834323650904],
+    [1, 0],
+    [0.9238795325112867, 0.38268343236508995],
+    [0.7071067811865477, 0.7071067811865474],
+    [0.38268343236509045, 0.9238795325112865],
+    [0, 1]
   ]
   geometry = arc({ startAngle: TAU * 0.75, endAngle: TAU / 4, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.is(obs.length, 10)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 
   exp = [[-1.8369701987210297e-16, -1]]

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')

package/src/primitives/ellipse.js

@@ -10,6 +10,7 @@ import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipse in two dimensional space.
+ *
  * @see https://en.wikipedia.org/wiki/Ellipse
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of ellipse
@@ -19,18 +20,18 @@ import { isGTE, isNumberArray } 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.ellipse
+ *
  * @example
  * let myshape = ellipse({radius: [5,10]})
  */
-export const ellipse = (options) => {
-  const defaults = {
-    center: [0, 0],
-    radius: [1, 1],
-    startAngle: 0,
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+export const ellipse = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = [1, 1],
+    startAngle = 0,
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(radius, 2)) throw new Error('radius must be an array of X and Y values')

package/src/primitives/ellipsoid.js

@@ -9,6 +9,7 @@ import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipsoid in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of ellipsoid
  * @param {Array} [options.radius=[1,1,1]] - radius of ellipsoid, along X, Y and Z
@@ -20,14 +21,13 @@ import { isGTE, isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = ellipsoid({radius: [5, 10, 20]})
 */
-export const ellipsoid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    radius: [1, 1, 1],
-    segments: 32,
-    axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
-  }
-  const { center, radius, segments, axes } = Object.assign({}, defaults, options)
+export const ellipsoid = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    radius = [1, 1, 1],
+    segments = 32,
+    axes = [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(radius, 3)) throw new Error('radius must be an array of X, Y and Z values')

package/src/primitives/geodesicSphere.js

@@ -8,6 +8,7 @@ import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a geodesic sphere based on icosahedron symmetry.
+ *
  * @param {object} [options] - options for construction
  * @param {number} [options.radius=1] - target radius of sphere
  * @param {number} [options.frequency=6] - subdivision frequency per face, multiples of 6
@@ -17,12 +18,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = geodesicSphere({radius: 15, frequency: 18})
  */
-export const geodesicSphere = (options) => {
-  const defaults = {
-    radius: 1,
-    frequency: 6
-  }
-  let { radius, frequency } = Object.assign({}, defaults, options)
+export const geodesicSphere = (options = {}) => {
+  let {
+    radius = 1,
+    frequency = 6
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(frequency, 6)) throw new Error('frequency must be six or more')

package/src/primitives/line.js

@@ -2,7 +2,9 @@ import * as path2 from '../geometries/path2/index.js'
 
 /**
  * Construct a new line in two dimensional space from the given points.
+ *
  * The points must be provided as an array, where each element is a 2D point.
+ *
  * @param {Array} points - array of points from which to create the path
  * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.line

package/src/primitives/polygon.js

@@ -24,13 +24,12 @@ import * as geom2 from '../geometries/geom2/index.js'
  * or
  * let poly = polygon({ points: [roof, wall], paths: [[0, 1, 2], [3, 4, 5, 6]] })
  */
-export const polygon = (options) => {
-  const defaults = {
-    points: [],
-    paths: [],
-    orientation: 'counterclockwise'
-  }
-  const { points, paths, orientation } = Object.assign({}, defaults, options)
+export const polygon = (options = {}) => {
+  const {
+    points = [],
+    paths = [],
+    orientation = 'counterclockwise'
+  } = options
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 

package/src/primitives/polyhedron.js

@@ -21,14 +21,13 @@ import { isNumberArray } from './commonChecks.js'
  * let myFaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
  * let myShape = polyhedron({points: myPoints, faces: myFaces, orientation: 'inward'})
  */
-export const polyhedron = (options) => {
-  const defaults = {
-    points: [],
-    faces: [],
-    colors: undefined,
-    orientation: 'outward'
-  }
-  const { points, faces, colors, orientation } = Object.assign({}, defaults, options)
+export const polyhedron = (options = {}) => {
+  const {
+    points = [],
+    faces = [],
+    colors = undefined,
+    orientation = 'outward'
+  } = options
 
   if (!(Array.isArray(points) && Array.isArray(faces))) {
     throw new Error('points and faces must be arrays')