@jscad/modeling 2.12.5 → 3.0.1-alpha.0

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

@@ -1,59 +1,79 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { TAU } = require('../../maths/constants')
+import { TAU } from '../../maths/constants.js'
 
-const { geom2, geom3 } = require('../../geometries')
+import { colorize } from '../../colors/index.js'
 
-const { extrudeRotate } = require('./index')
+import { geom2, geom3 } from '../../geometries/index.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+import { square } from '../../primitives/index.js'
+
+import { extrudeRotate } from './index.js'
 
 test('extrudeRotate: (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 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7033.914479497244)
+  t.is(measureVolume(geometry3), 27648.000000000007)
   t.is(pts.length, 96)
 })
 
+test('extrudeRotate: preserves color', (t) => {
+  const red = colorize([1, 0, 0], square())
+  const extruded = extrudeRotate({ }, red)
+  t.deepEqual(extruded.color, [1, 0, 0, 1])
+})
+
 test('extrudeRotate: (angle) 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]]])
 
   // test angle
   let geometry3 = extrudeRotate({ segments: 4, angle: TAU / 8 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   const exp = [
-    [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
-    [[10, 0, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, 0, -8], [10, 0, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, 0, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, 0, -8], [10, 0, -8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, 0, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
     [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
     [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
+    [[26, 0, -8], [10, 0, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[10, 0, -8], [10, 0, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[10, 0, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
     [[7.0710678118654755, 7.071067811865475, -8], [7.0710678118654755, 7.071067811865475, 8], [18.38477631085024, 18.384776310850235, 8]],
     [[18.38477631085024, 18.384776310850235, 8], [18.38477631085024, 18.384776310850235, -8], [7.0710678118654755, 7.071067811865475, -8]],
     [[26, 0, 8], [10, 0, 8], [10, 0, -8]],
     [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1360.144820048035)
+  t.is(measureVolume(geometry3), 3258.3480477076105)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 4525.850393739846)
+  t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 4525.8503937398455)
+  t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 })
 
 test('extrudeRotate: (startAngle) 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]]])
 
   // test startAngle
   let geometry3 = extrudeRotate({ segments: 5, startAngle: TAU / 8 }, geometry2)
@@ -64,8 +84,10 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [-11.803752993228215, 23.166169628897567, 8]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 6124.6858201346895)
+  t.is(measureVolume(geometry3), 21912.342135440336)
   t.is(pts.length, 40)
-  t.true(comparePoints(pts[0], exp))
+  t.true(comparePoints(pts[6], exp))
 
   geometry3 = extrudeRotate({ segments: 5, startAngle: -TAU / 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
@@ -75,85 +97,99 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [23.166169628897567, 11.803752993228215, 8]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 6124.685820134688)
+  t.is(measureVolume(geometry3), 21912.342135440336)
   t.is(pts.length, 40)
-  t.true(comparePoints(pts[0], exp))
+  t.true(comparePoints(pts[6], exp))
 })
 
 test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3', (t) => {
-  let geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+  let geometry2 = geom2.create([[[10, 8], [10, -8], [26, -8], [26, 8]]])
 
   // test segments
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 5562.34804770761)
+  t.is(measureVolume(geometry3), 18432)
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7230.965353920782)
+  t.is(measureVolume(geometry3), 28906.430888871357)
   t.is(pts.length, 512)
 
   // test overlapping edges
-  geometry2 = geom2.fromPoints([[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]])
+  geometry2 = geom2.create([[[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 84.28200374166053)
+  t.is(measureVolume(geometry3), 33.94112549695427)
   t.is(pts.length, 64)
 
   // test overlapping edges that produce hollow shape
-  geometry2 = geom2.fromPoints([[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]])
+  geometry2 = geom2.create([[[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 17692.315375839215)
+  t.is(measureVolume(geometry3), 147078.2104868019)
   t.is(pts.length, 80)
 })
 
 test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geom3', (t) => {
   // overlap of Y axis; even number of + and - points
-  let geometry = geom2.fromPoints([[-1, 8], [-1, -8], [7, -8], [7, 8]])
+  let geometry = geom2.create([[[-1, 8], [-1, -8], [7, -8], [7, 8]]])
 
   let obs = extrudeRotate({ segments: 4, angle: TAU / 4 }, geometry)
   let pts = geom3.toPoints(obs)
   let exp = [
     [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
-    [[7, 0, -8], [0, 0, -8], [0, 7, -8]],
     [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
     [[7, 0, 8], [0, 7, -8], [0, 7, 8]],
-    [[0, 0, -8], [0, 0, 8], [0, 7, 8]],
-    [[0, 7, 8], [0, 7, -8], [0, 0, -8]],
-    [[7, 0, 8], [0, 0, 8], [0, 0, -8]],
-    [[0, 0, -8], [7, 0, -8], [7, 0, 8]]
+    [[7, 0, -8], [0, 0, -8], [0, 7, -8]],
+    [[0, 7, -8], [0, 0, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 7, 8], [0, 7, -8]],
+    [[0, 0, 8], [0, 0, -8], [7, 0, -8]],
+    [[7, 0, -8], [7, 0, 8], [0, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 431.3919189857867)
+  t.is(measureVolume(obs), 391.99999999999994)
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // overlap of Y axis; larger number of - points
-  geometry = geom2.fromPoints([[-1, 8], [-2, 4], [-1, -8], [7, -8], [7, 8]])
+  geometry = geom2.create([[[-1, 8], [-2, 4], [-1, -8], [7, -8], [7, 8]]])
 
   obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry)
   pts = geom3.toPoints(obs)
   exp = [
-    [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
     [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
     [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[0, 0, 8], [1, 0, 8], [0.7071067811865476, 0.7071067811865475, 8]],
     [[1, 0, 8], [2, 0, 4], [1.4142135623730951, 1.414213562373095, 4]],
     [[1, 0, 8], [1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, 8]],
-    [[0, 0, 8], [1, 0, 8], [0.7071067811865476, 0.7071067811865475, 8]],
-    [[0.7071067811865476, 0.7071067811865475, -8], [0, 0, -8], [0, 1, -8]],
     [[1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, -8], [0, 1, -8]],
     [[1.4142135623730951, 1.414213562373095, 4], [0, 1, -8], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, -8], [0, 0, -8], [0, 1, -8]],
+    [[0, 0, 8], [0.7071067811865476, 0.7071067811865475, 8], [0, 1, 8]],
     [[0.7071067811865476, 0.7071067811865475, 8], [1.4142135623730951, 1.414213562373095, 4], [0, 2, 4]],
     [[0.7071067811865476, 0.7071067811865475, 8], [0, 2, 4], [0, 1, 8]],
-    [[0, 0, 8], [0.7071067811865476, 0.7071067811865475, 8], [0, 1, 8]],
-    [[0, 1, -8], [0, 0, -8], [0, 0, 8]],
     [[0, 0, 8], [0, 1, 8], [0, 2, 4]],
-    [[0, 2, 4], [0, 1, -8], [0, 0, 8]],
-    [[0, 0, 8], [0, 0, -8], [1, 0, -8]],
+    [[0, 2, 4], [0, 1, -8], [0, 0, -8]],
+    [[0, 0, -8], [0, 0, 8], [0, 2, 4]],
     [[2, 0, 4], [1, 0, 8], [0, 0, 8]],
-    [[0, 0, 8], [1, 0, -8], [2, 0, 4]]
+    [[0, 0, -8], [1, 0, -8], [2, 0, 4]],
+    [[2, 0, 4], [0, 0, 8], [0, 0, -8]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 86.47516025670329)
+  t.is(measureVolume(obs), 26.398653164297773)
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/operations/extrusions/extrudeWalls.js

@@ -1,9 +1,8 @@
-const { EPS } = require('../../maths/constants')
-const vec3 = require('../../maths/vec3')
+import { EPS } from '../../maths/constants.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
-const poly3 = require('../../geometries/poly3')
-
-const slice = require('./slice')
+import * as poly3 from '../../geometries/poly3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 // https://en.wikipedia.org/wiki/Greatest_common_divisor#Using_Euclid's_algorithm
 const gcd = (a, b) => {
@@ -17,10 +16,10 @@ const gcd = (a, b) => {
 const lcm = (a, b) => (a * b) / gcd(a, b)
 
 // Return a set of edges that encloses the same area by splitting
-// the given edges to have newlength total edges.
-const repartitionEdges = (newlength, edges) => {
+// the given edges to have newLength total edges.
+const repartitionEdges = (newLength, edges) => {
   // NOTE: This implementation splits each edge evenly.
-  const multiple = newlength / edges.length
+  const multiple = newLength / edges.length
   if (multiple === 1) {
     return edges
   }
@@ -49,15 +48,15 @@ const EPSAREA = (EPS * EPS / 2) * Math.sin(Math.PI / 3)
  * Extrude (build) walls between the given slices.
  * Each wall consists of two triangles, which may be invalid if slices are overlapping.
  */
-const extrudeWalls = (slice0, slice1) => {
+export const extrudeWalls = (slice0, slice1) => {
   let edges0 = slice.toEdges(slice0)
   let edges1 = slice.toEdges(slice1)
 
   if (edges0.length !== edges1.length) {
     // different shapes, so adjust one or both to the same number of edges
-    const newlength = lcm(edges0.length, edges1.length)
-    if (newlength !== edges0.length) edges0 = repartitionEdges(newlength, edges0)
-    if (newlength !== edges1.length) edges1 = repartitionEdges(newlength, edges1)
+    const newLength = lcm(edges0.length, edges1.length)
+    if (newLength !== edges0.length) edges0 = repartitionEdges(newLength, edges0)
+    if (newLength !== edges1.length) edges1 = repartitionEdges(newLength, edges1)
   }
 
   const walls = []
@@ -74,5 +73,3 @@ const extrudeWalls = (slice0, slice1) => {
   })
   return walls
 }
-
-module.exports = extrudeWalls

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

@@ -1,35 +1,22 @@
-const test = require('ava')
+import test from 'ava'
 
-const { mat4 } = require('../../maths')
+import { mat4 } from '../../maths/index.js'
 
-const slice = require('./slice')
+import * as slice from '../../geometries/slice/index.js'
 
-const extrudeWalls = require('./extrudeWalls')
+import { extrudeWalls } from './extrudeWalls.js'
 
 test('extrudeWalls (same shapes)', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
 
-  const shape0 = []
-  const shape1 = [
-    [[-10.0, 10.0], [-10.0, -10.0]],
-    [[-10.0, -10.0], [10.0, -10.0]],
-    [[10.0, -10.0], [10.0, 10.0]],
-    [[10.0, 10.0], [-10.0, 10.0]]
-  ]
-  const shape2 = [ // hole
-    [[-10.0, 10.0], [-10.0, -10.0]],
-    [[-10.0, -10.0], [10.0, -10.0]],
-    [[10.0, -10.0], [10.0, 10.0]],
-    [[10.0, 10.0], [-10.0, 10.0]],
-    [[-5.0, -5.0], [-5.0, 5.0]],
-    [[5.0, -5.0], [-5.0, -5.0]],
-    [[5.0, 5.0], [5.0, -5.0]],
-    [[-5.0, 5.0], [5.0, 5.0]]
-  ]
-
-  const slice0 = slice.fromSides(shape0)
-  const slice1 = slice.fromSides(shape1)
-  const slice2 = slice.fromSides(shape2)
+  const slice0 = slice.create([])
+  const slice1 = slice.create([
+    [[-10, 10, 0], [-10, -10, 0], [10, -10, 0], [10, 10, 0]]
+  ])
+  const slice2 = slice.create([
+    [[-10, 10, 0], [-10, -10, 0], [10, -10, 0], [10, 10, 0]],
+    [[-5, -5, 0], [5, -5, 0], [5, 5, 0], [-5, 5, 0]] // hole
+  ])
 
   // empty slices
   let walls = extrudeWalls(slice0, slice0)
@@ -47,29 +34,18 @@ test('extrudeWalls (same shapes)', (t) => {
 test('extrudeWalls (different shapes)', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
 
-  const shape1 = [
-    [[-10.0, 10.0], [-10.0, -10.0]],
-    [[-10.0, -10.0], [10.0, -10.0]],
-    [[10.0, -10.0], [10.0, 10.0]]
-  ]
-  const shape2 = [
-    [[-10.0, 10.0], [-10.0, -10.0]],
-    [[-10.0, -10.0], [10.0, -10.0]],
-    [[10.0, -10.0], [10.0, 10.0]],
-    [[10.0, 10.0], [-10.0, 10.0]]
-  ]
-  const shape3 = [
-    [[2.50000, -4.33013], [5.00000, 0.00000]],
-    [[5.00000, 0.00000], [2.50000, 4.33013]],
-    [[2.50000, 4.33013], [-2.50000, 4.33013]],
-    [[-2.50000, 4.33013], [-5.00000, 0.00000]],
-    [[-5.00000, 0.00000], [-2.50000, -4.33013]],
-    [[-2.50000, -4.33013], [2.50000, -4.33013]]
-  ]
-
-  const slice1 = slice.fromSides(shape1)
-  const slice2 = slice.fromSides(shape2)
-  const slice3 = slice.fromSides(shape3)
+  const slice1 = slice.create([[[-10, 10, 0], [-10, -10, 0], [10, -10, 0]]])
+  const slice2 = slice.create([
+    [[-10, 10, 0], [-10, -10, 0], [10, -10, 0], [10, 10, 0]]
+  ])
+  const slice3 = slice.create([[
+    [2.5, -4.33013, 0],
+    [5, 0, 0],
+    [2.5, 4.33013, 0],
+    [-2.5, 4.33013, 0],
+    [-5, 0, 0],
+    [-2.5, -4.33013, 0]
+  ]])
 
   let walls = extrudeWalls(slice1, slice.transform(matrix, slice2))
   t.is(walls.length, 24)

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

@@ -1,9 +1,5 @@
-export { default as extrudeFromSlices, ExtrudeFromSlicesOptions } from './extrudeFromSlices'
-export { default as extrudeLinear, ExtrudeLinearOptions } from './extrudeLinear'
-export { default as extrudeRectangular, ExtrudeRectangularOptions } from './extrudeRectangular'
-export { default as extrudeRotate, ExtrudeRotateOptions } from './extrudeRotate'
-export { default as extrudeHelical, ExtrudeHelicalOptions } from './extrudeHelical'
-export { default as project, ProjectOptions } from './project'
-export * as slice from './slice'
-
-export as namespace extrusions
+export { extrudeFromSlices, ExtrudeFromSlicesOptions } from './extrudeFromSlices.js'
+export { extrudeLinear, ExtrudeLinearOptions } from './extrudeLinear.js'
+export { extrudeRotate, ExtrudeRotateOptions } from './extrudeRotate.js'
+export { extrudeHelical, ExtrudeHelicalOptions } from './extrudeHelical.js'
+export { project, ProjectOptions } from './project.js'

package/src/operations/extrusions/index.js

@@ -3,14 +3,10 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/extrusions
  * @example
- * const { extrudeHelical, extrudeLinear, extrudeRectangular, extrudeRotate, project, slice } = require('@jscad/modeling').extrusions
+ * import { extrudeFromSlices, extrudeHelical, extrudeLinear, extrudeRotate, project } from '@jscad/modeling'
  */
-module.exports = {
-  extrudeFromSlices: require('./extrudeFromSlices'),
-  extrudeLinear: require('./extrudeLinear'),
-  extrudeRectangular: require('./extrudeRectangular'),
-  extrudeRotate: require('./extrudeRotate'),
-  extrudeHelical: require('./extrudeHelical'),
-  project: require('./project'),
-  slice: require('./slice')
-}
+export { extrudeFromSlices } from './extrudeFromSlices.js'
+export { extrudeLinear } from './extrudeLinear.js'
+export { extrudeRotate } from './extrudeRotate.js'
+export { extrudeHelical } from './extrudeHelical.js'
+export { project } from './project.js'

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

@@ -1,14 +1,12 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-import { Vec3 } from '../../maths/vec3'
-import RecursiveArray from '../../utils/recursiveArray'
-
-export default project
+import type { Geom2, Geom3 } from '../../geometries/types.d.ts'
+import type { Vec3 } from '../../maths/vec3/index.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export interface ProjectOptions {
   axis?: Vec3
   origin?: Vec3
 }
 
-declare function project(options: ProjectOptions, geometry: Geom3): Geom2
-declare function project(options: ProjectOptions, ...geometries: RecursiveArray<Geom3>): Array<Geom2>
-declare function project(options: ProjectOptions, ...geometries: RecursiveArray<any>): Array<any>
+export function project(options: ProjectOptions, geometry: Geom3): Geom2
+export function project(options: ProjectOptions, ...geometries: RecursiveArray<Geom3>): Array<Geom2>
+export function project(options: ProjectOptions, ...geometries: RecursiveArray<any>): Array<any>

package/src/operations/extrusions/project.js

@@ -1,21 +1,21 @@
-const flatten = require('../../utils/flatten')
+import { aboutEqualNormals } from '../../maths/utils/aboutEqualNormals.js'
 
-const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
-const plane = require('../../maths/plane')
-const mat4 = require('../../maths/mat4')
+import * as plane from '../../maths/plane/index.js'
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec2 from '../../maths/vec2/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'
 
-const measureEpsilon = require('../../measurements/measureEpsilon')
+import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
-const unionGeom2 = require('../booleans/unionGeom2')
+import { unionGeom2 } from '../booleans/unionGeom2.js'
 
 const projectGeom3 = (options, geometry) => {
   // create a plane from the options, and verify
-  const projplane = plane.fromNormalAndPoint(plane.create(), options.axis, options.origin)
-  if (Number.isNaN(projplane[0]) || Number.isNaN(projplane[1]) || Number.isNaN(projplane[2]) || Number.isNaN(projplane[3])) {
+  const projPlane = plane.fromNormalAndPoint(plane.create(), options.axis, options.origin)
+  if (Number.isNaN(projPlane[0]) || Number.isNaN(projPlane[1]) || Number.isNaN(projPlane[2]) || Number.isNaN(projPlane[3])) {
     throw new Error('project: invalid axis or origin')
   }
 
@@ -26,63 +26,66 @@ const projectGeom3 = (options, geometry) => {
 
   // project the polygons to the plane
   const polygons = geom3.toPolygons(geometry)
-  let projpolys = []
+  let projPolys = []
   for (let i = 0; i < polygons.length; i++) {
-    const newpoints = polygons[i].vertices.map((v) => plane.projectionOfPoint(projplane, v))
-    const newpoly = poly3.create(newpoints)
+    const newVertices = polygons[i].vertices.map((v) => plane.projectionOfPoint(projPlane, v))
+    const newPoly = poly3.create(newVertices)
     // only keep projections that face the same direction as the plane
-    const newplane = poly3.plane(newpoly)
-    if (!aboutEqualNormals(projplane, newplane)) continue
+    const newPlane = poly3.plane(newPoly)
+    if (!aboutEqualNormals(projPlane, newPlane)) continue
     // only keep projections that have a measurable area
-    if (poly3.measureArea(newpoly) < epsilonArea) continue
-    projpolys.push(newpoly)
+    if (poly3.measureArea(newPoly) < epsilonArea) continue
+    projPolys.push(newPoly)
   }
 
   // rotate the polygons to lay on X/Y axes if necessary
-  if (!aboutEqualNormals(projplane, [0, 0, 1])) {
-    const rotation = mat4.fromVectorRotation(mat4.create(), projplane, [0, 0, 1])
-    projpolys = projpolys.map((p) => poly3.transform(rotation, p))
+  if (!aboutEqualNormals(projPlane, [0, 0, 1])) {
+    const rotation = mat4.fromVectorRotation(mat4.create(), projPlane, [0, 0, 1])
+    projPolys = projPolys.map((p) => poly3.transform(rotation, p))
   }
 
   // sort the polygons to allow the union to ignore small pieces efficiently
-  projpolys = projpolys.sort((a, b) => poly3.measureArea(b) - poly3.measureArea(a))
+  projPolys = projPolys.sort((a, b) => poly3.measureArea(b) - poly3.measureArea(a))
 
   // convert polygons to geometry, and union all pieces into a single geometry
-  const projgeoms = projpolys.map((p) => geom2.fromPoints(p.vertices))
-  return unionGeom2(projgeoms)
+  const projGeoms = projPolys.map((p) => {
+    // This clones the points from vec3 to vec2
+    const cloned = p.vertices.map(vec2.clone)
+    return geom2.create([cloned])
+  })
+
+  const output = unionGeom2(projGeoms)
+  if (geometry.color) output.color = geometry.color
+  return output
 }
 
 /**
  * Project the given 3D geometry on to the given plane.
- * @param {Object} options - options for project
+ * @param {object} options - options for project
  * @param {Array} [options.axis=[0,0,1]] the axis of the plane (default is Z axis)
  * @param {Array} [options.origin=[0,0,0]] the origin of the plane
  * @param {...Object} objects - the list of 3D geometry to project
- * @return {geom2|Array} the projected 2D geometry, or a list of 2D projected geometry
+ * @return {Geom2|Array} the projected 2D geometry, or a list of 2D projected geometry
  * @alias module:modeling/extrusions.project
  *
  * @example
  * let myshape = project({}, sphere({radius: 20, segments: 5}))
  */
-const project = (options, ...objects) => {
+export const project = (options, ...objects) => {
   const defaults = {
     axis: [0, 0, 1], // Z axis
     origin: [0, 0, 0]
   }
   const { axis, origin } = Object.assign({ }, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   options = { axis, origin }
 
   const results = objects.map((object) => {
     // if (path.isA(object)) return project(options, object)
     // if (geom2.isA(object)) return project(options, object)
     if (geom3.isA(object)) return projectGeom3(options, object)
+    if (Array.isArray(object)) return project(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
 }
-
-module.exports = project