@jscad/modeling 2.12.6 → 2.13.0

package/src/primitives/arc.js

@@ -60,8 +60,8 @@ const arc = (options) => {
     vec2.add(point, point, centerv)
     pointArray.push(point)
   } else {
-    // note: add one additional step to acheive 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

@@ -12,7 +12,7 @@ test('arc (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 33)
+  t.deepEqual(obs.length, 32)
 })
 
 test('arc (options)', (t) => {
@@ -40,184 +40,195 @@ test('arc (options)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
-  t.true(comparePoints(obs, exp))
+  t.deepEqual(obs.length, 16)
+//console.log(obs)
+  //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]
+  [ 2, 0 ],
+  [ 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.deepEqual(obs.length, 17)
+  t.is(geometry.isClosed, true)
+
+  obs = path2.toPoints(geometry)
+  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.deepEqual(obs.length, 14)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  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]
+    [ 1, 0 ],
+    [ 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.deepEqual(obs.length, 6)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  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]
+  [ 1, 0 ],
+  [ 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.deepEqual(obs.length, 19)
+  t.is(geometry.isClosed, true)
+
+  obs = path2.toPoints(geometry)
+  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.deepEqual(obs.length, 9)
+  t.is(geometry.isClosed, true)
+
+  obs = path2.toPoints(geometry)
+  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.deepEqual(obs.length, 6)
+  t.is(geometry.isClosed, false)
+
+  let obs = path2.toPoints(geometry)
+  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.deepEqual(obs.length, 10)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  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.deepEqual(obs.length, 10)
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 
-  exp = [[-1.8369701987210297e-16, -1]]
+  exp = [[0, -1]]
   geometry = arc({ startAngle: TAU * 0.75, endAngle: 270.000000005 * 0.017453292519943295, segments: 16 })
-  obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
+  t.is(geometry.isClosed, false)
+
+  obs = path2.toPoints(geometry)
   t.deepEqual(obs.length, 1)
   t.true(comparePoints(obs, exp))
 })

package/src/utils/flatten.js

@@ -5,6 +5,6 @@
  * @returns {Array} a flat list of arguments
  * @alias module:modeling/utils.flatten
  */
-const flatten = (arr) => arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
+const flatten = (arr) => arr.flat(Infinity)
 
 module.exports = flatten

package/src/utils/flatten.test.js

@@ -0,0 +1,94 @@
+const test = require('ava')
+
+const flatten = require('./flatten')
+
+test('flatten: test an empty array returns empty.', (t) => {
+  t.deepEqual(flatten([]), [])
+})
+
+test('flatten: test a flat array is unchanged.', (t) => {
+  t.deepEqual(flatten([1, 2, 3]), [1, 2, 3])
+})
+
+test('flatten: test single level nesting is flattened.', (t) => {
+  t.deepEqual(flatten([1, [2, 3], 4]), [1, 2, 3, 4])
+  t.deepEqual(flatten([[1, 2], [3, 4]]), [1, 2, 3, 4])
+  t.deepEqual(flatten([[1], [2], [3]]), [1, 2, 3])
+})
+
+test('flatten: test deep nesting is flattened.', (t) => {
+  t.deepEqual(flatten([1, [2, [3, [4]]]]), [1, 2, 3, 4])
+  t.deepEqual(flatten([[[[1]]]]), [1])
+  t.deepEqual(flatten([1, [2, [3, [4, [5]]]]]), [1, 2, 3, 4, 5])
+})
+
+test('flatten: test mixed nesting depths are flattened.', (t) => {
+  t.deepEqual(flatten([1, [2, 3], [[4, 5]], [[[6]]]]), [1, 2, 3, 4, 5, 6])
+})
+
+test('flatten: test empty nested arrays are removed.', (t) => {
+  t.deepEqual(flatten([[]]), [])
+  t.deepEqual(flatten([[], []]), [])
+  t.deepEqual(flatten([1, [], 2]), [1, 2])
+  t.deepEqual(flatten([[], [1], []]), [1])
+})
+
+test('flatten: test single element arrays are flattened.', (t) => {
+  t.deepEqual(flatten([1]), [1])
+  t.deepEqual(flatten([[1]]), [1])
+  t.deepEqual(flatten([[[1]]]), [1])
+})
+
+test('flatten: test element order is preserved.', (t) => {
+  t.deepEqual(flatten([1, [2, 3], 4, [5, 6]]), [1, 2, 3, 4, 5, 6])
+  t.deepEqual(flatten([[1, 2], 3, [4, [5, 6]]]), [1, 2, 3, 4, 5, 6])
+})
+
+test('flatten: test object references are preserved.', (t) => {
+  const obj1 = { id: 1 }
+  const obj2 = { id: 2 }
+  const obj3 = { id: 3 }
+  const result = flatten([obj1, [obj2, obj3]])
+  t.is(result[0], obj1)
+  t.is(result[1], obj2)
+  t.is(result[2], obj3)
+})
+
+test('flatten: test various types are preserved.', (t) => {
+  const obj = { a: 1 }
+  const fn = () => {}
+  t.deepEqual(flatten([1, 'string', null, undefined, true]), [1, 'string', null, undefined, true])
+
+  const result = flatten([obj, [fn]])
+  t.is(result[0], obj)
+  t.is(result[1], fn)
+})
+
+test('flatten: test large flat array is unchanged.', (t) => {
+  const large = []
+  for (let i = 0; i < 1000; i++) {
+    large.push(i)
+  }
+  const result = flatten(large)
+  t.is(result.length, 1000)
+  t.is(result[0], 0)
+  t.is(result[999], 999)
+})
+
+test('flatten: test large nested array is flattened.', (t) => {
+  const nested = []
+  for (let i = 0; i < 100; i++) {
+    nested.push([i * 10, i * 10 + 1, i * 10 + 2])
+  }
+  const result = flatten(nested)
+  t.is(result.length, 300)
+  t.is(result[0], 0)
+  t.is(result[3], 10)
+})
+
+test('flatten: test input array is not modified.', (t) => {
+  const input = [1, [2, 3], 4]
+  const inputCopy = JSON.stringify(input)
+  flatten(input)
+  t.is(JSON.stringify(input), inputCopy)
+})