@jscad/modeling 2.11.1 → 3.0.0-alpha.0

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

@@ -1,11 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const comparePoints = require('../../../test/helpers/comparePoints')
+import { comparePoints } from '../../../test/helpers/index.js'
 
-const { geom2, geom3 } = require('../../geometries')
-const { cube, torus } = require('../../primitives')
+import { colorize } from '../../colors/index.js'
 
-const { project } = require('./index')
+import { geom2, geom3 } from '../../geometries/index.js'
+
+import { measureArea } from '../../measurements/index.js'
+
+import { cube, torus } from '../../primitives/index.js'
+
+import { project } from './index.js'
 
 test('project (defaults)', (t) => {
   const geometry0 = geom3.create()
@@ -22,102 +27,130 @@ test('project (defaults)', (t) => {
   t.is(results[3], geometry3)
   t.is(results[4], geometry4)
 
-  const result = project({ }, torus({ outerSegments: 4 }))
+  const result = project({ }, torus({ innerSegments: 4, outerSegments: 4 }))
   t.notThrows(() => geom2.validate(result))
   const pts = geom2.toPoints(result)
   const exp = [
-    [0, -5.000013333333333],
-    [5.000013333333333, 0],
-    [-5.000013333333333, 0],
-    [0, 2.9999933333333333],
-    [-2.9999933333333333, 0],
-    [0, -2.9999933333333333],
-    [2.9999933333333333, 0],
-    [0, 5.000013333333333]
+    [-5, 0],
+    [0, -5],
+    [5, 0],
+    [0, 5],
+    [0, 3],
+    [3, 0],
+    [0, -3],
+    [-3, 0]
   ]
   t.true(comparePoints(pts, exp))
 })
 
-test('project (X and Y axis)', (t) => {
+test('project torus (X and Y axis)', (t) => {
   let result = project({ axis: [1, 0, 0], origin: [1, 0, 0] }, torus({ outerSegments: 4 }))
   t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 19.12144515225805)
   let pts = geom2.toPoints(result)
   let exp = [
-    [-0.19511333333333336, -4.98078],
-    [0, -5.000006666666668],
-    [0, 5.000006666666668],
-    [0.3826666666666667, 4.923893333333334],
-    [-0.3826666666666667, -4.923893333333334],
-    [0.19511333333333336, -4.98078],
-    [-0.19511333333333336, 4.98078],
-    [-0.5555666666666668, -4.831446666666667],
-    [0.5555666666666668, 4.831446666666667],
-    [-0.3826666666666667, 4.923893333333334],
-    [0.3826666666666667, -4.923893333333334],
-    [0.7070933333333335, 4.707126666666667],
-    [-0.7070933333333335, -4.707126666666667],
-    [0.5555666666666668, -4.831446666666667],
-    [-0.5555666666666668, 4.831446666666667],
-    [0.8314600000000001, 4.555553333333334],
-    [-0.8314600000000001, -4.555553333333334],
-    [0.7070933333333335, -4.707126666666667],
-    [-0.7070933333333335, 4.707126666666667],
-    [-0.9238600000000001, -4.382700000000001],
-    [0.9238600000000001, 4.382700000000001],
-    [-0.8314600000000001, 4.555553333333334],
-    [0.8314600000000001, -4.555553333333334],
-    [0.9807933333333334, 4.1951],
-    [-0.9807933333333334, -4.1951],
-    [0.9238600000000001, -4.382700000000001],
-    [-0.9238600000000001, 4.382700000000001],
-    [1.0000200000000001, 3.999986666666667],
-    [-1.0000200000000001, -3.999986666666667],
-    [1.0000200000000001, -3.999986666666667],
-    [-1.0000200000000001, 3.999986666666667],
-    [-0.9807933333333334, 4.1951],
-    [0.9807933333333334, -4.1951],
-    [0.19511333333333336, 4.98078]
+    [-1, -4],
+    [-0.9807852804032304, -4.195090322016128],
+    [-0.9238795325112867, -4.38268343236509],
+    [-0.8314696123025452, -4.555570233019602],
+    [-0.7071067811865475, -4.707106781186548],
+    [-0.5555702330196022, -4.831469612302545],
+    [-0.3826834323650898, -4.923879532511287],
+    [-0.19509032201612825, -4.98078528040323],
+    [0, -5],
+    [0.19509032201612872, -4.98078528040323],
+    [0.3826834323650904, -4.923879532511286],
+    [0.5555702330196022, -4.831469612302545],
+    [0.7071067811865477, -4.707106781186547],
+    [0.8314696123025455, -4.555570233019602],
+    [0.9238795325112866, -4.38268343236509],
+    [0.9807852804032304, -4.195090322016128],
+    [1, -4],
+    [1, 0],
+    [1, 4],
+    [0.9807852804032304, 4.195090322016128],
+    [0.9238795325112866, 4.38268343236509],
+    [0.8314696123025455, 4.555570233019602],
+    [0.7071067811865477, 4.707106781186547],
+    [0.5555702330196022, 4.831469612302545],
+    [0.3826834323650904, 4.923879532511286],
+    [0.19509032201612872, 4.98078528040323],
+    [0, 5],
+    [-0.19509032201612825, 4.98078528040323],
+    [-0.3826834323650898, 4.923879532511287],
+    [-0.5555702330196022, 4.831469612302545],
+    [-0.7071067811865475, 4.707106781186548],
+    [-0.8314696123025452, 4.555570233019602],
+    [-0.9238795325112867, 4.38268343236509],
+    [-0.9807852804032304, 4.195090322016128],
+    [-1, 4],
+    [-1, 0]
   ]
   t.true(comparePoints(pts, exp))
 
   result = project({ axis: [0, 1, 0], origin: [0, -1, 0] }, torus({ outerSegments: 4 }))
   t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 19.12144515225805)
   pts = geom2.toPoints(result)
   exp = [
-    [4.98078, -0.19511333333333336],
-    [5.000006666666668, 0],
-    [-5.000006666666668, 0],
-    [-4.923893333333334, 0.3826666666666667],
-    [4.923893333333334, -0.3826666666666667],
-    [4.98078, 0.19511333333333336],
-    [-4.98078, -0.19511333333333336],
-    [4.831446666666667, -0.5555666666666668],
-    [-4.831446666666667, 0.5555666666666668],
-    [-4.923893333333334, -0.3826666666666667],
-    [4.923893333333334, 0.3826666666666667],
-    [-4.707126666666667, 0.7070933333333335],
-    [4.707126666666667, -0.7070933333333335],
-    [4.831446666666667, 0.5555666666666668],
-    [-4.831446666666667, -0.5555666666666668],
-    [4.555553333333334, -0.8314600000000001],
-    [-4.555553333333334, 0.8314600000000001],
-    [4.707126666666667, 0.7070933333333335],
-    [-4.707126666666667, -0.7070933333333335],
-    [4.382700000000001, -0.9238600000000001],
-    [-4.382700000000001, 0.9238600000000001],
-    [-4.555553333333334, -0.8314600000000001],
-    [4.555553333333334, 0.8314600000000001],
-    [-4.1951, 0.9807933333333334],
-    [4.1951, -0.9807933333333334],
-    [4.382700000000001, 0.9238600000000001],
-    [-4.382700000000001, -0.9238600000000001],
-    [3.999986666666667, -1.0000200000000001],
-    [-3.999986666666667, 1.0000200000000001],
-    [3.999986666666667, 1.0000200000000001],
-    [-3.999986666666667, -1.0000200000000001],
-    [4.1951, 0.9807933333333334],
-    [-4.1951, -0.9807933333333334],
-    [-4.98078, 0.19511333333333336]
+    [-5, 0],
+    [-4.98078528040323, -0.19509032201612825],
+    [-4.923879532511287, -0.3826834323650898],
+    [-4.831469612302545, -0.5555702330196022],
+    [-4.707106781186548, -0.7071067811865475],
+    [-4.555570233019602, -0.8314696123025452],
+    [-4.38268343236509, -0.9238795325112867],
+    [-4.195090322016128, -0.9807852804032304],
+    [-4, -1],
+    [0, -1],
+    [4, -1],
+    [4.195090322016128, -0.9807852804032304],
+    [4.38268343236509, -0.9238795325112867],
+    [4.555570233019602, -0.8314696123025452],
+    [4.707106781186548, -0.7071067811865475],
+    [4.831469612302545, -0.5555702330196022],
+    [4.923879532511287, -0.3826834323650898],
+    [4.98078528040323, -0.19509032201612825],
+    [5, 0],
+    [4.98078528040323, 0.19509032201612872],
+    [4.923879532511286, 0.3826834323650904],
+    [4.831469612302545, 0.5555702330196022],
+    [4.707106781186547, 0.7071067811865477],
+    [4.555570233019602, 0.8314696123025455],
+    [4.38268343236509, 0.9238795325112866],
+    [4.195090322016128, 0.9807852804032304],
+    [4, 1],
+    [0, 1],
+    [-4, 1],
+    [-4.195090322016128, 0.9807852804032304],
+    [-4.38268343236509, 0.9238795325112866],
+    [-4.555570233019602, 0.8314696123025455],
+    [-4.707106781186547, 0.7071067811865477],
+    [-4.831469612302545, 0.5555702330196022],
+    [-4.923879532511286, 0.3826834323650904],
+    [-4.98078528040323, 0.19509032201612872]
   ]
   t.true(comparePoints(pts, exp))
 })
+
+test('project torus (martinez issue #155)', (t) => {
+  const result = project(
+    { axis: [0, 1, 0], origin: [0, -1, 0] },
+    torus({ innerSegments: 8, outerSegments: 4 })
+  )
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 21.15545050788201)
+})
+
+test('project: preserves color', (t) => {
+  const redCube = colorize([1, 0, 0], cube())
+  const result = project({ }, redCube)
+  t.deepEqual(result.color, [1, 0, 0, 1])
+})
+
+test('project: empty geometry', (t) => {
+  const obj = geom3.create()
+  const result = project({ }, obj)
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 0)
+})

package/src/operations/hulls/hull.d.ts

@@ -1,8 +1,6 @@
-import { Geom2, Geom3, Path2 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geom2, Geom3, Path2 } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export default hull
-
-declare function hull(...geometries: RecursiveArray<Geom2>): Geom2
-declare function hull(...geometries: RecursiveArray<Geom3>): Geom3
-declare function hull(...geometries: RecursiveArray<Path2>): Path2
+export function hull(...geometries: RecursiveArray<Geom2>): Geom2
+export function hull(...geometries: RecursiveArray<Geom3>): Geom3
+export function hull(...geometries: RecursiveArray<Path2>): Path2

package/src/operations/hulls/hull.js

@@ -1,19 +1,19 @@
-const flatten = require('../../utils/flatten')
-const areAllShapesTheSameType = require('../../utils/areAllShapesTheSameType')
+import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
+import { flatten } from '../../utils/flatten.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
 
-const hullPath2 = require('./hullPath2')
-const hullGeom2 = require('./hullGeom2')
-const hullGeom3 = require('./hullGeom3')
+import { hullPath2 } from './hullPath2.js'
+import { hullGeom2 } from './hullGeom2.js'
+import { hullGeom3 } from './hullGeom3.js'
 
 /**
  * Create a convex hull of the given geometries.
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
  * @param {...Objects} geometries - list of geometries from which to create a hull
- * @returns {geom2|geom3} new geometry
+ * @returns {Geom2|Geom3} new geometry
  * @alias module:modeling/hulls.hull
  *
  * @example
@@ -32,7 +32,7 @@ const hullGeom3 = require('./hullGeom3')
  *       |       |          \        |
  *       +-------+           +-------+
  */
-const hull = (...geometries) => {
+export const hull = (...geometries) => {
   geometries = flatten(geometries)
   if (geometries.length === 0) throw new Error('wrong number of arguments')
 
@@ -48,5 +48,3 @@ const hull = (...geometries) => {
   // FIXME should this throw an error for unknown geometries?
   return geometry
 }
-
-module.exports = hull

package/src/operations/hulls/hull.test.js

@@ -1,69 +1,67 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
+import { measureArea } from '../../measurements/measureArea.js'
+import { sphere, cuboid, ellipsoid } from '../../primitives/index.js'
+import { center } from '../transforms/index.js'
 
-const { sphere, cuboid, ellipsoid } = require('../../primitives')
+import { hull } from './index.js'
 
-const { center } = require('../transforms/center')
-
-const { hull } = require('./index')
-
-const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 test('hull (single, geom2)', (t) => {
   let geometry = geom2.create()
 
   let obs = hull(geometry)
   let pts = geom2.toPoints(obs)
-
-  t.notThrows(() => geom2.validate(geometry))
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 0)
   t.is(pts.length, 0)
 
-  geometry = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  geometry = geom2.create([[[5, 5], [-5, 5], [-5, -5], [5, -5]]])
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
-
-  t.notThrows(() => geom2.validate(geometry))
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 100)
   t.is(pts.length, 4)
 
   // convex C shape
-  geometry = geom2.fromPoints([
-    [5.00000, 8.66025],
-    [-5.00000, 8.66025],
-    [-10.00000, 0.00000],
-    [-5.00000, -8.66025],
-    [5.00000, -8.66025],
-    [6.00000, -6.92820],
-    [-2.00000, -6.92820],
-    [-6.00000, 0.00000],
-    [-2.00000, 6.92820],
-    [6.00000, 6.92820]
-  ])
+  geometry = geom2.create([[
+    [5, 8.66025],
+    [-5, 8.66025],
+    [-10, 0],
+    [-5, -8.66025],
+    [5, -8.66025],
+    [6, -6.92820],
+    [-2, -6.92820],
+    [-6, 0],
+    [-2, 6.92820],
+    [6, 6.92820]
+  ]])
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
-
-  t.notThrows(() => geom2.validate(geometry))
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 7)
 })
 
 test('hull (multiple, overlapping, geom2)', (t) => {
-  const geometry1 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
-  const geometry2 = geom2.fromPoints([[3, 3], [-3, 3], [-3, -3], [3, -3]])
-  const geometry3 = geom2.fromPoints([[6, 3], [-6, 3], [-6, -3], [6, -3]])
+  const geometry1 = geom2.create([[[5, 5], [-5, 5], [-5, -5], [5, -5]]])
+  const geometry2 = geom2.create([[[3, 3], [-3, 3], [-3, -3], [3, -3]]])
+  const geometry3 = geom2.create([[[6, 3], [-6, 3], [-6, -3], [6, -3]]])
 
   // convex C shape
-  const geometry4 = geom2.fromPoints([
-    [5.00000, 8.66025],
-    [-5.00000, 8.66025],
-    [-10.00000, 0.00000],
-    [-5.00000, -8.66025],
-    [5.00000, -8.66025],
-    [6.00000, -6.92820],
-    [-2.00000, -6.92820],
-    [-6.00000, 0.00000],
-    [-2.00000, 6.92820],
-    [6.00000, 6.92820]
-  ])
+  const geometry4 = geom2.create([[
+    [5, 8.66025],
+    [-5, 8.66025],
+    [-10, 0],
+    [-5, -8.66025],
+    [5, -8.66025],
+    [6, -6.92820],
+    [-2, -6.92820],
+    [-6, 0],
+    [-2, 6.92820],
+    [6, 6.92820]
+  ]])
 
   // same
   let obs = hull(geometry1, geometry1)
@@ -94,24 +92,24 @@ test('hull (multiple, overlapping, geom2)', (t) => {
 })
 
 test('hull (multiple, various, geom2)', (t) => {
-  const geometry1 = geom2.fromPoints([[6, 6], [0, 6], [0, 0], [6, 0]])
-  const geometry2 = geom2.fromPoints([[6, 3], [-6, 3], [-6, -3], [6, -3]])
-  const geometry3 = geom2.fromPoints([[-10, -10], [0, -20], [10, -10]])
+  const geometry1 = geom2.create([[[6, 6], [0, 6], [0, 0], [6, 0]]])
+  const geometry2 = geom2.create([[[6, 3], [-6, 3], [-6, -3], [6, -3]]])
+  const geometry3 = geom2.create([[[-10, -10], [0, -20], [10, -10]]])
 
   // convex C shape
-  const geometry4 = geom2.fromPoints([
-    [5.00000, 8.66025],
-    [-5.00000, 8.66025],
-    [-10.00000, 0.00000],
-    [-5.00000, -8.66025],
-    [5.00000, -8.66025],
-    [6.00000, -6.92820],
-    [-2.00000, -6.92820],
-    [-6.00000, 0.00000],
-    [-2.00000, 6.92820],
-    [6.00000, 6.92820]
-  ])
-  const geometry5 = geom2.fromPoints([[-17, -17], [-23, -17], [-23, -23], [-17, -23]])
+  const geometry4 = geom2.create([[
+    [5, 8.66025],
+    [-5, 8.66025],
+    [-10, 0],
+    [-5, -8.66025],
+    [5, -8.66025],
+    [6, -6.92820],
+    [-2, -6.92820],
+    [-6, 0],
+    [-2, 6.92820],
+    [6, 6.92820]
+  ]])
+  const geometry5 = geom2.create([[[-17, -17], [-23, -17], [-23, -23], [-17, -23]]])
 
   let obs = hull(geometry1, geometry2)
   let pts = geom2.toPoints(obs)

package/src/operations/hulls/hullChain.d.ts

@@ -1,8 +1,6 @@
-import { Geom2, Geom3, Path2 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geom2, Geom3, Path2 } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export default hullChain
-
-declare function hullChain(...geometries: RecursiveArray<Geom2>): Geom2
-declare function hullChain(...geometries: RecursiveArray<Geom3>): Geom3
-declare function hullChain(...geometries: RecursiveArray<Path2>): Path2
+export function hullChain(...geometries: RecursiveArray<Geom2>): Geom2
+export function hullChain(...geometries: RecursiveArray<Geom3>): Geom3
+export function hullChain(...geometries: RecursiveArray<Path2>): Path2

package/src/operations/hulls/hullChain.js

@@ -1,8 +1,8 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const union = require('../booleans/union')
+import { union } from '../booleans/union.js'
 
-const hull = require('./hull')
+import { hull } from './hull.js'
 
 /**
  * Create a chain of hulled geometries from the given geometries.
@@ -10,11 +10,11 @@ const hull = require('./hull')
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
  *
  * @param {...Objects} geometries - list of geometries from which to create a hull
- * @returns {geom2|geom3} new geometry
+ * @returns {Geom2|Geom3} new geometry
  * @alias module:modeling/hulls.hullChain
  *
  * @example
- * let newshape = hullChain(rectangle({center: [-5,-5]}), circle({center: [0,0]}), rectangle({center: [5,5]}))
+ * let newShape = hullChain(rectangle({center: [-5,-5]}), circle({center: [0,0]}), rectangle({center: [5,5]}))
  *
  * @example
  * +-------+   +-------+     +-------+   +------+
@@ -29,15 +29,15 @@ const hull = require('./hull')
  *       |       |               \         /
  *       +-------+                +-------+
  */
-const hullChain = (...geometries) => {
+export const hullChain = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length < 2) throw new Error('wrong number of arguments')
-
   const hulls = []
+
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  if (geometries.length === 1) hulls.push(geometries[0])
+
   for (let i = 1; i < geometries.length; i++) {
     hulls.push(hull(geometries[i - 1], geometries[i]))
   }
   return union(hulls)
 }
-
-module.exports = hullChain

package/src/operations/hulls/hullChain.test.js

@@ -1,12 +1,21 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom2, geom3 } = require('../../geometries')
+import { geom2, geom3 } from '../../geometries/index.js'
+import { measureArea } from '../../measurements/measureArea.js'
+import { square } from '../../primitives/square.js'
 
-const { hullChain } = require('./index')
+import { hullChain } from './index.js'
+
+test('hullChain: hullChain single geometry', (t) => {
+  const result = hullChain([ square({ size: 1 }) ])
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 1)
+  t.is(geom2.toPoints(result).length, 4)
+})
 
 test('hullChain (two, geom2)', (t) => {
-  const geometry1 = geom2.fromPoints([[6, 6], [3, 6], [3, 3], [6, 3]])
-  const geometry2 = geom2.fromPoints([[-6, -6], [-9, -6], [-9, -9], [-6, -9]])
+  const geometry1 = geom2.create([[[6, 6], [3, 6], [3, 3], [6, 3]]])
+  const geometry2 = geom2.create([[[-6, -6], [-9, -6], [-9, -9], [-6, -9]]])
 
   // same
   let obs = hullChain(geometry1, geometry1)
@@ -24,9 +33,9 @@ test('hullChain (two, geom2)', (t) => {
 })
 
 test('hullChain (three, geom2)', (t) => {
-  const geometry1 = geom2.fromPoints([[6, 6], [3, 6], [3, 3], [6, 3]])
-  const geometry2 = geom2.fromPoints([[-6, -6], [-9, -6], [-9, -9], [-6, -9]])
-  const geometry3 = geom2.fromPoints([[-6, 6], [-3, 6], [-3, 9], [-6, 9]])
+  const geometry1 = geom2.create([[[6, 6], [3, 6], [3, 3], [6, 3]]])
+  const geometry2 = geom2.create([[[-6, -6], [-9, -6], [-9, -9], [-6, -9]]])
+  const geometry3 = geom2.create([[[-6, 6], [-3, 6], [-3, 9], [-6, 9]]])
 
   // open
   let obs = hullChain(geometry1, geometry2, geometry3)

package/src/operations/hulls/hullGeom2.js

@@ -1,16 +1,16 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const geom2 = require('../../geometries/geom2')
+import * as geom2 from '../../geometries/geom2/index.js'
 
-const hullPoints2 = require('./hullPoints2')
-const toUniquePoints = require('./toUniquePoints')
+import { hullPoints2 } from './hullPoints2.js'
+import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geom2 geometries.
  * @param {...geometries} geometries - list of geom2 geometries
- * @returns {geom2} new geometry
+ * @returns {Geom2} new geometry
  */
-const hullGeom2 = (...geometries) => {
+export const hullGeom2 = (...geometries) => {
   geometries = flatten(geometries)
 
   // extract the unique points from the geometries
@@ -22,7 +22,5 @@ const hullGeom2 = (...geometries) => {
   if (hullPoints.length < 3) return geom2.create()
 
   // assemble a new geometry from the list of points
-  return geom2.fromPoints(hullPoints)
+  return geom2.create([hullPoints])
 }
-
-module.exports = hullGeom2

package/src/operations/hulls/hullGeom3.js

@@ -1,17 +1,17 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as poly3 from '../../geometries/poly3/index.js'
 
-const quickhull = require('./quickhull')
-const toUniquePoints = require('./toUniquePoints')
+import { runner } from './quickhull/index.js'
+import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geometries (geom3).
  * @param {...geometries} geometries - list of geom3 geometries
- * @returns {geom3} new geometry
+ * @returns {Geom3} new geometry
  */
-const hullGeom3 = (...geometries) => {
+export const hullGeom3 = (...geometries) => {
   geometries = flatten(geometries)
 
   if (geometries.length === 1) return geometries[0]
@@ -19,7 +19,7 @@ const hullGeom3 = (...geometries) => {
   // extract the unique vertices from the geometries
   const unique = toUniquePoints(geometries)
 
-  const faces = quickhull(unique, { skipTriangulation: true })
+  const faces = runner(unique, { skipTriangulation: true })
 
   const polygons = faces.map((face) => {
     const vertices = face.map((index) => unique[index])
@@ -28,5 +28,3 @@ const hullGeom3 = (...geometries) => {
 
   return geom3.create(polygons)
 }
-
-module.exports = hullGeom3

package/src/operations/hulls/hullPath2.js

@@ -1,16 +1,16 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const path2 = require('../../geometries/path2')
+import * as path2 from '../../geometries/path2/index.js'
 
-const hullPoints2 = require('./hullPoints2')
-const toUniquePoints = require('./toUniquePoints')
+import { hullPoints2 } from './hullPoints2.js'
+import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geometries (path2).
  * @param {...geometries} geometries - list of path2 geometries
- * @returns {path2} new geometry
+ * @returns {Path2} new geometry
  */
-const hullPath2 = (...geometries) => {
+export const hullPath2 = (...geometries) => {
   geometries = flatten(geometries)
 
   // extract the unique points from the geometries
@@ -21,5 +21,3 @@ const hullPath2 = (...geometries) => {
   // assemble a new geometry from the list of points
   return path2.fromPoints({ closed: true }, hullPoints)
 }
-
-module.exports = hullPath2