@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/operations/{expansions/expandGeom3.test.js → offsets/offsetGeom3.test.js}

@@ -1,9 +1,67 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom3, poly3 } = require('../../geometries')
-const expandGeom3 = require('./expandGeom3')
+import { comparePoints } from '../../../test/helpers/index.js'
 
-test('expandGeom3: expand completes properly, issue 876', async (t) => {
+import { colorize } from '../../colors/index.js'
+import { geom3, poly3 } from '../../geometries/index.js'
+import { measureVolume } from '../../measurements/index.js'
+import { cube, sphere } from '../../primitives/index.js'
+
+import { offset } from './index.js'
+
+test('offset: offset empty geom3', (t) => {
+  const geometry = geom3.create()
+  const result = offset({ }, geometry)
+  t.notThrows(() => geom3.validate(result))
+  t.is(measureVolume(result), 0)
+  t.is(geom3.toPolygons(result).length, 0)
+  t.is(geom3.toPoints(result).length, 0)
+})
+
+test('offset: offset geom3 preserves color', (t) => {
+  const geometry = colorize([1, 0, 0], cube({ }))
+  const result = offset({ }, geometry)
+  t.deepEqual(result.color, [1, 0, 0, 1])
+})
+
+test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
+  const polygonsAsPoints = [
+    [[-5, -5, -5], [-5, -5, 15], [-5, 15, 15], [-5, 15, -5]],
+    [[15, -5, -5], [15, 15, -5], [15, 15, 15], [15, -5, 15]],
+    [[-5, -5, -5], [15, -5, -5], [15, -5, 15], [-5, -5, 15]],
+    [[-5, 15, -5], [-5, 15, 15], [15, 15, 15], [15, 15, -5]],
+    [[-5, -5, -5], [-5, 15, -5], [15, 15, -5], [15, -5, -5]],
+    [[-5, -5, 15], [15, -5, 15], [15, 15, 15], [-5, 15, 15]]
+  ]
+  const geometry = geom3.fromPoints(polygonsAsPoints)
+
+  const obs = offset({ delta: 2, corners: 'round', segments: 8 }, geometry)
+  const pts = geom3.toPoints(obs)
+  const exp0 = [
+    [-7, -5, -5],
+    [-7, -5, 15],
+    [-7, 15, 15],
+    [-7, 15, -5]
+  ]
+  const exp61 = [
+    [15, -7, 15],
+    [16.414213562373096, -6.414213562373095, 15],
+    [16, -6.414213562373095, 16]
+  ]
+
+  t.notThrows.skip(() => geom3.validate(obs))
+  t.is(pts.length, 62)
+  t.true(comparePoints(pts[0], exp0))
+  t.true(comparePoints(pts[61], exp61))
+
+  const geometry2 = sphere({ radius: 5, segments: 8 })
+  const obs2 = offset({ delta: 5 }, geometry2)
+  const pts2 = geom3.toPoints(obs2)
+  t.notThrows.skip(() => geom3.validate(obs2))
+  t.is(pts2.length, 864)
+})
+
+test('offsetGeom3: offset completes properly, issue 876', async (t) => {
   setTimeout(() => t.fail(), 1000)
   const polies = [
     poly3.create([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
@@ -25,7 +83,7 @@ test('expandGeom3: expand completes properly, issue 876', async (t) => {
   const sub = geom3.create(polies)
 
   return new Promise((resolve, reject) => {
-    expandGeom3({ delta: 1.3, corners: 'round', segments: 12 }, sub)
+    offset({ delta: 1.3, corners: 'round', segments: 12 }, sub)
     t.pass()
     resolve()
   })

package/src/operations/{expansions/expandPath2.js → offsets/offsetPath2.js}

@@ -1,30 +1,28 @@
-const area = require('../../maths/utils/area')
+import { area } from '../../maths/utils/area.js'
 
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-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'
+import { circle } from '../../primitives/circle.js'
 
-const offsetFromPoints = require('./offsetFromPoints')
+import { offsetFromPoints } from './offsetFromPoints.js'
 
-const createGeometryFromClosedOffsets = (paths) => {
+const createGeometryFromClosedPath = (paths) => {
   let { external, internal } = paths
+  if (external.length < 2) return geom2.create()
   if (area(external) < 0) {
     external = external.reverse()
   } else {
     internal = internal.reverse()
   }
-  // NOTE: creating path2 from the points ensures proper closure
-  const externalPath = path2.fromPoints({ closed: true }, external)
-  const internalPath = path2.fromPoints({ closed: true }, internal)
-  const externalSides = geom2.toSides(geom2.fromPoints(path2.toPoints(externalPath)))
-  const internalSides = geom2.toSides(geom2.fromPoints(path2.toPoints(internalPath)))
-  externalSides.push(...internalSides)
-  return geom2.create(externalSides)
+  return geom2.create([external, internal])
 }
 
-const createGeometryFromExpandedOpenPath = (paths, segments, corners, delta) => {
+const createGeometryFromOpenPath = (paths, segments, corners, delta) => {
   const { points, external, internal } = paths
+  if (points.length === 0) return geom2.create()
+  if (points.length === 1) return circle({ center: points[0], radius: delta })
   const capSegments = Math.floor(segments / 2) // rotation is 180 degrees
   const e2iCap = []
   const i2eCap = []
@@ -51,27 +49,26 @@ const createGeometryFromExpandedOpenPath = (paths, segments, corners, delta) =>
   }
   const allPoints = []
   allPoints.push(...external, ...e2iCap, ...internal.reverse(), ...i2eCap)
-  return geom2.fromPoints(allPoints)
+  return geom2.create([allPoints])
 }
 
 /*
  * Expand the given geometry (path2) using the given options (if any).
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+) of expansion
- * @param {String} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
- * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {path2} geometry - the geometry to expand
- * @returns {geom2} expanded geometry
+ * @param {object} options - options for offset
+ * @param {number} [options.delta=1] - delta (+) of expansion
+ * @param {string} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
+ * @param {number} [options.segments=16] - number of segments when creating round corners
+ * @param {Path2} geometry - the geometry to offset
+ * @returns {Geom2} offset geometry
  */
-const expandPath2 = (options, geometry) => {
+export const offsetPath2 = (options, geometry) => {
   const defaults = {
     delta: 1,
     corners: 'edge',
     segments: 16
   }
 
-  options = Object.assign({ }, defaults, options)
-  const { delta, corners, segments } = options
+  const { delta, corners, segments } = Object.assign({ }, defaults, options)
 
   if (delta <= 0) throw new Error('the given delta must be positive for paths')
 
@@ -81,19 +78,16 @@ const expandPath2 = (options, geometry) => {
 
   const closed = geometry.isClosed
   const points = path2.toPoints(geometry)
-  if (points.length === 0) throw new Error('the given geometry cannot be empty')
 
   const paths = {
-    points: points,
+    points,
     external: offsetFromPoints({ delta, corners, segments, closed }, points),
     internal: offsetFromPoints({ delta: -delta, corners, segments, closed }, points)
   }
 
-  if (geometry.isClosed) {
-    return createGeometryFromClosedOffsets(paths)
-  } else {
-    return createGeometryFromExpandedOpenPath(paths, segments, corners, delta)
-  }
+  const output = geometry.isClosed ?
+    createGeometryFromClosedPath(paths) :
+    createGeometryFromOpenPath(paths, segments, corners, delta)
+  if (geometry.color) output.color = geometry.color
+  return output
 }
-
-module.exports = expandPath2

package/src/operations/offsets/offsetPath2.test.js

@@ -0,0 +1,103 @@
+import test from 'ava'
+
+import { comparePoints, nearlyEqual } from '../../../test/helpers/index.js'
+
+import { colorize } from '../../colors/index.js'
+import { geom2, path2 } from '../../geometries/index.js'
+import { measureArea, measureBoundingBox } from '../../measurements/index.js'
+import { area } from '../../maths/utils/area.js'
+import { TAU } from '../../maths/constants.js'
+
+import { offset } from './index.js'
+
+test('offset: offset empty path2', (t) => {
+  const geometry = path2.create()
+  const result = offset({ corners: 'round' }, geometry)
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 0)
+  t.is(geom2.toPoints(result).length, 0)
+})
+
+test('offset: offset empty path2 closed', (t) => {
+  const geometry = path2.fromPoints({ closed: true }, [])
+  const result = offset({ }, geometry)
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 0)
+  t.is(geom2.toPoints(result).length, 0)
+})
+
+test('offset: offset single point path2 round', (t) => {
+  const geometry = path2.create([[2, 2]])
+  const result = offset({ delta: 1, corners: 'round', segments: 16 }, geometry)
+  t.notThrows(() => geom2.validate(result))
+  nearlyEqual(t, measureArea(result), 3.12, 0.01)
+  t.is(geom2.toPoints(result).length, 32)
+})
+
+test('offset: offset path2 preserves color', (t) => {
+  const geometry = colorize([1, 0, 0], path2.create())
+  const result = offset({ }, geometry)
+  t.deepEqual(result.color, [1, 0, 0, 1])
+})
+
+test('offset: edge-expanding a straight line produces rectangle', (t) => {
+  const points = [[0, 0], [0, 10]]
+  const linePath2 = path2.fromPoints({ closed: false }, points)
+  const expandedPathGeom2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  const expandedPoints = geom2.toPoints(expandedPathGeom2)
+
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
+  t.is(area(expandedPoints), 40)
+  t.true(comparePoints(measureBoundingBox(expandedPathGeom2), [[-2, 0, 0], [2, 10, 0]]))
+})
+
+test('offset: edge-expanding a bent line produces expected geometry', (t) => {
+  const points = [[0, 0], [0, 10], [-5, 10]]
+  const linePath2 = path2.fromPoints({ closed: false }, points)
+  const expandedPathGeom2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  const expandedPoints = geom2.toPoints(expandedPathGeom2)
+
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
+  t.is(area(expandedPoints), 60)
+  const boundingBox = measureBoundingBox(expandedPathGeom2)
+  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})
+
+test('offset: edge-expanding a bent line, reversed points, produces expected geometry', (t) => {
+  const points = [[-5, 10], [0, 10], [0, 0]]
+  const linePath2 = path2.fromPoints({ closed: false }, points)
+  const expandedPathGeom2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
+  const expandedPoints = geom2.toPoints(expandedPathGeom2)
+
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
+  t.is(area(expandedPoints), 60)
+  const boundingBox = measureBoundingBox(expandedPathGeom2)
+  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})
+
+test('offset: round-expanding a bent line produces expected geometry', (t) => {
+  const delta = 2
+  const points = [[0, 0], [0, 10], [-5, 10]]
+  const linePath2 = path2.fromPoints({ closed: false }, points)
+  const expandedPathGeom2 = offset({ delta, corners: 'round', segments: 128 }, linePath2)
+  const expandedPoints = geom2.toPoints(expandedPathGeom2)
+
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
+  const expectedArea = 56 + TAU * delta * 1.25 // shape will have 1 and 1/4 circles
+  nearlyEqual(t, area(expandedPoints), expectedArea, 0.01, 'Measured area should be pretty close')
+  const boundingBox = measureBoundingBox(expandedPathGeom2)
+  t.true(comparePoints(boundingBox, [[-7, -2, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})
+
+test('offset: chamfer-expanding a bent line produces expected geometry', (t) => {
+  const delta = 2
+  const points = [[0, 0], [0, 10], [-5, 10]]
+  const linePath2 = path2.fromPoints({ closed: false }, points)
+  const expandedPathGeom2 = offset({ delta, corners: 'chamfer', segments: 8 }, linePath2)
+  const expandedPoints = geom2.toPoints(expandedPathGeom2)
+
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
+  t.is(area(expandedPoints), 58)
+  const boundingBox = measureBoundingBox(expandedPathGeom2)
+  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
+})

package/src/operations/{expansions/expandShell.js → offsets/offsetShell.js}

@@ -1,20 +1,20 @@
-const { EPS, TAU } = require('../../maths/constants')
+import { EPS, TAU } from '../../maths/constants.js'
 
-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 fnNumberSort = require('../../utils/fnNumberSort')
+import { fnNumberSort } from '../../utils/fnNumberSort.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 sphere = require('../../primitives/sphere')
+import { sphere } from '../../primitives/sphere.js'
 
-const retessellate = require('../modifiers/retessellate')
+import { retessellate } from '../modifiers/retessellate.js'
 
-const unionGeom3Sub = require('../booleans/unionGeom3Sub')
+import { unionGeom3Sub } from '../booleans/unionGeom3Sub.js'
 
-const extrudePolygon = require('./extrudePolygon')
+import { extrudePolygon } from './extrudePolygon.js'
 
 /*
  * Collect all planes adjacent to each vertex
@@ -61,10 +61,10 @@ const addUniqueAngle = (map, angle) => {
  * Cylinders are constructed around every side
  * Spheres are placed on every vertex
  * the result is a true expansion of the solid
- * @param  {Number} delta
- * @param  {Integer} segments
+ * @param  {number} delta
+ * @param  {number} segments
  */
-const expandShell = (options, geometry) => {
+export const offsetShell = (options, geometry) => {
   const defaults = {
     delta: 1,
     segments: 12
@@ -80,14 +80,14 @@ const expandShell = (options, geometry) => {
 
   // loop through the polygons
   // - extruded the polygon, and add to the composite result
-  // - add the plane to the unique vertice map
+  // - add the plane to the unique vertex map
   // - add the plane to the unique edge map
   const polygons = geom3.toPolygons(geometry)
-  polygons.forEach((polygon, index) => {
-    const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon), 2 * delta)
-    const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon)
-    const extrudedface = extrudePolygon(extrudevector, translatedpolygon)
-    result = unionGeom3Sub(result, extrudedface)
+  polygons.forEach((polygon) => {
+    const extrudeVector = vec3.scale(vec3.create(), poly3.plane(polygon), 2 * delta)
+    const translatedPolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudeVector, -0.5)), polygon)
+    const extrudedFace = extrudePolygon(extrudeVector, translatedPolygon)
+    result = unionGeom3Sub(result, extrudedFace)
 
     const vertices = polygon.vertices
     for (let i = 0; i < vertices.length; i++) {
@@ -106,14 +106,14 @@ const expandShell = (options, geometry) => {
   edges2planes.forEach((item) => {
     const edge = item[0]
     const planes = item[1]
-    const startpoint = edge[0]
-    const endpoint = edge[1]
+    const startVertex = edge[0]
+    const endVertex = edge[1]
 
     // our x,y and z vectors:
-    const zbase = vec3.subtract(vec3.create(), endpoint, startpoint)
-    vec3.normalize(zbase, zbase)
-    const xbase = planes[0]
-    const ybase = vec3.cross(vec3.create(), xbase, zbase)
+    const zBase = vec3.subtract(vec3.create(), endVertex, startVertex)
+    vec3.normalize(zBase, zBase)
+    const xBase = planes[0]
+    const yBase = vec3.cross(vec3.create(), xBase, zBase)
 
     // make a list of angles that the cylinder should traverse:
     let angles = []
@@ -125,9 +125,9 @@ const expandShell = (options, geometry) => {
 
     // and also at every normal of all touching planes:
     for (let i = 0, iMax = planes.length; i < iMax; i++) {
-      const planenormal = planes[i]
-      const si = vec3.dot(ybase, planenormal)
-      const co = vec3.dot(xbase, planenormal)
+      const planeNormal = planes[i]
+      const si = vec3.dot(yBase, planeNormal)
+      const co = vec3.dot(xBase, planeNormal)
       let angle = Math.atan2(si, co)
 
       if (angle < 0) angle += TAU
@@ -141,42 +141,42 @@ const expandShell = (options, geometry) => {
     angles = angles.sort(fnNumberSort)
 
     // Now construct the cylinder by traversing all angles:
-    const numangles = angles.length
-    let prevp1
-    let prevp2
-    const startfacevertices = []
-    const endfacevertices = []
+    const numAngles = angles.length
+    let prevP1
+    let prevP2
+    const startFaceVertices = []
+    const endFaceVertices = []
     const polygons = []
-    for (let i = -1; i < numangles; i++) {
-      const angle = angles[(i < 0) ? (i + numangles) : i]
+    for (let i = -1; i < numAngles; i++) {
+      const angle = angles[(i < 0) ? (i + numAngles) : i]
       const si = Math.sin(angle)
       const co = Math.cos(angle)
-      vec3.scale(v1, xbase, co * delta)
-      vec3.scale(v2, ybase, si * delta)
+      vec3.scale(v1, xBase, co * delta)
+      vec3.scale(v2, yBase, si * delta)
       vec3.add(v1, v1, v2)
-      const p1 = vec3.add(vec3.create(), startpoint, v1)
-      const p2 = vec3.add(vec3.create(), endpoint, v1)
+      const p1 = vec3.add(vec3.create(), startVertex, v1)
+      const p2 = vec3.add(vec3.create(), endVertex, v1)
       let skip = false
       if (i >= 0) {
-        if (vec3.distance(p1, prevp1) < EPS) {
+        if (vec3.distance(p1, prevP1) < EPS) {
           skip = true
         }
       }
       if (!skip) {
         if (i >= 0) {
-          startfacevertices.push(p1)
-          endfacevertices.push(p2)
-          const points = [prevp2, p2, p1, prevp1]
-          const polygon = poly3.create(points)
+          startFaceVertices.push(p1)
+          endFaceVertices.push(p2)
+          const vertices = [prevP2, p2, p1, prevP1]
+          const polygon = poly3.create(vertices)
           polygons.push(polygon)
         }
-        prevp1 = p1
-        prevp2 = p2
+        prevP1 = p1
+        prevP2 = p2
       }
     }
-    endfacevertices.reverse()
-    polygons.push(poly3.create(startfacevertices))
-    polygons.push(poly3.create(endfacevertices))
+    endFaceVertices.reverse()
+    polygons.push(poly3.create(startFaceVertices))
+    polygons.push(poly3.create(endFaceVertices))
 
     const cylinder = geom3.create(polygons)
     result = unionGeom3Sub(result, cylinder)
@@ -192,14 +192,14 @@ const expandShell = (options, geometry) => {
     const xaxis = planes[0]
     // and find a suitable z axis. We will use the normal which is most perpendicular to the x axis:
     let bestzaxis = null
-    let bestzaxisorthogonality = 0
+    let bestzaxisOrthogonality = 0
     for (let i = 1; i < planes.length; i++) {
       const normal = planes[i]
       const cross = vec3.cross(v1, xaxis, normal)
-      const crosslength = vec3.length(cross)
-      if (crosslength > 0.05) { // FIXME why 0.05?
-        if (crosslength > bestzaxisorthogonality) {
-          bestzaxisorthogonality = crosslength
+      const crossLength = vec3.length(cross)
+      if (crossLength > 0.05) { // FIXME why 0.05?
+        if (crossLength > bestzaxisOrthogonality) {
+          bestzaxisOrthogonality = crossLength
           bestzaxis = normal
         }
       }
@@ -220,5 +220,3 @@ const expandShell = (options, geometry) => {
   })
   return retessellate(result)
 }
-
-module.exports = expandShell

package/src/operations/transforms/align.d.ts

@@ -1,7 +1,5 @@
-import { Geometry } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
-
-export default align
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 type NullableNumber = null | number
 
@@ -11,6 +9,6 @@ export interface AlignOptions {
   grouped?: boolean
 }
 
-declare function align<T extends Geometry>(options: AlignOptions, geometry: T): T
-declare function align<T extends Geometry>(options: AlignOptions, ...geometries: RecursiveArray<T>): Array<T>
-declare function align(options: AlignOptions, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+export function align<T extends Geometry>(options: AlignOptions, geometry: T): T
+export function align<T extends Geometry>(options: AlignOptions, ...geometries: RecursiveArray<T>): Array<T>
+export function align(options: AlignOptions, ...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/transforms/align.js

@@ -1,7 +1,9 @@
-const flatten = require('../../utils/flatten')
-const padArrayToLength = require('../../utils/padArrayToLength')
-const measureAggregateBoundingBox = require('../../measurements/measureAggregateBoundingBox')
-const { translate } = require('./translate')
+import { flatten } from '../../utils/flatten.js'
+import { padArrayToLength } from '../../utils/padArrayToLength.js'
+
+import { measureAggregateBoundingBox } from '../../measurements/measureAggregateBoundingBox.js'
+
+import { translate } from './translate.js'
 
 const validateOptions = (options) => {
   if (!Array.isArray(options.modes) || options.modes.length > 3) throw new Error('align(): modes must be an array of length <= 3')
@@ -50,10 +52,10 @@ const alignGeometries = (geometry, modes, relativeTo) => {
 
 /**
  * Align the boundaries of the given geometries using the given options.
- * @param {Object} options - options for aligning
+ * @param {object} options - options for aligning
  * @param {Array} [options.modes = ['center', 'center', 'min']] - the point on the geometries to align to for each axis. Valid options are "center", "max", "min", and "none".
  * @param {Array} [options.relativeTo = [0,0,0]] - The point one each axis on which to align the geometries upon.  If the value is null, then the corresponding value from the group's bounding box is used.
- * @param {Boolean} [options.grouped = false] - if true, transform all geometries by the same amount, maintaining the relative positions to each other.
+ * @param {boolean} [options.grouped = false] - if true, transform all geometries by the same amount, maintaining the relative positions to each other.
  * @param {...Object} geometries - the geometries to align
  * @return {Object|Array} the aligned geometry, or a list of aligned geometries
  * @alias module:modeling/transforms.align
@@ -61,7 +63,7 @@ const alignGeometries = (geometry, modes, relativeTo) => {
  * @example
  * let alignedGeometries = align({modes: ['min', 'center', 'none'], relativeTo: [10, null, 10], grouped: true }, geometries)
  */
-const align = (options, ...geometries) => {
+export const align = (options, ...geometries) => {
   const defaults = {
     modes: ['center', 'center', 'min'],
     relativeTo: [0, 0, 0],
@@ -85,5 +87,3 @@ const align = (options, ...geometries) => {
   }
   return geometries.length === 1 ? geometries[0] : geometries
 }
-
-module.exports = align

package/src/operations/transforms/align.test.js

@@ -1,11 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints } = require('../../../test/helpers')
-const { geom3 } = require('../../geometries')
-const { measureBoundingBox, measureAggregateBoundingBox } = require('../../measurements')
-const { cube } = require('../../primitives')
+import { comparePoints } from '../../../test/helpers/index.js'
 
-const { align } = require('./index')
+import { geom3 } from '../../geometries/index.js'
+import { measureBoundingBox, measureAggregateBoundingBox } from '../../measurements/index.js'
+import { cube } from '../../primitives/index.js'
+
+import { align } from './index.js'
 
 test('align: single object returns geometry unchanged if all axes are none', (t) => {
   const original = cube({ size: 4, center: [10, 10, 10] })

package/src/operations/transforms/center.d.ts

@@ -1,6 +1,6 @@
-import { Geometry } from '../../geometries/types'
-import Vec3 from '../../maths/vec3/type'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export interface CenterOptions {
   axes?: [boolean, boolean, boolean]

package/src/operations/transforms/center.js

@@ -1,12 +1,12 @@
-const flatten = require('../../utils/flatten')
+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 measureBoundingBox = require('../../measurements/measureBoundingBox')
+import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
 
-const { translate } = require('./translate')
+import { translate } from './translate.js'
 
 const centerGeometry = (options, object) => {
   const defaults = {
@@ -25,7 +25,7 @@ const centerGeometry = (options, object) => {
 
 /**
  * Center the given objects using the given options.
- * @param {Object} options - options for centering
+ * @param {object} options - options for centering
  * @param {Array} [options.axes=[true,true,true]] - axis of which to center, true or false
  * @param {Array} [options.relativeTo=[0,0,0]] - relative point of which to center the objects
  * @param {...Object} objects - the objects to center
@@ -35,7 +35,7 @@ const centerGeometry = (options, object) => {
  * @example
  * let myshape = center({axes: [true,false,false]}, sphere()) // center about the X axis
  */
-const center = (options, ...objects) => {
+export const center = (options, ...objects) => {
   const defaults = {
     axes: [true, true, true],
     relativeTo: [0, 0, 0]
@@ -64,7 +64,7 @@ const center = (options, ...objects) => {
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerX
  */
-const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
+export const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
 
 /**
  * Center the given objects about the Y axis.
@@ -72,7 +72,7 @@ const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerY
  */
-const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
+export const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
 
 /**
  * Center the given objects about the Z axis.
@@ -80,11 +80,4 @@ const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerZ
  */
-const centerZ = (...objects) => center({ axes: [false, false, true] }, objects)
-
-module.exports = {
-  center,
-  centerX,
-  centerY,
-  centerZ
-}
+export const centerZ = (...objects) => center({ axes: [false, false, true] }, objects)