@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/primitives/geodesicSphere.js

@@ -1,24 +1,23 @@
-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 geom3 = require('../geometries/geom3')
+import * as geom3 from '../geometries/geom3/index.js'
 
-const polyhedron = require('./polyhedron')
-
-const { isGTE } = require('./commonChecks')
+import { polyhedron } from './polyhedron.js'
+import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a geodesic sphere based on icosahedron symmetry.
- * @param {Object} [options] - options for construction
- * @param {Number} [options.radius=1] - target radius of sphere
- * @param {Number} [options.frequency=6] - subdivision frequency per face, multiples of 6
- * @returns {geom3} new 3D geometry
+ * @param {object} [options] - options for construction
+ * @param {number} [options.radius=1] - target radius of sphere
+ * @param {number} [options.frequency=6] - subdivision frequency per face, multiples of 6
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.geodesicSphere
  *
  * @example
  * let myshape = geodesicSphere({radius: 15, frequency: 18})
  */
-const geodesicSphere = (options) => {
+export const geodesicSphere = (options) => {
   const defaults = {
     radius: 1,
     frequency: 6
@@ -109,7 +108,7 @@ const geodesicSphere = (options) => {
         }
       }
     }
-    return { points: c, triangles: f, offset: n }
+    return { vertices: c, triangles: f, offset: n }
   }
 
   const mix3 = (a, b, f) => {
@@ -121,20 +120,18 @@ const geodesicSphere = (options) => {
     return c
   }
 
-  let points = []
+  let vertices = []
   let faces = []
   let offset = 0
 
   for (let i = 0; i < ti.length; i++) {
     const g = geodesicSubDivide([ci[ti[i][0]], ci[ti[i][1]], ci[ti[i][2]]], frequency, offset)
-    points = points.concat(g.points)
+    vertices = vertices.concat(g.vertices)
     faces = faces.concat(g.triangles)
     offset = g.offset
   }
 
-  let geometry = polyhedron({ points: points, faces: faces, orientation: 'inward' })
+  let geometry = polyhedron({ points: vertices, faces: faces, orientation: 'inward' })
   if (radius !== 1) geometry = geom3.transform(mat4.fromScaling(mat4.create(), [radius, radius, radius]), geometry)
   return geometry
 }
-
-module.exports = geodesicSphere

package/src/primitives/geodesicSphere.test.js

@@ -1,10 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { geodesicSphere } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { geodesicSphere } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('geodesicSphere (defaults)', (t) => {
   const obs = geodesicSphere()
@@ -41,6 +43,8 @@ test('geodesicSphere (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 239.3635345818432)
+  t.is(measureVolume(obs), 317.0188387650327)
   t.is(pts.length, 20)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -49,6 +53,8 @@ test('geodesicSphere (options)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 303.76605423529395)
+  t.is(measureVolume(obs), 492.6739732379337)
   t.is(pts.length, 180)
 })
 
@@ -56,5 +62,7 @@ test('geodesicSphere (zero radius)', (t) => {
   const obs = geodesicSphere({ radius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })

package/src/primitives/index.d.ts

@@ -1,23 +1,21 @@
-export { default as arc, ArcOptions } from './arc'
-export { default as circle, CircleOptions } from './circle'
-export { default as cube, CubeOptions } from './cube'
-export { default as cuboid, CuboidOptions } from './cuboid'
-export { default as cylinder, CylinderOptions } from './cylinder'
-export { default as cylinderElliptic, CylinderEllipticOptions } from './cylinderElliptic'
-export { default as ellipse, EllipseOptions } from './ellipse'
-export { default as ellipsoid, EllipsoidOptions } from './ellipsoid'
-export { default as geodesicSphere, GeodesicSphereOptions } from './geodesicSphere'
-export { default as line } from './line'
-export { default as polygon, PolygonOptions } from './polygon'
-export { default as polyhedron, PolyhedronOptions } from './polyhedron'
-export { default as rectangle, RectangleOptions } from './rectangle'
-export { default as roundedCuboid, RoundedCuboidOptions } from './roundedCuboid'
-export { default as roundedCylinder, RoundedCylinderOptions } from './roundedCylinder'
-export { default as roundedRectangle, RoundedRectangleOptions } from './roundedRectangle'
-export { default as sphere, SphereOptions } from './sphere'
-export { default as square, SquareOptions } from './square'
-export { default as star, StarOptions } from './star'
-export { default as torus, TorusOptions } from './torus'
-export { default as triangle, TriangleOptions } from './triangle'
-
-export as namespace primitives
+export { arc, ArcOptions } from './arc.js'
+export { circle, CircleOptions } from './circle.js'
+export { cube, CubeOptions } from './cube.js'
+export { cuboid, CuboidOptions } from './cuboid.js'
+export { cylinder, CylinderOptions } from './cylinder.js'
+export { cylinderElliptic, CylinderEllipticOptions } from './cylinderElliptic.js'
+export { ellipse, EllipseOptions } from './ellipse.js'
+export { ellipsoid, EllipsoidOptions } from './ellipsoid.js'
+export { geodesicSphere, GeodesicSphereOptions } from './geodesicSphere.js'
+export { line } from './line.js'
+export { polygon, PolygonOptions } from './polygon.js'
+export { polyhedron, PolyhedronOptions } from './polyhedron.js'
+export { rectangle, RectangleOptions } from './rectangle.js'
+export { roundedCuboid, RoundedCuboidOptions } from './roundedCuboid.js'
+export { roundedCylinder, RoundedCylinderOptions } from './roundedCylinder.js'
+export { roundedRectangle, RoundedRectangleOptions } from './roundedRectangle.js'
+export { sphere, SphereOptions } from './sphere.js'
+export { square, SquareOptions } from './square.js'
+export { star, StarOptions } from './star.js'
+export { torus, TorusOptions } from './torus.js'
+export { triangle, TriangleOptions } from './triangle.js'

package/src/primitives/index.js

@@ -4,28 +4,26 @@
  * Primitives can be logically combined, transformed, extruded, etc.
  * @module modeling/primitives
  * @example
- * const { cube, ellipse, star } = require('@jscad/modeling').primitives
+ * import { cube, ellipse, star } from '@jscad/modeling'
  */
-module.exports = {
-  arc: require('./arc'),
-  circle: require('./circle'),
-  cube: require('./cube'),
-  cuboid: require('./cuboid'),
-  cylinder: require('./cylinder'),
-  cylinderElliptic: require('./cylinderElliptic'),
-  ellipse: require('./ellipse'),
-  ellipsoid: require('./ellipsoid'),
-  geodesicSphere: require('./geodesicSphere'),
-  line: require('./line'),
-  polygon: require('./polygon'),
-  polyhedron: require('./polyhedron'),
-  rectangle: require('./rectangle'),
-  roundedCuboid: require('./roundedCuboid'),
-  roundedCylinder: require('./roundedCylinder'),
-  roundedRectangle: require('./roundedRectangle'),
-  sphere: require('./sphere'),
-  square: require('./square'),
-  star: require('./star'),
-  torus: require('./torus'),
-  triangle: require('./triangle')
-}
+export { arc } from './arc.js'
+export { circle } from './circle.js'
+export { cube } from './cube.js'
+export { cuboid } from './cuboid.js'
+export { cylinder } from './cylinder.js'
+export { cylinderElliptic } from './cylinderElliptic.js'
+export { ellipse } from './ellipse.js'
+export { ellipsoid } from './ellipsoid.js'
+export { geodesicSphere } from './geodesicSphere.js'
+export { line } from './line.js'
+export { polygon } from './polygon.js'
+export { polyhedron } from './polyhedron.js'
+export { rectangle } from './rectangle.js'
+export { roundedCuboid } from './roundedCuboid.js'
+export { roundedCylinder } from './roundedCylinder.js'
+export { roundedRectangle } from './roundedRectangle.js'
+export { sphere } from './sphere.js'
+export { square } from './square.js'
+export { star } from './star.js'
+export { torus } from './torus.js'
+export { triangle } from './triangle.js'

package/src/primitives/line.d.ts

@@ -1,6 +1,4 @@
-import Vec2 from '../maths/vec2/type'
-import Path2 from '../geometries/path2/type'
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Path2 } from '../geometries/path2/type.d.ts'
 
-export default line
-
-declare function line(points: Array<Vec2>): Path2
+export function line(points: Array<Vec2>): Path2

package/src/primitives/line.js

@@ -1,19 +1,17 @@
-const path2 = require('../geometries/path2')
+import * as path2 from '../geometries/path2/index.js'
 
 /**
  * Construct a new line in two dimensional space from the given points.
  * The points must be provided as an array, where each element is a 2D point.
  * @param {Array} points - array of points from which to create the path
- * @returns {path2} new 2D path
+ * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.line
  *
  * @example
  * let myshape = line([[10, 10], [-10, 10]])
  */
-const line = (points) => {
+export const line = (points) => {
   if (!Array.isArray(points)) throw new Error('points must be an array')
 
   return path2.fromPoints({}, points)
 }
-
-module.exports = line

package/src/primitives/line.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { line } = require('./index')
+import { path2 } from '../geometries/index.js'
 
-const path2 = require('../geometries/path2')
+import { line } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('line (defaults)', (t) => {
   const exp = [[0, 0], [1, 1], [-3, 3]]
@@ -12,6 +12,6 @@ test('line (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/polygon.d.ts

@@ -1,7 +1,5 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default polygon
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface PolygonOptions {
   points: Array<Vec2> | Array<Array<Vec2>>
@@ -9,4 +7,4 @@ export interface PolygonOptions {
   orientation?: 'counterclockwise' | 'clockwise'
 }
 
-declare function polygon(options: PolygonOptions): Geom2
+export function polygon(options: PolygonOptions): Geom2

package/src/primitives/polygon.js

@@ -1,15 +1,15 @@
-const geom2 = require('../geometries/geom2')
+import * as geom2 from '../geometries/geom2/index.js'
 
 /**
  * Construct a polygon in two dimensional space from a list of points, or a list of points and paths.
  *
  * NOTE: The ordering of points is important, and must define a counter clockwise rotation of points.
  *
- * @param {Object} options - options for construction
+ * @param {object} options - options for construction
  * @param {Array} options.points - points of the polygon : either flat or nested array of 2D points
  * @param {Array} [options.paths] - paths of the polygon : either flat or nested array of point indexes
  * @param {String} [options.orientation='counterclockwise'] - orientation of points
- * @returns {geom2} new 2D geometry
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.polygon
  *
  * @example
@@ -24,7 +24,7 @@ const geom2 = require('../geometries/geom2')
  * or
  * let poly = polygon({ points: [roof, wall], paths: [[0, 1, 2], [3, 4, 5, 6]] })
  */
-const polygon = (options) => {
+export const polygon = (options) => {
   const defaults = {
     points: [],
     paths: [],
@@ -34,15 +34,15 @@ const polygon = (options) => {
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 
-  let listofpolys = points
+  let listOfPolys = points
   if (Array.isArray(points[0])) {
     if (!Array.isArray(points[0][0])) {
       // points is an array of something... convert to list
-      listofpolys = [points]
+      listOfPolys = [points]
     }
   }
 
-  listofpolys.forEach((list, i) => {
+  listOfPolys.forEach((list, i) => {
     if (!Array.isArray(list)) throw new Error('list of points ' + i + ' must be an array')
     if (list.length < 3) throw new Error('list of points ' + i + ' must contain three or more points')
     list.forEach((point, j) => {
@@ -51,31 +51,26 @@ const polygon = (options) => {
     })
   })
 
-  let listofpaths = paths
+  let listOfPaths = paths
   if (paths.length === 0) {
     // create a list of paths based on the points
     let count = 0
-    listofpaths = listofpolys.map((list) => list.map((point) => count++))
+    listOfPaths = listOfPolys.map((list) => list.map((point) => count++))
   }
 
-  // flatten the listofpoints for indexed access
-  const allpoints = []
-  listofpolys.forEach((list) => list.forEach((point) => allpoints.push(point)))
+  // flatten the listOfPoints for indexed access
+  const allPoints = []
+  listOfPolys.forEach((list) => list.forEach((point) => allPoints.push(point)))
 
-  // convert the list of paths into a list of sides, and accumulate
-  let sides = []
-  listofpaths.forEach((path) => {
-    const setofpoints = path.map((index) => allpoints[index])
-    const geometry = geom2.fromPoints(setofpoints)
-    sides = sides.concat(geom2.toSides(geometry))
+  const outlines = []
+  listOfPaths.forEach((path) => {
+    const setOfPoints = path.map((index) => allPoints[index])
+    outlines.push(setOfPoints)
   })
 
-  // convert the list of sides into a geometry
-  let geometry = geom2.create(sides)
+  let geometry = geom2.create(outlines)
   if (orientation === 'clockwise') {
     geometry = geom2.reverse(geometry)
   }
   return geometry
 }
-
-module.exports = polygon

package/src/primitives/polygon.test.js

@@ -1,11 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom2 = require('../geometries/geom2')
-const measureArea = require('../measurements/measureArea')
+import { geom2 } from '../geometries/index.js'
 
-const { polygon } = require('./index')
+import { measureArea } from '../measurements/index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { polygon } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('polygon: providing only object.points creates expected geometry', (t) => {
   let geometry = polygon({ points: [[0, 0], [100, 0], [130, 50], [30, 50]] })
@@ -14,14 +15,16 @@ test('polygon: providing only object.points creates expected geometry', (t) => {
   let exp = [[0, 0], [100, 0], [130, 50], [30, 50]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 5000)
   t.true(comparePoints(obs, exp))
 
   geometry = polygon({ points: [[[0, 0], [100, 0], [0, 100]], [[10, 10], [80, 10], [10, 80]]] })
 
   obs = geom2.toPoints(geometry)
-  exp = [[0, 0], [100, 0], [10, 80], [10, 10], [80, 10], [0, 100]]
+  exp = [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 7450)
   t.true(comparePoints(obs, exp))
 })
 
@@ -32,24 +35,27 @@ test('polygon: providing object.points (array) and object.path (array) creates e
   let exp = [[30, 50], [130, 50], [100, 0], [0, 0]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), -5000)
   t.true(comparePoints(obs, exp))
 
   // multiple paths
   geometry = polygon({ points: [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]], paths: [[0, 1, 2], [3, 4, 5]] })
 
   obs = geom2.toPoints(geometry)
-  exp = [[0, 0], [100, 0], [10, 80], [10, 10], [80, 10], [0, 100]]
+  exp = [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 7450)
   t.true(comparePoints(obs, exp))
 
   // multiple points and paths
   geometry = polygon({ points: [[[0, 0], [100, 0], [0, 100]], [[10, 10], [80, 10], [10, 80]]], paths: [[0, 1, 2], [3, 4, 5]] })
 
   obs = geom2.toPoints(geometry)
-  exp = [[0, 0], [100, 0], [10, 80], [10, 10], [80, 10], [0, 100]]
+  exp = [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 7450)
   t.true(comparePoints(obs, exp))
 })
 
@@ -58,6 +64,5 @@ test('polygon: clockwise points', (t) => {
     points: [[-10, -0], [-10, -10], [-15, -5]],
     orientation: 'clockwise'
   })
-  t.is(poly.sides.length, 3)
   t.is(measureArea(poly), 25)
 })

package/src/primitives/polyhedron.d.ts

@@ -1,8 +1,6 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-import { RGB, RGBA } from '../colors/types'
-
-export default polyhedron
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
+import type { RGB, RGBA } from '../colors/types.d.ts'
 
 export interface PolyhedronOptions {
   points: Array<Vec3>
@@ -11,4 +9,4 @@ export interface PolyhedronOptions {
   orientation?: 'outward' | 'inward'
 }
 
-declare function polyhedron(options: PolyhedronOptions): Geom3
+export function polyhedron(options: PolyhedronOptions): Geom3

package/src/primitives/polyhedron.js

@@ -1,27 +1,27 @@
-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 { isNumberArray } = require('./commonChecks')
+import { isNumberArray } from './commonChecks.js'
 
 /**
- * Construct a polyhedron in three dimensional space from the given set of 3D points and faces.
+ * Construct a polyhedron in three dimensional space from the given set of 3D vertices and faces.
  *
  * The faces can define outward or inward facing polygons (orientation).
- * However, each face must define a counter clockwise rotation of points which follows the right hand rule.
- * @param {Object} options - options for construction
+ * However, each face must define a counterclockwise rotation of vertices which follows the right hand rule.
+ * @param {object} options - options for construction
  * @param {Array} options.points - list of points in 3D space
  * @param {Array} options.faces - list of faces, where each face is a set of indexes into the points
  * @param {Array} [options.colors=undefined] - list of RGBA colors to apply to each face
- * @param {String} [options.orientation='outward'] - orientation of faces
- * @returns {geom3} new 3D geometry
+ * @param {string} [options.orientation='outward'] - orientation of faces
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.polyhedron
  *
  * @example
- * let mypoints = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ]
- * let myfaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
- * let myshape = polyhedron({points: mypoints, faces: myfaces, orientation: 'inward'})
+ * let myPoints = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ]
+ * let myFaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
+ * let myShape = polyhedron({points: myPoints, faces: myFaces, orientation: 'inward'})
  */
-const polyhedron = (options) => {
+export const polyhedron = (options) => {
   const defaults = {
     points: [],
     faces: [],
@@ -47,15 +47,15 @@ const polyhedron = (options) => {
       throw new Error('faces and colors must have the same length')
     }
   }
-  points.forEach((point, i) => {
-    if (!isNumberArray(point, 3)) throw new Error(`point ${i} must be an array of X, Y, Z values`)
+  points.forEach((vertex, i) => {
+    if (!isNumberArray(vertex, 3)) throw new Error(`vertex ${i} must be an array of X, Y, Z values`)
   })
   faces.forEach((face, i) => {
     if (face.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`)
     if (!isNumberArray(face, face.length)) throw new Error(`face ${i} must be an array of numbers`)
   })
 
-  // invert the faces if orientation is inwards, as all internals expect outwarding facing polygons
+  // invert the faces if orientation is inwards, as all internals expect outward facing polygons
   if (orientation !== 'outward') {
     faces.forEach((face) => face.reverse())
   }
@@ -68,5 +68,3 @@ const polyhedron = (options) => {
 
   return geom3.create(polygons)
 }
-
-module.exports = polyhedron

package/src/primitives/polyhedron.test.js

@@ -1,10 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { polyhedron } = require('./index')
+import { geom3 } from '../geometries/index.js'
 
-const geom3 = require('../geometries/geom3')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { polyhedron } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('polyhedron (points and faces)', (t) => {
   // points and faces form a cube
@@ -22,7 +24,9 @@ test('polyhedron (points and faces)', (t) => {
     [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 6)
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
+  t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // test orientation
@@ -39,6 +43,8 @@ test('polyhedron (points and faces)', (t) => {
     [[-10, 10, 0], [10, -10, 0], [-10, -10, 0]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 6)
+  t.is(measureArea(obs), 965.6854249492379)
+  t.is(measureVolume(obs), 1333.3333333333333)
+  t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/rectangle.d.ts

@@ -1,11 +1,9 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default rectangle
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface RectangleOptions {
   center?: Vec2
   size?: Vec2
 }
 
-declare function rectangle(options?: RectangleOptions): Geom2
+export function rectangle(options?: RectangleOptions): Geom2

package/src/primitives/rectangle.js

@@ -1,21 +1,21 @@
-const vec2 = require('../maths/vec2')
+import * as vec2 from '../maths/vec2/index.js'
 
-const geom2 = require('../geometries/geom2')
+import * as geom2 from '../geometries/geom2/index.js'
 
-const { isNumberArray } = require('./commonChecks')
+import { isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with four sides at right angles.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rectangle, width and length
- * @returns {geom2} new 2D geometry
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.rectangle
  *
  * @example
  * let myshape = rectangle({size: [10, 20]})
  */
-const rectangle = (options) => {
+export const rectangle = (options) => {
   const defaults = {
     center: [0, 0],
     size: [2, 2]
@@ -30,15 +30,13 @@ const rectangle = (options) => {
   if (size[0] === 0 || size[1] === 0) return geom2.create()
 
   const point = [size[0] / 2, size[1] / 2]
-  const pswap = [point[0], -point[1]]
+  const swapped = [point[0], -point[1]]
 
   const points = [
     vec2.subtract(vec2.create(), center, point),
-    vec2.add(vec2.create(), center, pswap),
+    vec2.add(vec2.create(), center, swapped),
     vec2.add(vec2.create(), center, point),
-    vec2.subtract(vec2.create(), center, pswap)
+    vec2.subtract(vec2.create(), center, swapped)
   ]
-  return geom2.fromPoints(points)
+  return geom2.create([points])
 }
-
-module.exports = rectangle