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

package/src/primitives/roundedCuboid.js

@@ -151,7 +151,7 @@ export const roundedCuboid = (options) => {
 
   if (roundRadius > (size[0] - EPS) ||
       roundRadius > (size[1] - EPS) ||
-      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller then the radius of all dimensions')
+      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
 
   segments = Math.floor(segments / 4)
 

package/src/primitives/roundedCuboid.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { roundedCuboid } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -11,13 +13,17 @@ test('roundedCuboid (defaults)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 614)
+  t.is(measureArea(obs), 21.87859958298585)
+  t.is(measureVolume(obs), 7.800061070935406)
+  t.is(pts.length, 614)
 })
 
 test('roundedCuboid (zero size)', (t) => {
   const obs = roundedCuboid({ size: [1, 1, 0] })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -25,7 +31,9 @@ test('roundedCuboid (zero radius)', (t) => {
   const obs = roundedCuboid({ roundRadius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 6)
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
+  t.is(pts.length, 6)
 })
 
 test('roundedCuboid (options)', (t) => {
@@ -35,6 +43,8 @@ test('roundedCuboid (options)', (t) => {
   let exp = []
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 21.65472758198208)
+  t.is(measureVolume(obs), 7.734600480283937)
   t.is(pts.length, 62)
 
   // test center
@@ -44,6 +54,8 @@ test('roundedCuboid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 21.65472758198207)
+  t.is(measureVolume(obs), 7.73460048028392)
   t.is(pts.length, 62)
 
   // test size
@@ -144,7 +156,9 @@ test('roundedCuboid (options)', (t) => {
       [-3.8, 4.8, -6], [3.8, 4.8, -6]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 62)
+  t.is(measureArea(obs), 580.6448151876211)
+  t.is(measureVolume(obs), 958.6098905200406)
+  t.is(pts.length, 62)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // test roundRadius
@@ -243,6 +257,8 @@ test('roundedCuboid (options)', (t) => {
     [[2, -3, -6], [-2, -3, -6], [-2, 3, -6], [2, 3, -6]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 62)
+  t.is(measureArea(obs), 470.09666312772333)
+  t.is(measureVolume(obs), 835.1892253143822)
+  t.is(pts.length, 62)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/roundedCylinder.js

@@ -38,7 +38,7 @@ export const roundedCylinder = (options) => {
   if (!isGTE(height, 0)) throw new Error('height must be positive')
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
-  if (roundRadius > radius) throw new Error('roundRadius must be smaller then the radius')
+  if (roundRadius > radius) throw new Error('roundRadius must be smaller than the radius')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
   // if size is zero return empty geometry

package/src/primitives/roundedCylinder.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { roundedCylinder } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -11,6 +13,8 @@ test('roundedCylinder (defaults)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 16.844951865908268)
+  t.is(measureVolume(obs), 5.81870059177007)
   t.is(pts.length, 544)
 })
 
@@ -18,6 +22,8 @@ test('roundedCylinder (zero height)', (t) => {
   const obs = roundedCylinder({ height: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -25,6 +31,8 @@ test('roundedCylinder (zero radius)', (t) => {
   const obs = roundedCylinder({ radius: 0, roundRadius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -32,6 +40,8 @@ test('roundedCylinder (zero roundRadius)', (t) => {
   const obs = roundedCylinder({ roundRadius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 18.789084266699856)
+  t.is(measureVolume(obs), 6.2428903045161)
   t.is(pts.length, 96)
 })
 
@@ -43,6 +53,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 14.303000362787825)
+  t.is(measureVolume(obs), 4.121244903945666)
   t.is(pts.length, 15)
 
   // test center
@@ -72,6 +84,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 14.303000362787827)
+  t.is(measureVolume(obs), 4.121244903945658)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -102,6 +116,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 120.104345775433)
+  t.is(measureVolume(obs), 46.91878813722758)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -131,6 +147,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 569.7191848255909)
+  t.is(measureVolume(obs), 412.1244903945666)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -160,6 +178,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 602.8474323274462)
+  t.is(measureVolume(obs), 1030.3112259864165)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/roundedRectangle.js

@@ -45,7 +45,7 @@ export const roundedRectangle = (options) => {
   size = size.map((v) => v / 2) // convert to radius
 
   if (roundRadius > (size[0] - EPS) ||
-      roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller then the radius of all dimensions')
+      roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
 
   const cornerSegments = Math.floor(segments / 4)
 

package/src/primitives/roundedRectangle.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom2 } from '../geometries/index.js'
 
+import { measureArea } from '../measurements/index.js'
+
 import { roundedRectangle } from './index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
@@ -11,13 +13,15 @@ test('roundedRectangle (defaults)', (t) => {
   const obs = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 36)
+  t.is(measureArea(geometry), 3.964857806090323)
+  t.is(obs.length, 36)
 })
 
 test('roundedRectangle (zero size)', (t) => {
   const obs = roundedRectangle({ size: [1, 0] })
   const pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -25,7 +29,8 @@ test('roundedRectangle (zero radius)', (t) => {
   const obs = roundedRectangle({ roundRadius: 0 })
   const pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
-  t.deepEqual(pts.length, 4)
+  t.is(measureArea(obs), 4)
+  t.is(pts.length, 4)
 })
 
 test('roundedRectangle (options)', (t) => {
@@ -55,7 +60,8 @@ test('roundedRectangle (options)', (t) => {
     [5, 4.2]
   ]
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 20)
+  t.is(measureArea(geometry), 3.962458698356829)
+  t.is(obs.length, 20)
   t.true(comparePoints(obs, exp))
 
   // test size
@@ -84,7 +90,8 @@ test('roundedRectangle (options)', (t) => {
     [5, -2.8]
   ]
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 20)
+  t.is(measureArea(geometry), 59.96245869835682)
+  t.is(obs.length, 20)
   t.true(comparePoints(obs, exp))
 
   // test roundRadius
@@ -113,12 +120,14 @@ test('roundedRectangle (options)', (t) => {
     [5, -1.0000000000000004]
   ]
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 20)
+  t.is(measureArea(geometry), 56.24586983568288)
+  t.is(obs.length, 20)
   t.true(comparePoints(obs, exp))
 
   // test segments
   geometry = roundedRectangle({ size: [10, 6], roundRadius: 2, segments: 64 })
   obs = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 68)
+  t.is(measureArea(geometry), 56.546193962183764)
+  t.is(obs.length, 68)
 })

package/src/primitives/sphere.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { sphere } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -11,6 +13,8 @@ test('sphere (defaults)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 12.465694088650583)
+  t.is(measureVolume(obs), 4.121941740785839)
   t.is(pts.length, 512)
 })
 
@@ -20,6 +24,8 @@ test('sphere (options)', (t) => {
   let pts = geom3.toPoints(obs)
   let exp = []
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 296.5322084069296)
+  t.is(measureVolume(obs), 466.5063509461097)
   t.is(pts.length, 72)
   // t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -103,6 +109,8 @@ test('sphere (options)', (t) => {
       [0.4999999999999999, 0.5000000000000001, 0.7071067811865475]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 11.013439076647456)
+  t.is(measureVolume(obs), 3.2189514164974597)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -160,6 +168,8 @@ test('sphere (options)', (t) => {
     [[-3, 5, 8], [-2.2928932188134525, 5, 7.707106781186548], [-2.5, 5.5, 7.707106781186548]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 11.013439076647467)
+  t.is(measureVolume(obs), 3.218951416497485)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -168,5 +178,7 @@ test('sphere (zero radius)', (t) => {
   const obs = sphere({ radius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })

package/src/primitives/square.test.js

@@ -2,15 +2,18 @@ import test from 'ava'
 
 import { geom2 } from '../geometries/index.js'
 
+import { measureArea } from '../measurements/index.js'
+
 import { square } from './index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
 
 test('square (defaults)', (t) => {
   const geometry = square()
-  const obs = geom2.toPoints(geometry)
+  const pts = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 4)
+  t.is(measureArea(geometry), 4)
+  t.is(pts.length, 4)
 })
 
 test('square (options)', (t) => {
@@ -25,6 +28,7 @@ test('square (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 49)
   t.is(pts.length, 4)
   t.true(comparePoints(pts, exp))
 
@@ -39,13 +43,15 @@ test('square (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 49)
   t.is(pts.length, 4)
   t.true(comparePoints(pts, exp))
 })
 
 test('square (zero size)', (t) => {
   const geometry = square({ size: 0 })
-  const obs = geom2.toPoints(geometry)
+  const pts = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.is(obs.length, 0)
+  t.is(measureArea(geometry), 0)
+  t.is(pts.length, 0)
 })

package/src/primitives/star.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom2 } from '../geometries/index.js'
 
+import { measureArea } from '../measurements/index.js'
+
 import { star } from './index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
@@ -23,7 +25,8 @@ test('star (defaults)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 10)
+  t.is(measureArea(geometry), 1.1225699414489634)
+  t.is(pts.length, 10)
   t.true(comparePoints(pts, exp))
 })
 
@@ -45,7 +48,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 10)
+  t.is(measureArea(geometry), 28.06424853622408)
+  t.is(pts.length, 10)
   t.true(comparePoints(pts, exp))
 
   // test vertices
@@ -71,7 +75,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 58.5786437626905)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test density
@@ -97,7 +102,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 41.42135623730952)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test innerRadius
@@ -123,7 +129,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 15.30733729460359)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test start angle
@@ -143,6 +150,7 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 10)
+  t.is(measureArea(geometry), 28.06424853622409)
+  t.is(pts.length, 10)
   t.true(comparePoints(pts, exp))
 })

package/src/primitives/torus.js

@@ -43,7 +43,7 @@ export const torus = (options) => {
   if (!isGTE(startAngle, 0)) throw new Error('startAngle must be positive')
   if (!isGT(outerRotation, 0)) throw new Error('outerRotation must be greater than zero')
 
-  if (innerRadius >= outerRadius) throw new Error('inner circle is two large to rotate about the outer circle')
+  if (innerRadius >= outerRadius) throw new Error('inner circle is too large to rotate about the outer circle')
 
   let innerCircle = circle({ radius: innerRadius, segments: innerSegments })
 

package/src/primitives/torus.test.js

@@ -4,7 +4,7 @@ import { TAU } from '../maths/constants.js'
 
 import { geom3 } from '../geometries/index.js'
 
-import { measureBoundingBox } from '../measurements/index.js'
+import { measureArea, measureBoundingBox, measureVolume } from '../measurements/index.js'
 
 import { torus } from './index.js'
 
@@ -15,6 +15,8 @@ test('torus (defaults)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 157.0282327749074)
+  t.is(measureVolume(obs), 77.94735870844194)
   t.is(pts.length, 2048) // 32 * 32 * 2 (polys/segment) = 2048
 
   const bounds = measureBoundingBox(obs)
@@ -26,6 +28,8 @@ test('torus (simple options)', (t) => {
   const obs = torus({ innerRadius: 0.5, innerSegments: 4, outerRadius: 5, outerSegments: 8 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 83.36086132479792)
+  t.is(measureVolume(obs), 14.14213562373095)
   t.is(pts.length, 64) // 4 * 8 * 2 (polys/segment) = 64
 
   const bounds = measureBoundingBox(obs)
@@ -37,6 +41,8 @@ test('torus (complex options)', (t) => {
   const obs = torus({ innerRadius: 1, outerRadius: 5, innerSegments: 32, outerSegments: 72, startAngle: TAU / 4, outerRotation: TAU / 4 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 55.472610544494)
+  t.is(measureVolume(obs), 24.484668362201525)
   t.is(pts.length, 1212)
 
   const bounds = measureBoundingBox(obs)
@@ -48,6 +54,8 @@ test('torus (startAngle)', (t) => {
   const obs = torus({ startAngle: 1, endAngle: 1 + TAU })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 157.0282327749074)
+  t.is(measureVolume(obs), 77.94735870844195)
   t.is(pts.length, 2048)
 })
 
@@ -57,5 +65,7 @@ test('torus (square by square)', (t) => {
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 110.85125168440814)
+  t.is(measureVolume(obs), 32)
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })

package/src/primitives/triangle.test.js

@@ -1,11 +1,13 @@
 import test from 'ava'
 
-import { TAU } from '../maths/constants.js'
-
 import { degToRad } from '../utils/index.js'
 
 import { geom2 } from '../geometries/index.js'
 
+import { TAU } from '../maths/constants.js'
+
+import { measureArea } from '../measurements/index.js'
+
 import { triangle } from './index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
@@ -20,7 +22,8 @@ test('triangle (defaults)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 0.43301270189221935)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 })
 
@@ -35,7 +38,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 20.33316256758894)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test AAA
@@ -48,7 +52,7 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test AAS
@@ -61,7 +65,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 15.796947276180953)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test ASA
@@ -74,7 +79,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 23.384870895211314)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test SAS
@@ -87,7 +93,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 13.207417653898512)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test SSA
@@ -100,6 +107,7 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 51.962298292283386)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 })

package/src/utils/coalesce.d.ts

@@ -0,0 +1,3 @@
+import type { RecursiveArray } from './recursiveArray.d.ts'
+
+export function coalesce<T>(arr: RecursiveArray<T>): Array<T>

package/src/utils/coalesce.js

@@ -0,0 +1,20 @@
+/**
+ * Flattens and filters out nullish values from the given list of arguments.
+ * The arguments can be composed of multiple depths of objects and arrays.
+ * The output is a single flat array with no missing values.
+ * @param {Array} arr - list of arguments
+ * @returns {Array} a flat list of arguments
+ * @alias module:modeling/utils.coalesce
+ */
+export const coalesce = (arr) => flattenHelper(arr, [])
+
+// Helper to recursively append to a given list.
+// This is MUCH faster than other flatten methods.
+const flattenHelper = (arr, out) => {
+  if (Array.isArray(arr)) {
+    arr.forEach((child) => flattenHelper(child, out))
+  } else if (arr != null && arr !== undefined) {
+    out.push(arr)
+  }
+  return out
+}

package/src/utils/index.js

@@ -1,8 +1,8 @@
 /**
- * Utility functions of various sorts.
+ * Utility functions of various sorts, including conversions from different angular measures.
  * @module modeling/utils
  * @example
- * import { degToRad } from '@jscad/modeling'
+ * import { degToRad, flatten, radiusToSegments, radToDeg } from '@jscad/modeling'
  */
 export { degToRad } from './degToRad.js'
 export { flatten } from './flatten.js'

package/src/maths/mat4/leftMultiplyVec2.d.ts

@@ -1,4 +0,0 @@
-import type { Mat4 } from './type.d.ts'
-import type { Vec2 } from '../vec2/type.d.ts'
-
-export function leftMultiplyVec2(vector: Vec2, matrix: Mat4): Vec2

package/src/maths/mat4/leftMultiplyVec2.js

@@ -1,26 +0,0 @@
-import { fromValues } from '../vec2/index.js'
-
-/*
- * Multiply the input matrix by a Vector2 (interpreted as 2 column, 1 row)
- * (result = v*M)
- * Fourth element is set to 1
- * @param {Vec2} vector the input vector
- * @param {Mat4} matrix the input matrix
- * @returns {Vec2} output
- */
-export const leftMultiplyVec2 = (vector, matrix) => {
-  const [v0, v1] = vector
-  const v2 = 0
-  const v3 = 1
-  let x = v0 * matrix[0] + v1 * matrix[4] + v2 * matrix[8] + v3 * matrix[12]
-  let y = v0 * matrix[1] + v1 * matrix[5] + v2 * matrix[9] + v3 * matrix[13]
-  const w = v0 * matrix[3] + v1 * matrix[7] + v2 * matrix[11] + v3 * matrix[15]
-
-  // scale such that fourth element becomes 1:
-  if (w !== 1) {
-    const invw = 1.0 / w
-    x *= invw
-    y *= invw
-  }
-  return fromValues(x, y)
-}

package/src/maths/mat4/leftMultiplyVec3.d.ts

@@ -1,4 +0,0 @@
-import type { Mat4 } from './type.d.ts'
-import type { Vec3 } from '../vec3/type.d.ts'
-
-export function leftMultiplyVec3(vector: Vec3, matrix: Mat4): Vec3

package/src/maths/mat4/leftMultiplyVec3.js

@@ -1,27 +0,0 @@
-import { fromValues } from '../vec3/index.js'
-
-/*
- * Multiply the input matrix by a Vector3 (interpreted as 3 column, 1 row)
- * (result = v*M)
- * Fourth element is set to 1
- * @param {Vec3} vector the input vector
- * @param {Mat4} matrix the input matrix
- * @returns {Vec3} output
- */
-export const leftMultiplyVec3 = (vector, matrix) => {
-  const [v0, v1, v2] = vector
-  const v3 = 1
-  let x = v0 * matrix[0] + v1 * matrix[4] + v2 * matrix[8] + v3 * matrix[12]
-  let y = v0 * matrix[1] + v1 * matrix[5] + v2 * matrix[9] + v3 * matrix[13]
-  let z = v0 * matrix[2] + v1 * matrix[6] + v2 * matrix[10] + v3 * matrix[14]
-  const w = v0 * matrix[3] + v1 * matrix[7] + v2 * matrix[11] + v3 * matrix[15]
-
-  // scale such that fourth element becomes 1:
-  if (w !== 1) {
-    const invw = 1.0 / w
-    x *= invw
-    y *= invw
-    z *= invw
-  }
-  return fromValues(x, y, z)
-}