@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/operations/transforms/center.js

@@ -1,12 +1,10 @@
-const flatten = require('../../utils/flatten')
+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 geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
+import { measureAggregateBoundingBox } from '../../measurements/measureAggregateBoundingBox.js'
 
-const measureBoundingBox = require('../../measurements/measureBoundingBox')
-
-const { translate } = require('./translate')
+import { translate } from './translate.js'
 
 const centerGeometry = (options, object) => {
   const defaults = {
@@ -15,7 +13,7 @@ const centerGeometry = (options, object) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  const bounds = measureBoundingBox(object)
+  const bounds = measureAggregateBoundingBox(object)
   const offset = [0, 0, 0]
   if (axes[0]) offset[0] = relativeTo[0] - (bounds[0][0] + ((bounds[1][0] - bounds[0][0]) / 2))
   if (axes[1]) offset[1] = relativeTo[1] - (bounds[0][1] + ((bounds[1][1] - bounds[0][1]) / 2))
@@ -25,7 +23,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 +33,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]
@@ -43,8 +41,6 @@ const center = (options, ...objects) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
   if (relativeTo.length !== 3) throw new Error('relativeTo must be an array of length 3')
 
   options = { axes, relativeTo }
@@ -53,6 +49,7 @@ const center = (options, ...objects) => {
     if (path2.isA(object)) return centerGeometry(options, object)
     if (geom2.isA(object)) return centerGeometry(options, object)
     if (geom3.isA(object)) return centerGeometry(options, object)
+    if (Array.isArray(object)) return centerGeometry(options, object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -64,7 +61,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 +69,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 +77,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)

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

@@ -1,10 +1,14 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { center, centerX, centerY, centerZ } = require('./index')
+import { measureArea, measureAggregateBoundingBox, measureVolume } from '../../measurements/index.js'
+
+import { square } from '../../primitives/index.js'
+
+import { center, centerX, centerY, centerZ } from './index.js'
 
 test('center: centering of a path2 produces expected changes to points', (t) => {
   const geometry = path2.fromPoints({}, [[5, 0], [0, 3], [-1, 0]])
@@ -23,18 +27,20 @@ test('center: centering of a path2 produces expected changes to points', (t) =>
 })
 
 test('center: centering of a geom2 produces expected changes to points', (t) => {
-  const geometry = geom2.fromPoints([[0, 0], [10, 0], [0, 10]])
+  const geometry = geom2.create([[[0, 0], [10, 0], [0, 10]]])
 
   // center about Y
   let centered = center({ axes: [false, true, false] }, geometry)
   let pts = geom2.toPoints(centered)
   const exp = [[0, -5], [10, -5], [0, 5]]
   t.notThrows(() => geom2.validate(centered))
+  t.is(measureArea(centered), measureArea(geometry))
   t.true(comparePoints(pts, exp))
 
   centered = centerY(geometry)
   pts = geom2.toPoints(centered)
   t.notThrows(() => geom2.validate(centered))
+  t.is(measureArea(centered), measureArea(geometry))
   t.true(comparePoints(pts, exp))
 })
 
@@ -61,11 +67,13 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-5, -7, 18], [5, -7, 18], [5, 13, 18], [-5, 13, 18]]
   ]
   t.notThrows(() => geom3.validate(centered))
+  t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerX(geometry)
   pts = geom3.toPoints(centered)
   t.notThrows(() => geom3.validate(centered))
+  t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Y
@@ -80,11 +88,13 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -10, 18], [8, -10, 18], [8, 10, 18], [-2, 10, 18]]
   ]
   t.notThrows(() => geom3.validate(centered))
+  t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerY(geometry)
   pts = geom3.toPoints(centered)
   t.notThrows(() => geom3.validate(centered))
+  t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Z
@@ -99,18 +109,20 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -7, 15], [8, -7, 15], [8, 13, 15], [-2, 13, 15]]
   ]
   t.notThrows(() => geom3.validate(centered))
+  t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerZ(geometry)
   pts = geom3.toPoints(centered)
   t.notThrows(() => geom3.validate(centered))
+  t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
 test('center: centering of multiple objects produces expected changes', (t) => {
   const junk = 'hello'
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
-  const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+  const geometry2 = geom2.create([[[-5, -5], [0, 5], [10, -5]]])
 
   const centered = center({ axes: [true, true, false], relativeTo: [10, 15, 0] }, junk, geometry1, geometry2)
 
@@ -126,3 +138,19 @@ test('center: centering of multiple objects produces expected changes', (t) => {
   t.notThrows(() => geom2.validate(centered[2]))
   t.true(comparePoints(pts2, exp2))
 })
+
+test('center multiple separate', (t) => {
+  const square1 = square({ size: 4, center: [10, 10] })
+  const square2 = square({ size: 6, center: [-10, -10] })
+  const obs = center({}, square1, square2)
+  t.notThrows(() => obs.map(geom2.validate))
+  t.deepEqual([[-3, -3, 0], [3, 3, 0]], measureAggregateBoundingBox(obs))
+})
+
+test('center multiple grouped', (t) => {
+  const square1 = square({ size: 4, center: [10, 10] })
+  const square2 = square({ size: 6, center: [-10, -10] })
+  const obs = center({}, [square1, square2])
+  t.notThrows(() => obs.map(geom2.validate))
+  t.deepEqual([[-12.5, -12.5, 0], [12.5, 12.5, 0]], measureAggregateBoundingBox(obs))
+})

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

@@ -1,9 +1,7 @@
-export { default as align, AlignOptions } from './align'
-export * from './center'
-export * from './mirror'
-export * from './rotate'
-export * from './scale'
-export * from './transform'
-export * from './translate'
-
-export as namespace transforms
+export { align, AlignOptions } from './align.js'
+export * from './center.js'
+export * from './mirror.js'
+export * from './rotate.js'
+export * from './scale.js'
+export * from './transform.js'
+export * from './translate.js'

package/src/operations/transforms/index.js

@@ -3,35 +3,14 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/transforms
  * @example
- * const { center, rotateX, translate } = require('@jscad/modeling').transforms
+ * import { center, rotateX, translate } from '@jscad/modeling'
  */
-module.exports = {
-  align: require('./align'),
+export { align } from './align.js'
 
-  center: require('./center').center,
-  centerX: require('./center').centerX,
-  centerY: require('./center').centerY,
-  centerZ: require('./center').centerZ,
+export { center, centerX, centerY, centerZ } from './center.js'
+export { mirror, mirrorX, mirrorY, mirrorZ } from './mirror.js'
+export { rotate, rotateX, rotateY, rotateZ } from './rotate.js'
+export { scale, scaleX, scaleY, scaleZ } from './scale.js'
+export { translate, translateX, translateY, translateZ } from './translate.js'
 
-  mirror: require('./mirror').mirror,
-  mirrorX: require('./mirror').mirrorX,
-  mirrorY: require('./mirror').mirrorY,
-  mirrorZ: require('./mirror').mirrorZ,
-
-  rotate: require('./rotate').rotate,
-  rotateX: require('./rotate').rotateX,
-  rotateY: require('./rotate').rotateY,
-  rotateZ: require('./rotate').rotateZ,
-
-  scale: require('./scale').scale,
-  scaleX: require('./scale').scaleX,
-  scaleY: require('./scale').scaleY,
-  scaleZ: require('./scale').scaleZ,
-
-  transform: require('./transform'),
-
-  translate: require('./translate').translate,
-  translateX: require('./translate').translateX,
-  translateY: require('./translate').translateY,
-  translateZ: require('./translate').translateZ
-}
+export { transform } from './transform.js'

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

@@ -1,6 +1,6 @@
-import { Geometry } from '../../geometries/types'
-import { Vec3 } from '../../maths/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { Vec3 } from '../../maths/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export interface MirrorOptions {
   origin?: Vec3

package/src/operations/transforms/mirror.js

@@ -1,15 +1,13 @@
-const flatten = require('../../utils/flatten')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as plane from '../../maths/plane/index.js'
 
-const mat4 = require('../../maths/mat4')
-const plane = require('../../maths/plane')
-
-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'
 
 /**
  * Mirror the given objects using the given options.
- * @param {Object} options - options for mirror
+ * @param {object} options - options for mirror
  * @param {Array} [options.origin=[0,0,0]] - the origin of the plane
  * @param {Array} [options.normal=[0,0,1]] - the normal vector of the plane
  * @param {...Object} objects - the objects to mirror
@@ -19,16 +17,13 @@ const path2 = require('../../geometries/path2')
  * @example
  * let myshape = mirror({normal: [0,0,10]}, cube({center: [0,0,15], radius: [20, 25, 5]}))
  */
-const mirror = (options, ...objects) => {
+export const mirror = (options, ...objects) => {
   const defaults = {
     origin: [0, 0, 0],
     normal: [0, 0, 1] // Z axis
   }
   const { origin, normal } = Object.assign({}, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const planeOfMirror = plane.fromNormalAndPoint(plane.create(), normal, origin)
   // verify the plane, i.e. check that the given normal was valid
   if (Number.isNaN(planeOfMirror[0])) {
@@ -41,6 +36,8 @@ const mirror = (options, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return mirror(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -52,7 +49,7 @@ const mirror = (options, ...objects) => {
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorX
  */
-const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
+export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, ...objects)
 
 /**
  * Mirror the given objects about the Y axis.
@@ -60,7 +57,7 @@ const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorY
  */
-const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
+export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, ...objects)
 
 /**
  * Mirror the given objects about the Z axis.
@@ -68,11 +65,4 @@ const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorZ
  */
-const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, objects)
-
-module.exports = {
-  mirror,
-  mirrorX,
-  mirrorY,
-  mirrorZ
-}
+export const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, ...objects)

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

@@ -1,12 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { measureArea } = require('../../measurements')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
-const { mirror, mirrorX, mirrorY, mirrorZ } = require('./index')
+import { mirror, mirrorX, mirrorY, mirrorZ } from './index.js'
 
 test('mirror: mirroring of path2 about X/Y produces expected changes to points', (t) => {
   const geometry = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
@@ -37,12 +37,12 @@ test('mirror: mirroring of path2 about X/Y produces expected changes to points',
 })
 
 test('mirror: mirroring of geom2 about X/Y produces expected changes to points', (t) => {
-  const geometry = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+  const geometry = geom2.create([[[-5, -5], [0, 5], [10, -5]]])
 
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
-  let exp = [[0, 5], [5, -5], [-10, -5]]
+  let exp = [[-10, -5], [0, 5], [5, -5]]
   t.notThrows(() => geom2.validate(mirrored))
   t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
@@ -56,7 +56,7 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = geom2.toPoints(mirrored)
-  exp = [[0, -5], [-5, 5], [10, 5]]
+  exp = [[10, 5], [0, -5], [-5, 5]]
   t.notThrows(() => geom2.validate(mirrored))
   t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
@@ -91,12 +91,14 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[2, 13, 18], [-8, 13, 18], [-8, -7, 18], [2, -7, 18]]
   ]
   t.notThrows(() => geom3.validate(mirrored))
+  t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
   t.deepEqual(obs, exp)
 
   mirrored = mirrorX(geometry)
   obs = geom3.toPoints(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
+  t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Y
@@ -111,11 +113,13 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[-2, -13, 18], [8, -13, 18], [8, 7, 18], [-2, 7, 18]]
   ]
   t.notThrows(() => geom3.validate(mirrored))
+  t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom3.toPoints(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
+  t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Z
@@ -130,18 +134,20 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[-2, 13, -18], [8, 13, -18], [8, -7, -18], [-2, -7, -18]]
   ]
   t.notThrows(() => geom3.validate(mirrored))
+  t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorZ(geometry)
   obs = geom3.toPoints(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
+  t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
 test('mirror: mirroring of multiple objects produces an array of mirrored objects', (t) => {
   const junk = 'hello'
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
-  const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+  const geometry2 = geom2.create([[[-5, -5], [0, 5], [10, -5]]])
 
   const mirrored = mirror({ normal: [0, 1, 0] }, junk, geometry1, geometry2)
   t.is(mirrored[0], junk)
@@ -152,7 +158,7 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
-  exp = [[0, -5], [-5, 5], [10, 5]]
+  exp = [[10, 5], [0, -5], [-5, 5]]
   t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

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

@@ -1,10 +1,10 @@
-import { Geometry } from '../../geometries/types'
-import { Vec1, Vec2, Vec3 } from '../../maths/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { Vec } from '../../maths/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export function rotate<T extends Geometry>(angles: Vec1 | Vec2 | Vec3, geometry: T): T
-export function rotate<T extends Geometry>(angles: Vec1 | Vec2 | Vec3, ...geometries: RecursiveArray<T>): Array<T>
-export function rotate(angles: Vec1 | Vec2 | Vec3, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+export function rotate<T extends Geometry>(angles: Vec, geometry: T): T
+export function rotate<T extends Geometry>(angles: Vec, ...geometries: RecursiveArray<T>): Array<T>
+export function rotate(angles: Vec, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
 
 export function rotateX<T extends Geometry>(angle: number, geometry: T): T
 export function rotateX<T extends Geometry>(angle: number, ...geometries: RecursiveArray<T>): Array<T>

package/src/operations/transforms/rotate.js

@@ -1,10 +1,8 @@
-const flatten = require('../../utils/flatten')
+import * as mat4 from '../../maths/mat4/index.js'
 
-const mat4 = require('../../maths/mat4')
-
-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'
 
 /**
  * Rotate the given objects using the given options.
@@ -14,14 +12,11 @@ const path2 = require('../../geometries/path2')
  * @alias module:modeling/transforms.rotate
  *
  * @example
- * const newsphere = rotate([TAU / 8, 0, 0], sphere())
+ * const newSphere = rotate([TAU / 8, 0, 0], sphere())
  */
-const rotate = (angles, ...objects) => {
+export const rotate = (angles, ...objects) => {
   if (!Array.isArray(angles)) throw new Error('angles must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the angles if necessary
   angles = angles.slice() // don't modify the original
   while (angles.length < 3) angles.push(0)
@@ -36,6 +31,8 @@ const rotate = (angles, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return rotate(angles, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -43,34 +40,27 @@ const rotate = (angles, ...objects) => {
 
 /**
  * Rotate the given objects about the X axis, using the given options.
- * @param {Number} angle - angle (RADIANS) of rotations about X
+ * @param {number} angle - angle (RADIANS) of rotations about X
  * @param {...Object} objects - the objects to rotate
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateX
  */
-const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
+export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], ...objects)
 
 /**
  * Rotate the given objects about the Y axis, using the given options.
- * @param {Number} angle - angle (RADIANS) of rotations about Y
+ * @param {number} angle - angle (RADIANS) of rotations about Y
  * @param {...Object} objects - the objects to rotate
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateY
  */
-const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
+export const rotateY = (angle, ...objects) => rotate([0, angle, 0], ...objects)
 
 /**
  * Rotate the given objects about the Z axis, using the given options.
- * @param {Number} angle - angle (RADIANS) of rotations about Z
+ * @param {number} angle - angle (RADIANS) of rotations about Z
  * @param {...Object} objects - the objects to rotate
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateZ
  */
-const rotateZ = (angle, ...objects) => rotate([0, 0, angle], objects)
-
-module.exports = {
-  rotate,
-  rotateX,
-  rotateY,
-  rotateZ
-}
+export const rotateZ = (angle, ...objects) => rotate([0, 0, angle], ...objects)

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

@@ -1,12 +1,14 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../../maths/constants')
+import { TAU } from '../../maths/constants.js'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { rotate, rotateX, rotateY, rotateZ } = require('./index')
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+import { rotate, rotateX, rotateY, rotateZ } from './index.js'
+
+import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 test('rotate: rotating of a path2 produces expected changes to points', (t) => {
   const geometry = path2.fromPoints({}, [[1, 0], [0, 1], [-1, 0]])
@@ -28,7 +30,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
 })
 
 test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
-  const geometry = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  const geometry = geom2.create([[[0, 0], [1, 0], [0, 1]]])
 
   // rotate about Z
   let rotated = rotate([0, 0, -TAU / 4], geometry)
@@ -39,11 +41,13 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
     new Float32Array([1, 0])
   ]
   t.notThrows(() => geom2.validate(rotated))
+  t.is(measureArea(rotated), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   rotated = rotateZ(-TAU / 4, geometry)
   obs = geom2.toPoints(rotated)
   t.notThrows(() => geom2.validate(rotated))
+  t.is(measureArea(rotated), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -76,11 +80,13 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
       [8, -18, 13.000000000000002], [-2, -18, 13.000000000000002]]
   ]
   t.notThrows(() => geom3.validate(rotated))
+  t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateX(TAU / 4, geometry)
   obs = geom3.toPoints(rotated)
   t.notThrows(() => geom3.validate(rotated))
+  t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
@@ -101,10 +107,13 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
       [-18, 13, 8.000000000000002], [-18, 13, -1.999999999999999]]
   ]
   t.notThrows(() => geom3.validate(rotated))
+  t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateY(-TAU / 4, geometry)
   obs = geom3.toPoints(rotated)
+  t.notThrows(() => geom3.validate(rotated))
+  t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Z
@@ -125,18 +134,20 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
       [-8.000000000000002, -12.999999999999998, 18], [1.9999999999999984, -13, 18]]
   ]
   t.notThrows(() => geom3.validate(rotated))
+  t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateZ(TAU / 2, geometry)
   obs = geom3.toPoints(rotated)
   t.notThrows(() => geom3.validate(rotated))
+  t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
 test('rotate: rotating of multiple objects produces expected changes', (t) => {
   const junk = 'hello'
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
-  const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+  const geometry2 = geom2.create([[[-5, -5], [0, 5], [10, -5]]])
 
   const rotated = rotate([0, 0, TAU / 4], junk, geometry1, geometry2)