@jscad/modeling 2.12.0 → 3.0.0-alpha.0

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

@@ -1,143 +1,164 @@
-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')
+import { TAU } from '../../maths/constants.js'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { colorize } from '../../colors/index.js'
 
-const { extrudeLinear } = require('./index')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
+
+import { measureVolume } from '../../measurements/index.js'
+
+import { square } from '../../primitives/index.js'
+
+import { extrudeLinear } from './index.js'
 
 test('extrudeLinear (defaults)', (t) => {
-  const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  const geometry2 = square({ size: 10 })
 
   const geometry3 = extrudeLinear({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
   const exp = [
+    [[-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]],
-    [[-5, -5, 0], [5, -5, 0], [5, -5, 1]],
-    [[-5, -5, 0], [5, -5, 1], [-5, -5, 1]],
-    [[-5, -5, 1], [5, -5, 1], [5, 5, 1]],
     [[5, 5, 1], [-5, 5, 1], [-5, -5, 1]],
-    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
-    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [[-5, -5, 1], [5, -5, 1], [5, 5, 1]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 100.00000000000001)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
+test('extrudeLinear: preserves color', (t) => {
+  const redSquare = colorize([1, 0, 0], square())
+  const extruded = extrudeLinear({ }, redSquare)
+  t.deepEqual(extruded.color, [1, 0, 0, 1])
+
+  // one red, one blue
+  const out = extrudeLinear({ }, [redSquare, square()])
+  t.deepEqual(out[0].color, [1, 0, 0, 1])
+  t.is(out[1].color, undefined)
+})
+
 test('extrudeLinear (no twist)', (t) => {
-  const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  const geometry2 = square({ size: 10 })
 
   let geometry3 = extrudeLinear({ height: 15 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   let exp = [
+    [[-5, -5, 0], [5, -5, 0], [5, -5, 15]],
+    [[-5, -5, 0], [5, -5, 15], [-5, -5, 15]],
     [[5, -5, 0], [5, 5, 0], [5, 5, 15]],
     [[5, -5, 0], [5, 5, 15], [5, -5, 15]],
     [[5, 5, 0], [-5, 5, 0], [-5, 5, 15]],
     [[5, 5, 0], [-5, 5, 15], [5, 5, 15]],
     [[-5, 5, 0], [-5, -5, 0], [-5, -5, 15]],
     [[-5, 5, 0], [-5, -5, 15], [-5, 5, 15]],
-    [[-5, -5, 0], [5, -5, 0], [5, -5, 15]],
-    [[-5, -5, 0], [5, -5, 15], [-5, -5, 15]],
-    [[-5, -5, 15], [5, -5, 15], [5, 5, 15]],
     [[5, 5, 15], [-5, 5, 15], [-5, -5, 15]],
-    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
-    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [[-5, -5, 15], [5, -5, 15], [5, 5, 15]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 1500)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: -15 }, geometry2)
   pts = geom3.toPoints(geometry3)
   exp = [
-    [[5, 5, 0], [5, -5, 0], [5, -5, -15]],
-    [[5, 5, 0], [5, -5, -15], [5, 5, -15]],
     [[-5, 5, 0], [5, 5, 0], [5, 5, -15]],
     [[-5, 5, 0], [5, 5, -15], [-5, 5, -15]],
-    [[-5, -5, 0], [-5, 5, 0], [-5, 5, -15]],
-    [[-5, -5, 0], [-5, 5, -15], [-5, -5, -15]],
+    [[5, 5, 0], [5, -5, 0], [5, -5, -15]],
+    [[5, 5, 0], [5, -5, -15], [5, 5, -15]],
     [[5, -5, 0], [-5, -5, 0], [-5, -5, -15]],
     [[5, -5, 0], [-5, -5, -15], [5, -5, -15]],
-    [[-5, 5, -15], [5, 5, -15], [5, -5, -15]],
+    [[-5, -5, 0], [-5, 5, 0], [-5, 5, -15]],
+    [[-5, -5, 0], [-5, 5, -15], [-5, -5, -15]],
     [[5, -5, -15], [-5, -5, -15], [-5, 5, -15]],
-    [[5, -5, 0], [5, 5, 0], [-5, 5, 0]],
-    [[-5, 5, 0], [-5, -5, 0], [5, -5, 0]]
+    [[-5, 5, -15], [5, 5, -15], [5, -5, -15]],
+    [[-5, 5, 0], [-5, -5, 0], [5, -5, 0]],
+    [[5, -5, 0], [5, 5, 0], [-5, 5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 1500)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
 test('extrudeLinear (twist)', (t) => {
-  const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  const geometry2 = square({ size: 10 })
 
   let geometry3 = extrudeLinear({ height: 15, twistAngle: -TAU / 8 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   let exp = [
+    [[-5, -5, 0], [5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15]],
+    [[-5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15], [-7.0710678118654755, -4.440892098500626e-16, 15]],
     [[5, -5, 0], [5, 5, 0], [7.0710678118654755, 4.440892098500626e-16, 15]],
     [[5, -5, 0], [7.0710678118654755, 4.440892098500626e-16, 15], [4.440892098500626e-16, -7.0710678118654755, 15]],
     [[5, 5, 0], [-5, 5, 0], [-4.440892098500626e-16, 7.0710678118654755, 15]],
     [[5, 5, 0], [-4.440892098500626e-16, 7.0710678118654755, 15], [7.0710678118654755, 4.440892098500626e-16, 15]],
     [[-5, 5, 0], [-5, -5, 0], [-7.0710678118654755, -4.440892098500626e-16, 15]],
     [[-5, 5, 0], [-7.0710678118654755, -4.440892098500626e-16, 15], [-4.440892098500626e-16, 7.0710678118654755, 15]],
-    [[-5, -5, 0], [5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15]],
-    [[-5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15], [-7.0710678118654755, -4.440892098500626e-16, 15]],
-    [
-      [-7.0710678118654755, -4.440892098500626e-16, 15],
-      [4.440892098500626e-16, -7.0710678118654755, 15],
-      [7.0710678118654755, 4.440892098500626e-16, 15]
-    ],
     [
       [7.0710678118654755, 4.440892098500626e-16, 15],
       [-4.440892098500626e-16, 7.0710678118654755, 15],
       [-7.0710678118654755, -4.440892098500626e-16, 15]
     ],
-    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
-    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [
+      [-7.0710678118654755, -4.440892098500626e-16, 15],
+      [4.440892098500626e-16, -7.0710678118654755, 15],
+      [7.0710678118654755, 4.440892098500626e-16, 15]
+    ],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 1707.1067811865476)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 4, twistSteps: 3 }, geometry2)
   pts = geom3.toPoints(geometry3)
   exp = [
+    [[-5, -5, 0], [5, -5, 0], [6.830127018922193, -1.830127018922194, 5]],
+    [[-5, -5, 0], [6.830127018922193, -1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5]],
     [[5, -5, 0], [5, 5, 0], [1.830127018922194, 6.830127018922193, 5]],
     [[5, -5, 0], [1.830127018922194, 6.830127018922193, 5], [6.830127018922193, -1.830127018922194, 5]],
     [[5, 5, 0], [-5, 5, 0], [-6.830127018922193, 1.830127018922194, 5]],
     [[5, 5, 0], [-6.830127018922193, 1.830127018922194, 5], [1.830127018922194, 6.830127018922193, 5]],
     [[-5, 5, 0], [-5, -5, 0], [-1.830127018922194, -6.830127018922193, 5]],
     [[-5, 5, 0], [-1.830127018922194, -6.830127018922193, 5], [-6.830127018922193, 1.830127018922194, 5]],
-    [[-5, -5, 0], [5, -5, 0], [6.830127018922193, -1.830127018922194, 5]],
-    [[-5, -5, 0], [6.830127018922193, -1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5]],
+    [[-1.830127018922194, -6.830127018922193, 5], [6.830127018922193, -1.830127018922194, 5], [6.830127018922193, 1.8301270189221923, 10]],
+    [[-1.830127018922194, -6.830127018922193, 5], [6.830127018922193, 1.8301270189221923, 10], [1.8301270189221923, -6.830127018922193, 10]],
     [[6.830127018922193, -1.830127018922194, 5], [1.830127018922194, 6.830127018922193, 5], [-1.8301270189221923, 6.830127018922193, 10]],
     [[6.830127018922193, -1.830127018922194, 5], [-1.8301270189221923, 6.830127018922193, 10], [6.830127018922193, 1.8301270189221923, 10]],
     [[1.830127018922194, 6.830127018922193, 5], [-6.830127018922193, 1.830127018922194, 5], [-6.830127018922193, -1.8301270189221923, 10]],
     [[1.830127018922194, 6.830127018922193, 5], [-6.830127018922193, -1.8301270189221923, 10], [-1.8301270189221923, 6.830127018922193, 10]],
     [[-6.830127018922193, 1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5], [1.8301270189221923, -6.830127018922193, 10]],
     [[-6.830127018922193, 1.830127018922194, 5], [1.8301270189221923, -6.830127018922193, 10], [-6.830127018922193, -1.8301270189221923, 10]],
-    [[-1.830127018922194, -6.830127018922193, 5], [6.830127018922193, -1.830127018922194, 5], [6.830127018922193, 1.8301270189221923, 10]],
-    [[-1.830127018922194, -6.830127018922193, 5], [6.830127018922193, 1.8301270189221923, 10], [1.8301270189221923, -6.830127018922193, 10]],
+    [[1.8301270189221923, -6.830127018922193, 10], [6.830127018922193, 1.8301270189221923, 10], [5, 5, 15]],
+    [[1.8301270189221923, -6.830127018922193, 10], [5, 5, 15], [5, -5, 15]],
     [[6.830127018922193, 1.8301270189221923, 10], [-1.8301270189221923, 6.830127018922193, 10], [-5, 5, 15]],
     [[6.830127018922193, 1.8301270189221923, 10], [-5, 5, 15], [5, 5, 15]],
     [[-1.8301270189221923, 6.830127018922193, 10], [-6.830127018922193, -1.8301270189221923, 10], [-5, -5, 15]],
     [[-1.8301270189221923, 6.830127018922193, 10], [-5, -5, 15], [-5, 5, 15]],
     [[-6.830127018922193, -1.8301270189221923, 10], [1.8301270189221923, -6.830127018922193, 10], [5, -5, 15]],
     [[-6.830127018922193, -1.8301270189221923, 10], [5, -5, 15], [-5, -5, 15]],
-    [[1.8301270189221923, -6.830127018922193, 10], [6.830127018922193, 1.8301270189221923, 10], [5, 5, 15]],
-    [[1.8301270189221923, -6.830127018922193, 10], [5, 5, 15], [5, -5, 15]],
-    [[5, -5, 15], [5, 5, 15], [-5, 5, 15]],
     [[-5, 5, 15], [-5, -5, 15], [5, -5, 15]],
-    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
-    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [[5, -5, 15], [5, 5, 15], [-5, 5, 15]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.is(pts.length, 28)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -145,19 +166,14 @@ test('extrudeLinear (twist)', (t) => {
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 1444.9967160503095)
   t.is(pts.length, 244)
 })
 
 test('extrudeLinear (holes)', (t) => {
   const geometry2 = geom2.create([
-    [[-5, 5], [-5, -5]],
-    [[-5, -5], [5, -5]],
-    [[5, -5], [5, 5]],
-    [[5, 5], [-5, 5]],
-    [[-2, -2], [-2, 2]],
-    [[2, -2], [-2, -2]],
-    [[2, 2], [2, -2]],
-    [[-2, 2], [2, 2]]
+    [[-5, 5], [-5, -5], [5, -5], [5, 5]],
+    [[-2, -2], [-2, 2], [2, 2], [2, -2]]
   ])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
   const pts = geom3.toPoints(geometry3)
@@ -172,36 +188,37 @@ test('extrudeLinear (holes)', (t) => {
     [[5, 5, 0], [-5, 5, 15], [5, 5, 15]],
     [[-2, -2, 0], [-2, 2, 0], [-2, 2, 15]],
     [[-2, -2, 0], [-2, 2, 15], [-2, -2, 15]],
-    [[2, -2, 0], [-2, -2, 0], [-2, -2, 15]],
-    [[2, -2, 0], [-2, -2, 15], [2, -2, 15]],
-    [[2, 2, 0], [2, -2, 0], [2, -2, 15]],
-    [[2, 2, 0], [2, -2, 15], [2, 2, 15]],
     [[-2, 2, 0], [2, 2, 0], [2, 2, 15]],
     [[-2, 2, 0], [2, 2, 15], [-2, 2, 15]],
-    [[5, -5, 15], [5, 5, 15], [2, 2, 15]],
+    [[2, 2, 0], [2, -2, 0], [2, -2, 15]],
+    [[2, 2, 0], [2, -2, 15], [2, 2, 15]],
+    [[2, -2, 0], [-2, -2, 0], [-2, -2, 15]],
+    [[2, -2, 0], [-2, -2, 15], [2, -2, 15]],
     [[-2, 2, 15], [2, 2, 15], [5, 5, 15]],
-    [[5, -5, 15], [2, 2, 15], [2, -2, 15]],
+    [[5, -5, 15], [5, 5, 15], [2, 2, 15]],
     [[-2, 2, 15], [5, 5, 15], [-5, 5, 15]],
-    [[-5, -5, 15], [5, -5, 15], [2, -2, 15]],
+    [[5, -5, 15], [2, 2, 15], [2, -2, 15]],
     [[-2, -2, 15], [-2, 2, 15], [-5, 5, 15]],
-    [[-5, -5, 15], [2, -2, 15], [-2, -2, 15]],
+    [[-5, -5, 15], [5, -5, 15], [2, -2, 15]],
     [[-2, -2, 15], [-5, 5, 15], [-5, -5, 15]],
-    [[2, 2, 0], [5, 5, 0], [5, -5, 0]],
+    [[-5, -5, 15], [2, -2, 15], [-2, -2, 15]],
     [[5, 5, 0], [2, 2, 0], [-2, 2, 0]],
-    [[2, -2, 0], [2, 2, 0], [5, -5, 0]],
+    [[2, 2, 0], [5, 5, 0], [5, -5, 0]],
     [[-5, 5, 0], [5, 5, 0], [-2, 2, 0]],
-    [[2, -2, 0], [5, -5, 0], [-5, -5, 0]],
+    [[2, -2, 0], [2, 2, 0], [5, -5, 0]],
     [[-5, 5, 0], [-2, 2, 0], [-2, -2, 0]],
-    [[-2, -2, 0], [2, -2, 0], [-5, -5, 0]],
-    [[-5, -5, 0], [-5, 5, 0], [-2, -2, 0]]
+    [[2, -2, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [-2, -2, 0]],
+    [[-2, -2, 0], [2, -2, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureVolume(geometry3), 1260)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
 test('extrudeLinear (path2)', (t) => {
-  const geometry2 = path2.fromPoints({ closed: true }, [[0, 0], [12, 0], [6, 10]])
+  const geometry2 = path2.fromPoints({ closed: true }, [[6, 10], [0, 0], [12, 0]])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
   t.notThrows(() => geom3.validate(geometry3))
   const pts = geom3.toPoints(geometry3)
@@ -212,8 +229,8 @@ test('extrudeLinear (path2)', (t) => {
     [[0, 0, 0], [12, 0, 15], [0, 0, 15]],
     [[12, 0, 0], [6, 10, 0], [6, 10, 15]],
     [[12, 0, 0], [6, 10, 15], [12, 0, 15]],
-    [[12, 0, 15], [6, 10, 15], [0, 0, 15]],
-    [[0, 0, 0], [6, 10, 0], [12, 0, 0]]
+    [[0, 0, 15], [12, 0, 15], [6, 10, 15]],
+    [[6, 10, 0], [12, 0, 0], [0, 0, 0]]
   ]
 
   t.is(pts.length, 8)

package/src/operations/extrusions/extrudeLinearGeom2.js

@@ -1,24 +1,22 @@
-const mat4 = require('../../maths/mat4')
-const vec3 = require('../../maths/vec3')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
-const geom2 = require('../../geometries/geom2')
+import * as slice from '../../geometries/slice/index.js'
 
-const slice = require('./slice')
-
-const extrudeFromSlices = require('./extrudeFromSlices')
+import { extrudeFromSlices } from './extrudeFromSlices.js'
 
 /*
  * Extrude the given geometry using the given options.
  *
- * @param {Object} [options] - options for extrude
+ * @param {object} [options] - options for extrude
  * @param {Array} [options.offset] - the direction of the extrusion as a 3D vector
- * @param {Number} [options.twistAngle] - the final rotation (RADIANS) about the origin
- * @param {Integer} [options.twistSteps] - the number of steps created to produce the twist (if any)
- * @param {Boolean} [options.repair] - repair gaps in the geometry
- * @param {geom2} geometry - the geometry to extrude
- * @returns {geom3} the extruded 3D geometry
+ * @param {number} [options.twistAngle] - the final rotation (RADIANS) about the origin
+ * @param {number} [options.twistSteps] - the number of steps created to produce the twist (if any)
+ * @param {boolean} [options.repair] - repair gaps in the geometry
+ * @param {Geom2} geometry - the geometry to extrude
+ * @returns {Geom3} the extruded 3D geometry
 */
-const extrudeGeom2 = (options, geometry) => {
+export const extrudeLinearGeom2 = (options, geometry) => {
   const defaults = {
     offset: [0, 0, 1],
     twistAngle: 0,
@@ -34,18 +32,15 @@ const extrudeGeom2 = (options, geometry) => {
   }
 
   // convert to vector in order to perform transforms
-  const offsetv = vec3.clone(offset)
-
-  const baseSides = geom2.toSides(geometry)
-  if (baseSides.length === 0) throw new Error('the given geometry cannot be empty')
+  const offsetV = vec3.clone(offset)
 
-  const baseSlice = slice.fromSides(baseSides)
-  if (offsetv[2] < 0) slice.reverse(baseSlice, baseSlice)
+  let baseSlice = slice.fromGeom2(geometry)
+  if (offsetV[2] < 0) baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()
   const createTwist = (progress, index, base) => {
     const Zrotation = index / twistSteps * twistAngle
-    const Zoffset = vec3.scale(vec3.create(), offsetv, index / twistSteps)
+    const Zoffset = vec3.scale(vec3.create(), offsetV, index / twistSteps)
     mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromTranslation(mat4.create(), Zoffset))
 
     return slice.transform(matrix, base)
@@ -58,7 +53,7 @@ const extrudeGeom2 = (options, geometry) => {
     repair,
     callback: createTwist
   }
-  return extrudeFromSlices(options, baseSlice)
+  const output = extrudeFromSlices(options, baseSlice)
+  if (geometry.color) output.color = geometry.color
+  return output
 }
-
-module.exports = extrudeGeom2

package/src/operations/extrusions/extrudeLinearPath2.js

@@ -1,24 +1,23 @@
-const geom2 = require('../../geometries/geom2')
-const path2 = require('../../geometries/path2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as path2 from '../../geometries/path2/index.js'
 
-const extrudeLinearGeom2 = require('./extrudeLinearGeom2')
+import { extrudeLinearGeom2 } from './extrudeLinearGeom2.js'
 
 /*
  * Extrude the given geometry using the given options.
  *
- * @param {Object} [options] - options for extrude
+ * @param {object} [options] - options for extrude
  * @param {Array} [options.offset] - the direction of the extrusion as a 3D vector
- * @param {Number} [options.twistAngle] - the final rotation (RADIANS) about the origin
- * @param {Integer} [options.twistSteps] - the number of steps created to produce the twist (if any)
- * @param {path2} geometry - the geometry to extrude
- * @returns {geom3} the extruded 3D geometry
+ * @param {number} [options.twistAngle] - the final rotation (RADIANS) about the origin
+ * @param {number} [options.twistSteps] - the number of steps created to produce the twist (if any)
+ * @param {Path2} geometry - the geometry to extrude
+ * @returns {Geom3} the extruded 3D geometry
 */
-const extrudePath2 = (options, geometry) => {
+export const extrudeLinearPath2 = (options, geometry) => {
   if (!geometry.isClosed) throw new Error('extruded path must be closed')
   // Convert path2 to geom2
   const points = path2.toPoints(geometry)
-  const geometry2 = geom2.fromPoints(points)
+  const geometry2 = geom2.create([points])
+  if (geometry.color) geometry2.color = geometry.color
   return extrudeLinearGeom2(options, geometry2)
 }
-
-module.exports = extrudePath2

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

@@ -1,6 +1,4 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-
-export default extrudeRotate
+import type { Geom2, Geom3 } from '../../geometries/types.d.ts'
 
 export interface ExtrudeRotateOptions {
   angle?: number
@@ -9,4 +7,4 @@ export interface ExtrudeRotateOptions {
   segments?: number;
 }
 
-declare function extrudeRotate(options: ExtrudeRotateOptions, geometry: Geom2): Geom3
+export function extrudeRotate(options: ExtrudeRotateOptions, geometry: Geom2): Geom3

package/src/operations/extrusions/extrudeRotate.js

@@ -1,31 +1,30 @@
-const { TAU } = require('../../maths/constants')
-const mat4 = require('../../maths/mat4')
+import { TAU } from '../../maths/constants.js'
+import * as mat4 from '../../maths/mat4/index.js'
 
-const { mirrorX } = require('../transforms/mirror')
+import { mirrorX } from '../transforms/mirror.js'
 
-const geom2 = require('../../geometries/geom2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
-const slice = require('./slice')
-
-const extrudeFromSlices = require('./extrudeFromSlices')
+import { extrudeFromSlices } from './extrudeFromSlices.js'
 
 /**
  * Rotate extrude the given geometry using the given options.
  *
- * @param {Object} options - options for extrusion
- * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS)
- * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
- * @param {String} [options.overflow='cap'] - what to do with points outside of bounds (+ / - x) :
+ * @param {object} options - options for extrusion
+ * @param {number} [options.angle=TAU] - angle of the extrusion (RADIANS)
+ * @param {number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
+ * @param {string} [options.overflow='cap'] - what to do with points outside of bounds (+ / - x) :
  * defaults to capping those points to 0 (only supported behaviour for now)
- * @param {Number} [options.segments=12] - number of segments of the extrusion
- * @param {geom2} geometry - the geometry to extrude
- * @returns {geom3} the extruded geometry
+ * @param {number} [options.segments=12] - number of segments of the extrusion
+ * @param {Geom2} geometry - the geometry to extrude
+ * @returns {Geom3} the extruded geometry
  * @alias module:modeling/extrusions.extrudeRotate
  *
  * @example
  * const myshape = extrudeRotate({segments: 8, angle: TAU / 2}, circle({size: 3, center: [4, 0]}))
  */
-const extrudeRotate = (options, geometry) => {
+export const extrudeRotate = (options, geometry) => {
   const defaults = {
     segments: 12,
     startAngle: 0,
@@ -57,21 +56,17 @@ const extrudeRotate = (options, geometry) => {
     if (Math.abs(totalRotation) > (segments * anglePerSegment)) segments++
   }
 
-  // console.log('startAngle: '+startAngle)
-  // console.log('endAngle: '+endAngle)
-  // console.log(totalRotation)
-  // console.log(segments)
-
   // convert geometry to an array of sides, easier to deal with
   let shapeSides = geom2.toSides(geometry)
-  if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
+  if (shapeSides.length === 0) return geometry
+  let sliceGeometry = geometry
 
-  // determine if the rotate extrude can be computed in the first place
+  // determine if the extrusion can be computed in the first place
   // ie all the points have to be either x > 0 or x < 0
 
   // generic solution to always have a valid solid, even if points go beyond x/ -x
-  // 1. split points up between all those on the 'left' side of the axis (x<0) & those on the 'righ' (x>0)
-  // 2. for each set of points do the extrusion operation IN OPOSITE DIRECTIONS
+  // 1. split points up between all those on the 'left' side of the axis (x<0) & those on the 'right' (x>0)
+  // 2. for each set of points do the extrusion operation IN OPPOSITE DIRECTIONS
   // 3. union the two resulting solids
 
   // 1. alt : OR : just cap of points at the axis ?
@@ -93,8 +88,8 @@ const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (-) capped points
-      geometry = geom2.reverse(geom2.create(shapeSides))
-      geometry = mirrorX(geometry)
+      sliceGeometry = geom2.reverse(geom2.fromSides(shapeSides))
+      sliceGeometry = mirrorX(sliceGeometry)
     } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
       shapeSides = shapeSides.map((side) => {
         let point0 = side[0]
@@ -104,14 +99,14 @@ const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (+) capped points
-      geometry = geom2.create(shapeSides)
+      sliceGeometry = geom2.fromSides(shapeSides)
     }
   }
 
   const rotationPerSlice = totalRotation / segments
   const isCapped = Math.abs(totalRotation) < TAU
-  const baseSlice = slice.fromSides(geom2.toSides(geometry))
-  slice.reverse(baseSlice, baseSlice)
+  let baseSlice = slice.fromGeom2(sliceGeometry)
+  baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()
   const createSlice = (progress, index, base) => {
@@ -132,7 +127,7 @@ const extrudeRotate = (options, geometry) => {
     close: !isCapped,
     callback: createSlice
   }
-  return extrudeFromSlices(options, baseSlice)
+  const output = extrudeFromSlices(options, baseSlice)
+  if (geometry.color) output.color = geometry.color
+  return output
 }
-
-module.exports = extrudeRotate