@jscad/modeling 2.12.0 → 3.0.0-alpha.0

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

@@ -1,10 +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 { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { center, centerX, centerY, centerZ } = require('./index')
+import { measureArea, measureVolume } from '../../measurements/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 +25,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 +65,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 +86,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 +107,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)
 

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,15 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const mat4 = require('../../maths/mat4')
-const plane = require('../../maths/plane')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as plane from '../../maths/plane/index.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'
 
 /**
  * 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,7 +19,7 @@ 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
@@ -52,7 +52,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 +60,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 +68,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,10 +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 { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { mirror, mirrorX, mirrorY, mirrorZ } = require('./index')
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+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]])
@@ -35,18 +37,20 @@ 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 = [[5, -5], [0, 5], [-10, -5]]
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), -measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), -measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
@@ -54,11 +58,13 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   obs = geom2.toPoints(mirrored)
   exp = [[-5, 5], [0, -5], [10, 5]]
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), -measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), -measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -85,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
@@ -105,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
@@ -124,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)

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,10 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.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'
 
 /**
  * Rotate the given objects using the given options.
@@ -14,9 +14,9 @@ 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)
@@ -43,34 +43,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)
 

package/src/operations/transforms/scale.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 scale<T extends Geometry>(factors: Vec1 | Vec2 | Vec3, geometry: T): T
-export function scale<T extends Geometry>(factors: Vec1 | Vec2 | Vec3, ...geometries: RecursiveArray<T>): Array<T>
-export function scale(factors: Vec1 | Vec2 | Vec3, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+export function scale<T extends Geometry>(factors: Vec, geometry: T): T
+export function scale<T extends Geometry>(factors: Vec, ...geometries: RecursiveArray<T>): Array<T>
+export function scale(factors: Vec, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
 
 export function scaleX<T extends Geometry>(factor: number, geometry: T): T
 export function scaleX<T extends Geometry>(factor: number, ...geometries: RecursiveArray<T>): Array<T>

package/src/operations/transforms/scale.js

@@ -1,10 +1,10 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.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'
 
 /**
  * Scale the given objects using the given options.
@@ -16,7 +16,7 @@ const path2 = require('../../geometries/path2')
  * @example
  * let myshape = scale([5, 0, 10], sphere())
  */
-const scale = (factors, ...objects) => {
+export const scale = (factors, ...objects) => {
   if (!Array.isArray(factors)) throw new Error('factors must be an array')
 
   objects = flatten(objects)
@@ -41,34 +41,27 @@ const scale = (factors, ...objects) => {
 
 /**
  * Scale the given objects about the X axis using the given options.
- * @param {Number} factor - X factor by which to scale the objects
+ * @param {number} factor - X factor by which to scale the objects
  * @param {...Object} objects - the objects to scale
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleX
  */
-const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
+export const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
 
 /**
  * Scale the given objects about the Y axis using the given options.
- * @param {Number} factor - Y factor by which to scale the objects
+ * @param {number} factor - Y factor by which to scale the objects
  * @param {...Object} objects - the objects to scale
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleY
  */
-const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
+export const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
 
 /**
  * Scale the given objects about the Z axis using the given options.
- * @param {Number} factor - Z factor by which to scale the objects
+ * @param {number} factor - Z factor by which to scale the objects
  * @param {...Object} objects - the objects to scale
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleZ
  */
-const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)
-
-module.exports = {
-  scale,
-  scaleX,
-  scaleY,
-  scaleZ
-}
+export const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)