@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/operations/booleans/unionGeom3.test.js

@@ -1,14 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { geom3 } = require('../../geometries')
+import { geom3 } from '../../geometries/index.js'
 
-const { sphere, cuboid } = require('../../primitives')
+import { measureVolume } from '../../measurements/index.js'
 
-const { union } = require('./index')
+import { sphere, cuboid } from '../../primitives/index.js'
 
-const { center } = require('../transforms/center')
+import { center } from '../transforms/index.js'
+
+import { union } from './index.js'
 
 test('union of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
@@ -67,6 +69,8 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[8.65956056235493e-17, 8.659560562354935e-17, 2], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095]]
   ]
   t.notThrows.skip(() => geom3.validate(result1))
+  t.is(measureVolume(result1), 25.751611331979678)
+  t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // union of two non-overlapping objects
@@ -75,6 +79,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
   const result2 = union(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows.skip(() => geom3.validate(result2))
+  t.is(measureVolume(result2), 89.75161133197969)
   t.is(obs.length, 38)
 
   // union of two partially overlapping objects
@@ -103,6 +108,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, 8, 9], [-9, -9, 9], [9, -9, 9], [9, 8, 9]]
   ]
   t.notThrows.skip(() => geom3.validate(result3))
+  t.is(measureVolume(result3), 5895)
   t.is(obs.length, 18)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -118,6 +124,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, -9, 9], [9, -9, 9], [9, 9, 9], [-9, 9, 9]]
   ]
   t.notThrows(() => geom3.validate(result4))
+  t.is(measureVolume(result4), 5832)
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
 })
@@ -126,8 +133,9 @@ test('union of geom3 with rounding issues #137', (t) => {
   const geometry1 = center({ relativeTo: [0, 0, -1] }, cuboid({ size: [44, 26, 5] }))
   const geometry2 = center({ relativeTo: [0, 0, -4.400001] }, cuboid({ size: [44, 26, 1.8] })) // introduce precision error
 
-  const obs = union(geometry1, geometry2)
-  const pts = geom3.toPoints(obs)
-  t.notThrows(() => geom3.validate(obs))
+  const result = union(geometry1, geometry2)
+  const pts = geom3.toPoints(result)
+  t.notThrows(() => geom3.validate(result))
+  t.is(measureVolume(result), 7779.201144000001)
   t.is(pts.length, 6) // number of polygons in union
 })

package/src/operations/booleans/unionGeom3Sub.js

@@ -1,15 +1,16 @@
-const geom3 = require('../../geometries/geom3')
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const mayOverlap = require('./mayOverlap')
-const { Tree } = require('./trees')
+import { Tree } from './trees/index.js'
+
+import { mayOverlap } from './mayOverlap.js'
 
 /*
  * Return a new 3D geometry representing the space in the given geometries.
- * @param {geom3} geometry1 - geometry to union
- * @param {geom3} geometry2 - geometry to union
- * @returns {geom3} new 3D geometry
+ * @param {Geom3} geometry1 - geometry to union
+ * @param {Geom3} geometry2 - geometry to union
+ * @returns {Geom3} new 3D geometry
  */
-const unionSub = (geometry1, geometry2) => {
+export const unionGeom3Sub = (geometry1, geometry2) => {
   if (!mayOverlap(geometry1, geometry2)) {
     return unionForNonIntersecting(geometry1, geometry2)
   }
@@ -24,9 +25,8 @@ const unionSub = (geometry1, geometry2) => {
   b.clipTo(a)
   b.invert()
 
-  const newpolygons = a.allPolygons().concat(b.allPolygons())
-  const result = geom3.create(newpolygons)
-  return result
+  const newPolygons = a.allPolygons().concat(b.allPolygons())
+  return geom3.create(newPolygons)
 }
 
 // Like union, but when we know that the two solids are not intersecting
@@ -36,5 +36,3 @@ const unionForNonIntersecting = (geometry1, geometry2) => {
   newpolygons = newpolygons.concat(geom3.toPolygons(geometry2))
   return geom3.create(newpolygons)
 }
-
-module.exports = unionSub

package/src/operations/extrusions/extrudeFromSlices.d.ts

@@ -1,8 +1,5 @@
-import Geom3 from '../../geometries/geom3/type'
-
-import Slice from './slice/type'
-
-export default extrudeFromSlices
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { Slice } from '../../geometries/slice/type.d.ts'
 
 export interface ExtrudeFromSlicesOptions<Base> {
   numberOfSlices?: number
@@ -12,4 +9,4 @@ export interface ExtrudeFromSlicesOptions<Base> {
   callback?: (progress: number, index: number, base: Base) => Slice
 }
 
-declare function extrudeFromSlices<Base>(options: ExtrudeFromSlicesOptions<Base>, base: Base): Geom3
+export function extrudeFromSlices<Base>(options: ExtrudeFromSlicesOptions<Base>, base: Base): Geom3

package/src/operations/extrusions/extrudeFromSlices.js

@@ -1,18 +1,16 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as poly3 from '../../geometries/poly3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
-const slice = require('./slice')
-const repairSlice = require('./slice/repair')
-
-const extrudeWalls = require('./extrudeWalls')
+import { extrudeWalls } from './extrudeWalls.js'
 
 const defaultCallback = (progress, index, base) => {
   let baseSlice = null
-  if (geom2.isA(base)) baseSlice = slice.fromSides(geom2.toSides(base))
-  if (poly3.isA(base)) baseSlice = slice.fromPoints(poly3.toPoints(base))
+  if (geom2.isA(base)) baseSlice = slice.fromGeom2(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
 }
@@ -21,15 +19,15 @@ const defaultCallback = (progress, index, base) => {
  * Extrude a solid from the slices as returned by the callback function.
  * @see slice
  *
- * @param {Object} options - options for extrude
- * @param {Integer} [options.numberOfSlices=2] the number of slices to be generated by the callback
- * @param {Boolean} [options.capStart=true] the solid should have a cap at the start
- * @param {Boolean} [options.capEnd=true] the solid should have a cap at the end
- * @param {Boolean} [options.close=false] the solid should have a closing section between start and end
- * @param {Boolean} [options.repair=true] - repair gaps in the geometry
+ * @param {object} options - options for extrude
+ * @param {number} [options.numberOfSlices=2] the number of slices to be generated by the callback
+ * @param {boolean} [options.capStart=true] the solid should have a cap at the start
+ * @param {boolean} [options.capEnd=true] the solid should have a cap at the end
+ * @param {boolean} [options.close=false] the solid should have a closing section between start and end
+ * @param {boolean} [options.repair=true] - repair gaps in the geometry
  * @param {Function} [options.callback] the callback function that generates each slice
- * @param {Object} base - the base object which is used to create slices (see the example for callback information)
- * @return {geom3} the extruded shape
+ * @param {object} base - the base object which is used to create slices (see the example for callback information)
+ * @return {Geom3} the extruded shape
  * @alias module:modeling/extrusions.extrudeFromSlices
  *
  * @example
@@ -44,25 +42,18 @@ const defaultCallback = (progress, index, base) => {
  *   return slice
  * }
  */
-const extrudeFromSlices = (options, base) => {
+export const extrudeFromSlices = (options, base) => {
   const defaults = {
     numberOfSlices: 2,
     capStart: true,
     capEnd: true,
     close: false,
-    repair: true,
     callback: defaultCallback
   }
-  const { numberOfSlices, capStart, capEnd, close, repair, callback: generate } = Object.assign({ }, defaults, options)
+  const { numberOfSlices, capStart, capEnd, close, callback: generate } = Object.assign({ }, defaults, options)
 
   if (numberOfSlices < 2) throw new Error('numberOfSlices must be 2 or more')
 
-  // Repair gaps in the base slice
-  if (repair) {
-    // note: base must be a slice, if base is geom2 this doesn't repair
-    base = repairSlice(base)
-  }
-
   const sMax = numberOfSlices - 1
 
   let startSlice = null
@@ -77,8 +68,7 @@ const extrudeFromSlices = (options, base) => {
     if (currentSlice) {
       if (!slice.isA(currentSlice)) throw new Error('the callback function must return slice objects')
 
-      const edges = slice.toEdges(currentSlice)
-      if (edges.length === 0) throw new Error('the callback function must return slices with one or more edges')
+      if (currentSlice.contours.length === 0) throw new Error('the callback function must return slices with one or more contours')
 
       if (prevSlice) {
         polygons = polygons.concat(extrudeWalls(prevSlice, currentSlice))
@@ -110,5 +100,3 @@ const extrudeFromSlices = (options, base) => {
   }
   return geom3.create(polygons)
 }
-
-module.exports = extrudeFromSlices

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

@@ -1,43 +1,46 @@
-const test = require('ava')
+import test from 'ava'
 
-const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { TAU } = require('../../maths/constants')
-const mat4 = require('../../maths/mat4')
+import { TAU } from '../../maths/constants.js'
+import { mat4 } from '../../maths/index.js'
 
-const { geom2, geom3, poly3 } = require('../../geometries')
+import { geom2, geom3, poly3, slice } from '../../geometries/index.js'
 
-const { circle } = require('../../primitives')
+import { measureVolume } from '../../measurements/index.js'
 
-const { extrudeFromSlices, slice } = require('./index')
+import { circle, square } from '../../primitives/index.js'
+
+import { extrudeFromSlices } from './index.js'
 
 test('extrudeFromSlices (defaults)', (t) => {
-  const geometry2 = geom2.fromPoints([[10, 10], [-10, 10], [-10, -10], [10, -10]])
+  const geometry2 = square({ size: 20 })
 
   let geometry3 = extrudeFromSlices({ }, geometry2)
   let pts = geom3.toPoints(geometry3)
   const exp = [
+    [[-10, -10, 0], [10, -10, 0], [10, -10, 1]],
+    [[-10, -10, 0], [10, -10, 1], [-10, -10, 1]],
     [[10, -10, 0], [10, 10, 0], [10, 10, 1]],
     [[10, -10, 0], [10, 10, 1], [10, -10, 1]],
     [[10, 10, 0], [-10, 10, 0], [-10, 10, 1]],
     [[10, 10, 0], [-10, 10, 1], [10, 10, 1]],
     [[-10, 10, 0], [-10, -10, 0], [-10, -10, 1]],
     [[-10, 10, 0], [-10, -10, 1], [-10, 10, 1]],
-    [[-10, -10, 0], [10, -10, 0], [10, -10, 1]],
-    [[-10, -10, 0], [10, -10, 1], [-10, -10, 1]],
-    [[-10, -10, 1], [10, -10, 1], [10, 10, 1]],
     [[10, 10, 1], [-10, 10, 1], [-10, -10, 1]],
-    [[10, 10, 0], [10, -10, 0], [-10, -10, 0]],
-    [[-10, -10, 0], [-10, 10, 0], [10, 10, 0]]
+    [[-10, -10, 1], [10, -10, 1], [10, 10, 1]],
+    [[-10, -10, 0], [-10, 10, 0], [10, 10, 0]],
+    [[10, 10, 0], [10, -10, 0], [-10, -10, 0]]
   ]
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  const poly2 = poly3.create([[10, 10, 0], [-10, 10, 0], [-10, -10, 0], [10, -10, 0]])
+  const poly2 = poly3.create([[-10, -10, 0], [10, -10, 0], [10, 10, 0], [-10, 10, 0]])
   geometry3 = extrudeFromSlices({ }, poly2)
   pts = geom3.toPoints(geometry3)
 
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 400.00000000000006)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -55,7 +58,7 @@ test('extrudeFromSlices (torus)', (t) => {
     [radius / 2, -radius * sqrt3, 0]
   ])
   hex = poly3.transform(mat4.fromTranslation(mat4.create(), [0, 20, 0]), hex)
-  hex = slice.fromPoints(poly3.toPoints(hex))
+  hex = slice.fromVertices(poly3.toVertices(hex))
 
   const angle = TAU / 8
   const geometry3 = extrudeFromSlices(
@@ -71,26 +74,28 @@ test('extrudeFromSlices (torus)', (t) => {
   )
   const pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 29393.876913398108)
   t.is(pts.length, 96)
 })
 
 test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
-  const base = slice.fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]])
+  const base = slice.fromVertices([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]])
   const geometry3 = extrudeFromSlices(
     {
       numberOfSlices: 4,
       capStart: true,
       capEnd: false,
       callback: function (progress, count, base) {
-        let newslice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 2]), base)
-        newslice = slice.transform(mat4.fromScaling(mat4.create(), [1 + count, 1 + (count / 2), 1]), newslice)
-        return newslice
+        let newSlice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 2]), base)
+        newSlice = slice.transform(mat4.fromScaling(mat4.create(), [1 + count, 1 + (count / 2), 1]), newSlice)
+        return newSlice
       }
     }, base
   )
   const pts = geom3.toPoints(geometry3)
   // expected to throw because capEnd is false (non-closed geometry)
   t.throws(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 8.5)
   t.is(pts.length, 26)
 })
 
@@ -100,31 +105,24 @@ 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.fromSides(geom2.toSides(newshape))
-        newslice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 10]), newslice)
-        return newslice
+        const newShape = circle({ radius: 5 + count, segments: 4 + count })
+        let newSlice = slice.fromGeom2(newShape)
+        newSlice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 10]), newSlice)
+        return newSlice
       }
     }, base
   )
   const pts = geom3.toPoints(geometry3)
   t.notThrows.skip(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 5260.067107417433)
   t.is(pts.length, 304)
 })
 
 test('extrudeFromSlices (holes)', (t) => {
-  const geometry2 = geom2.create(
-    [
-      [[-10, 10], [-10, -10]],
-      [[-10, -10], [10, -10]],
-      [[10, -10], [10, 10]],
-      [[10, 10], [-10, 10]],
-      [[-5, -5], [-5, 5]],
-      [[5, -5], [-5, -5]],
-      [[5, 5], [5, -5]],
-      [[-5, 5], [5, 5]]
-    ]
-  )
+  const geometry2 = geom2.create([
+    [[-10, 10], [-10, -10], [10, -10], [10, 10]],
+    [[-5, -5], [-5, 5], [5, 5], [5, -5]]
+  ])
   const geometry3 = extrudeFromSlices({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
   const exp = [
@@ -138,30 +136,31 @@ test('extrudeFromSlices (holes)', (t) => {
     [[10, 10, 0], [-10, 10, 1], [10, 10, 1]],
     [[-5, -5, 0], [-5, 5, 0], [-5, 5, 1]],
     [[-5, -5, 0], [-5, 5, 1], [-5, -5, 1]],
-    [[5, -5, 0], [-5, -5, 0], [-5, -5, 1]],
-    [[5, -5, 0], [-5, -5, 1], [5, -5, 1]],
-    [[5, 5, 0], [5, -5, 0], [5, -5, 1]],
-    [[5, 5, 0], [5, -5, 1], [5, 5, 1]],
     [[-5, 5, 0], [5, 5, 0], [5, 5, 1]],
     [[-5, 5, 0], [5, 5, 1], [-5, 5, 1]],
-    [[10, -10, 1], [10, 10, 1], [5, 5, 1]],
+    [[5, 5, 0], [5, -5, 0], [5, -5, 1]],
+    [[5, 5, 0], [5, -5, 1], [5, 5, 1]],
+    [[5, -5, 0], [-5, -5, 0], [-5, -5, 1]],
+    [[5, -5, 0], [-5, -5, 1], [5, -5, 1]],
     [[-5, 5, 1], [5, 5, 1], [10, 10, 1]],
-    [[10, -10, 1], [5, 5, 1], [5, -5, 1]],
+    [[10, -10, 1], [10, 10, 1], [5, 5, 1]],
     [[-5, 5, 1], [10, 10, 1], [-10, 10, 1]],
-    [[-10, -10, 1], [10, -10, 1], [5, -5, 1]],
+    [[10, -10, 1], [5, 5, 1], [5, -5, 1]],
     [[-5, -5, 1], [-5, 5, 1], [-10, 10, 1]],
-    [[-10, -10, 1], [5, -5, 1], [-5, -5, 1]],
+    [[-10, -10, 1], [10, -10, 1], [5, -5, 1]],
     [[-5, -5, 1], [-10, 10, 1], [-10, -10, 1]],
-    [[5, 5, 0], [10, 10, 0], [10, -10, 0]],
+    [[-10, -10, 1], [5, -5, 1], [-5, -5, 1]],
     [[10, 10, 0], [5, 5, 0], [-5, 5, 0]],
-    [[5, -5, 0], [5, 5, 0], [10, -10, 0]],
+    [[5, 5, 0], [10, 10, 0], [10, -10, 0]],
     [[-10, 10, 0], [10, 10, 0], [-5, 5, 0]],
-    [[5, -5, 0], [10, -10, 0], [-10, -10, 0]],
+    [[5, -5, 0], [5, 5, 0], [10, -10, 0]],
     [[-10, 10, 0], [-5, 5, 0], [-5, -5, 0]],
-    [[-5, -5, 0], [5, -5, 0], [-10, -10, 0]],
-    [[-10, -10, 0], [-10, 10, 0], [-5, -5, 0]]
+    [[5, -5, 0], [10, -10, 0], [-10, -10, 0]],
+    [[-10, -10, 0], [-10, 10, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [5, -5, 0], [-10, -10, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 300)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/operations/extrusions/extrudeHelical.d.ts

@@ -1,6 +1,4 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-
-export default extrudeHelical
+import type { Geom2, Geom3 } from '../../geometries/types.d.ts'
 
 export interface ExtrudeHelicalOptions {
   angle?: number
@@ -11,4 +9,4 @@ export interface ExtrudeHelicalOptions {
   segmentsPerRotation?: number
 }
 
-declare function extrudeHelical(options: ExtrudeHelicalOptions, geometry: Geom2): Geom3
+export function extrudeHelical(options: ExtrudeHelicalOptions, geometry: Geom2): Geom3

package/src/operations/extrusions/extrudeHelical.js

@@ -1,21 +1,21 @@
-const { TAU } = require('../../maths/constants')
-const slice = require('./slice')
-const mat4 = require('../../maths/mat4')
-const extrudeFromSlices = require('./extrudeFromSlices')
-const geom2 = require('../../geometries/geom2')
+import { TAU } from '../../maths/constants.js'
+import * as slice from '../../geometries/slice/index.js'
+import * as mat4 from '../../maths/mat4/index.js'
+import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
+import { extrudeFromSlices } from './extrudeFromSlices.js'
 
 /**
  * Perform a helical extrude of the geometry, using the given options.
  *
- * @param {Object} options - options for extrusion
- * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS) positive for right-hand rotation, negative for left-hand
- * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
- * @param {Number} [options.pitch=10] - elevation gain for each turn
- * @param {Number} [options.height] - total height of the helix path. Ignored if pitch is set.
- * @param {Number} [options.endOffset=0] - offset the final radius of the extrusion, allowing for tapered helix, and or spiral
- * @param {Number} [options.segmentsPerRotation=32] - number of segments per full rotation of the extrusion
- * @param {geom2} geometry - the geometry to extrude
- * @returns {geom3} the extruded geometry
+ * @param {object} options - options for extrusion
+ * @param {number} [options.angle=TAU] - angle of the extrusion (RADIANS) positive for right-hand rotation, negative for left-hand
+ * @param {number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
+ * @param {number} [options.pitch=10] - elevation gain for each turn
+ * @param {number} [options.height] - total height of the helix path. Ignored if pitch is set.
+ * @param {number} [options.endOffset=0] - offset the final radius of the extrusion, allowing for tapered helix, and or spiral
+ * @param {number} [options.segmentsPerRotation=32] - number of segments per full rotation of the extrusion
+ * @param {Geom2} geometry - the geometry to extrude
+ * @returns {Geom3} the extruded geometry
  * @alias module:modeling/extrusions.extrudeHelical
  *
  * @example
@@ -28,7 +28,7 @@ const geom2 = require('../../geometries/geom2')
  *  circle({size: 3, center: [10, 0]})
  * )
  */
-const extrudeHelical = (options, geometry) => {
+export const extrudeHelical = (options, geometry) => {
   const defaults = {
     angle: TAU,
     startAngle: 0,
@@ -40,7 +40,7 @@ const extrudeHelical = (options, geometry) => {
 
   let pitch
   // ignore height if pitch is set
-  if(!options.pitch && options.height) {
+  if (!options.pitch && options.height) {
     pitch = options.height / (angle / TAU)
   } else {
     pitch = options.pitch ? options.pitch : defaults.pitch
@@ -49,18 +49,12 @@ const extrudeHelical = (options, geometry) => {
   // needs at least 3 segments for each revolution
   const minNumberOfSegments = 3
 
-  if (segmentsPerRotation < minNumberOfSegments)
-    throw new Error(`The number of segments per rotation needs to be at least 3.`)
+  if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
-  let shapeSides = geom2.toSides(geometry)
-  if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
+  let baseSlice = slice.fromGeom2(geometry)
 
-  // const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
-  const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
-  
-  let baseSlice = slice.fromSides(shapeSides)
-  
-  if(pointsWithPositiveX.length === 0) {
+  const bounds = measureBoundingBox(geometry)
+  if (bounds[1][0] <= 0) {
     // only points in negative x plane, reverse
     baseSlice = slice.reverse(baseSlice)
   }
@@ -98,7 +92,7 @@ const extrudeHelical = (options, geometry) => {
       mat4.fromZRotation(mat4.create(), zRotation),
       step1
     )
-    return slice.transform(matrix, base)
+    return slice.transform(matrix, baseSlice)
   }
 
   return extrudeFromSlices(
@@ -110,5 +104,3 @@ const extrudeHelical = (options, geometry) => {
     baseSlice
   )
 }
-
-module.exports = extrudeHelical

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

@@ -1,62 +1,60 @@
-const test = require('ava')
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
-const { TAU } = require('../../maths/constants')
-const { geom2, geom3 } = require('../../geometries')
-const { circle } = require('../../primitives')
+import test from 'ava'
+import { TAU } from '../../maths/constants.js'
+import { geom2, geom3 } from '../../geometries/index.js'
+import { circle } from '../../primitives/index.js'
 
-const { extrudeHelical } = require('./index')
+import { extrudeHelical } from './index.js'
 
 test('extrudeHelical: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
-    const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+  const geometry2 = geom2.create([[[10, 8], [10, -8], [26, -8], [26, 8]]])
 
-    const geometry3 = extrudeHelical({}, geometry2)
-    const pts = geom3.toPoints(geometry3)
-    t.notThrows(() => geom3.validate(geometry3))
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
 })
 
 test('extrudeHelical: (defaults) extruding of a circle produces an expected geom3', (t) => {
-    const geometry2 = circle({ size: 3, center: [10, 0] })
+  const geometry2 = circle({ size: 3, center: [10, 0] })
 
-    const geometry3 = extrudeHelical({}, geometry2)
-    t.notThrows(() => geom3.validate(geometry3))
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
 })
 
 test('extrudeHelical: (angle) extruding of a circle produces an expected geom3', (t) => {
-    const maxRevolutions = 10
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(maxRevolutions).keys()]) {
-        // also test negative angles
-        const geometry3 = extrudeHelical({angle: TAU * (index - maxRevolutions / 2)}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const maxRevolutions = 10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(maxRevolutions).keys()]) {
+    // also test negative angles
+    const geometry3 = extrudeHelical({ angle: TAU * (index - maxRevolutions / 2) }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3', (t) => {
-    const startPitch = -10
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(20).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({pitch: startPitch + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const startPitch = -10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(20).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ pitch: startPitch + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expected geom3', (t) => {
-    const startOffset = -5
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(10).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({endRadiusOffset: startOffset + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const startOffset = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ endRadiusOffset: startOffset + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (segments) extruding of a circle produces an expected geom3', (t) => {
-    const startSegments = 3
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(30).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({segments: startSegments + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
-})
+  const startSegments = 3
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(30).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ segments: startSegments + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})

package/src/operations/extrusions/extrudeLinear.d.ts

@@ -1,7 +1,5 @@
-import { Path2, Geom2, Geom3 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
-
-export default extrudeLinear
+import type { Path2, Geom2, Geom3 } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export interface ExtrudeLinearOptions {
   height?: number
@@ -11,5 +9,5 @@ export interface ExtrudeLinearOptions {
 
 type Geometry = Path2 | Geom2
 
-declare function extrudeLinear(options: ExtrudeLinearOptions, geometry: Geometry): Geom3
-declare function extrudeLinear(options: ExtrudeLinearOptions, ...geometries: RecursiveArray<Geometry>): Geom3
+export function extrudeLinear(options: ExtrudeLinearOptions, geometry: Geometry): Geom3
+export function extrudeLinear(options: ExtrudeLinearOptions, ...geometries: RecursiveArray<Geometry>): Geom3