@jscad/modeling 2.12.0 → 3.0.0-alpha.0

package/src/primitives/polyhedron.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { polyhedron } = require('./index')
+import { geom3 } from '../geometries/index.js'
 
-const geom3 = require('../geometries/geom3')
+import { polyhedron } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('polyhedron (points and faces)', (t) => {
   // points and faces form a cube

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

package/src/primitives/rectangle.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { rectangle } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { rectangle } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('rectangle (defaults)', (t) => {
   const geometry = rectangle()

package/src/primitives/roundedCuboid.d.ts

@@ -1,7 +1,5 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default roundedCuboid
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface RoundedCuboidOptions {
   center?: Vec3
@@ -10,4 +8,4 @@ export interface RoundedCuboidOptions {
   segments?: number
 }
 
-declare function roundedCuboid(options?: RoundedCuboidOptions): Geom3
+export function roundedCuboid(options?: RoundedCuboidOptions): Geom3

package/src/primitives/roundedCuboid.js

@@ -1,57 +1,58 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
+import { sin, cos } from '../maths/utils/trigonometry.js'
 
-const vec2 = require('../maths/vec2')
-const vec3 = require('../maths/vec3')
+import * as vec2 from '../maths/vec2/index.js'
+import * as vec3 from '../maths/vec3/index.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 { sin, cos } = require('../maths/utils/trigonometry')
+import { isGTE, isNumberArray } from './commonChecks.js'
 
-const { isGTE, isNumberArray } = require('./commonChecks')
-const cuboid = require('./cuboid')
+import { cuboid } from './cuboid.js'
 
 const createCorners = (center, size, radius, segments, slice, positive) => {
   const pitch = (TAU / 4) * slice / segments
-  const cospitch = cos(pitch)
-  const sinpitch = sin(pitch)
-
-  const layersegments = segments - slice
-  let layerradius = radius * cospitch
-  let layeroffset = size[2] - (radius - (radius * sinpitch))
-  if (!positive) layeroffset = (radius - (radius * sinpitch)) - size[2]
-
-  layerradius = layerradius > EPS ? layerradius : 0
-
-  const corner0 = vec3.add(vec3.create(), center, [size[0] - radius, size[1] - radius, layeroffset])
-  const corner1 = vec3.add(vec3.create(), center, [radius - size[0], size[1] - radius, layeroffset])
-  const corner2 = vec3.add(vec3.create(), center, [radius - size[0], radius - size[1], layeroffset])
-  const corner3 = vec3.add(vec3.create(), center, [size[0] - radius, radius - size[1], layeroffset])
-  const corner0Points = []
-  const corner1Points = []
-  const corner2Points = []
-  const corner3Points = []
-  for (let i = 0; i <= layersegments; i++) {
-    const radians = layersegments > 0 ? TAU / 4 * i / layersegments : 0
+  const cosPitch = cos(pitch)
+  const sinPitch = sin(pitch)
+
+  const layerSegments = segments - slice
+  let layerRadius = radius * cosPitch
+  let layerOffset = size[2] - (radius - (radius * sinPitch))
+  if (!positive) layerOffset = (radius - (radius * sinPitch)) - size[2]
+
+  layerRadius = layerRadius > EPS ? layerRadius : 0
+
+  const corner0 = vec3.add(vec3.create(), center, [size[0] - radius, size[1] - radius, layerOffset])
+  const corner1 = vec3.add(vec3.create(), center, [radius - size[0], size[1] - radius, layerOffset])
+  const corner2 = vec3.add(vec3.create(), center, [radius - size[0], radius - size[1], layerOffset])
+  const corner3 = vec3.add(vec3.create(), center, [size[0] - radius, radius - size[1], layerOffset])
+  const corner0Vertices = []
+  const corner1Vertices = []
+  const corner2Vertices = []
+  const corner3Vertices = []
+  for (let i = 0; i <= layerSegments; i++) {
+    const radians = layerSegments > 0 ? TAU / 4 * i / layerSegments : 0
+    // FIXME allocate only once
     const point2d = vec2.fromAngleRadians(vec2.create(), radians)
-    vec2.scale(point2d, point2d, layerradius)
+    vec2.scale(point2d, point2d, layerRadius)
     const point3d = vec3.fromVec2(vec3.create(), point2d)
-    corner0Points.push(vec3.add(vec3.create(), corner0, point3d))
+    corner0Vertices.push(vec3.add(vec3.create(), corner0, point3d))
     vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
-    corner1Points.push(vec3.add(vec3.create(), corner1, point3d))
+    corner1Vertices.push(vec3.add(vec3.create(), corner1, point3d))
     vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
-    corner2Points.push(vec3.add(vec3.create(), corner2, point3d))
+    corner2Vertices.push(vec3.add(vec3.create(), corner2, point3d))
     vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
-    corner3Points.push(vec3.add(vec3.create(), corner3, point3d))
+    corner3Vertices.push(vec3.add(vec3.create(), corner3, point3d))
   }
   if (!positive) {
-    corner0Points.reverse()
-    corner1Points.reverse()
-    corner2Points.reverse()
-    corner3Points.reverse()
-    return [corner3Points, corner2Points, corner1Points, corner0Points]
+    corner0Vertices.reverse()
+    corner1Vertices.reverse()
+    corner2Vertices.reverse()
+    corner3Vertices.reverse()
+    return [corner3Vertices, corner2Vertices, corner1Vertices, corner0Vertices]
   }
-  return [corner0Points, corner1Points, corner2Points, corner3Points]
+  return [corner0Vertices, corner1Vertices, corner2Vertices, corner3Vertices]
 }
 
 const stitchCorners = (previousCorners, currentCorners) => {
@@ -94,38 +95,38 @@ const stitchSides = (bottomCorners, topCorners) => {
   bottomCorners = [bottomCorners[3], bottomCorners[2], bottomCorners[1], bottomCorners[0]]
   bottomCorners = bottomCorners.map((corner) => corner.slice().reverse())
 
-  const bottomPoints = []
+  const bottomVertices = []
   bottomCorners.forEach((corner) => {
-    corner.forEach((point) => bottomPoints.push(point))
+    corner.forEach((vertex) => bottomVertices.push(vertex))
   })
 
-  const topPoints = []
+  const topVertices = []
   topCorners.forEach((corner) => {
-    corner.forEach((point) => topPoints.push(point))
+    corner.forEach((vertex) => topVertices.push(vertex))
   })
 
   const polygons = []
-  for (let i = 0; i < topPoints.length; i++) {
-    const j = (i + 1) % topPoints.length
-    polygons.push(poly3.create([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
+  for (let i = 0; i < topVertices.length; i++) {
+    const j = (i + 1) % topVertices.length
+    polygons.push(poly3.create([bottomVertices[i], bottomVertices[j], topVertices[j], topVertices[i]]))
   }
   return polygons
 }
 
 /**
  * Construct an axis-aligned solid cuboid in three dimensional space with rounded corners.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of rounded cube
  * @param {Array} [options.size=[2,2,2]] - dimension of rounded cube; width, depth, height
- * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom3} new 3D geometry
+ * @param {number} [options.roundRadius=0.2] - radius of rounded edges
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.roundedCuboid
  *
  * @example
- * let mycube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
+ * let myCube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
  */
-const roundedCuboid = (options) => {
+export const roundedCuboid = (options) => {
   const defaults = {
     center: [0, 0, 0],
     size: [2, 2, 2],
@@ -176,11 +177,11 @@ const roundedCuboid = (options) => {
 
     if (slice === segments) {
       // add the top
-      let points = cornersPos.map((corner) => corner[0])
-      polygons.push(poly3.create(points))
+      let vertices = cornersPos.map((corner) => corner[0])
+      polygons.push(poly3.create(vertices))
       // add the bottom
-      points = cornersNeg.map((corner) => corner[0])
-      polygons.push(poly3.create(points))
+      vertices = cornersNeg.map((corner) => corner[0])
+      polygons.push(poly3.create(vertices))
     }
 
     prevCornersPos = cornersPos
@@ -189,5 +190,3 @@ const roundedCuboid = (options) => {
 
   return geom3.create(polygons)
 }
-
-module.exports = roundedCuboid

package/src/primitives/roundedCuboid.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { roundedCuboid } = require('./index')
+import { geom3 } from '../geometries/index.js'
 
-const geom3 = require('../geometries/geom3')
+import { roundedCuboid } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCuboid (defaults)', (t) => {
   const obs = roundedCuboid()

package/src/primitives/roundedCylinder.d.ts

@@ -1,7 +1,5 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default roundedCylinder
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface RoundedCylinderOptions {
   center?: Vec3
@@ -11,4 +9,4 @@ export interface RoundedCylinderOptions {
   segments?: number
 }
 
-declare function roundedCylinder(options?: RoundedCylinderOptions): Geom3
+export function roundedCylinder(options?: RoundedCylinderOptions): Geom3

package/src/primitives/roundedCylinder.js

@@ -1,30 +1,30 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
+import { sin, cos } from '../maths/utils/trigonometry.js'
 
-const vec3 = require('../maths/vec3')
+import * as vec3 from '../maths/vec3/index.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 { sin, cos } = require('../maths/utils/trigonometry')
+import { isGTE, isNumberArray } from './commonChecks.js'
 
-const { isGTE, isNumberArray } = require('./commonChecks')
-const cylinder = require('./cylinder')
+import { cylinder } from './cylinder.js'
 
 /**
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
- * @param {Number} [options.height=2] - height of cylinder
- * @param {Number} [options.radius=1] - radius of cylinder
- * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom3} new 3D geometry
+ * @param {number} [options.height=2] - height of cylinder
+ * @param {number} [options.radius=1] - radius of cylinder
+ * @param {number} [options.roundRadius=0.2] - radius of rounded edges
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.roundedCylinder
  *
  * @example
  * let myshape = roundedCylinder({ height: 10, radius: 2, roundRadius: 0.5 })
  */
-const roundedCylinder = (options) => {
+export const roundedCylinder = (options) => {
   const defaults = {
     center: [0, 0, 0],
     height: 2,
@@ -54,94 +54,91 @@ const roundedCylinder = (options) => {
 
   if ((2 * roundRadius) > (length - EPS)) throw new Error('height must be larger than twice roundRadius')
 
-  let defaultnormal
+  let defaultNormal
   if (Math.abs(direction[0]) > Math.abs(direction[1])) {
-    defaultnormal = vec3.fromValues(0, 1, 0)
+    defaultNormal = vec3.fromValues(0, 1, 0)
   } else {
-    defaultnormal = vec3.fromValues(1, 0, 0)
+    defaultNormal = vec3.fromValues(1, 0, 0)
   }
 
-  const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), direction), roundRadius)
-  const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), zvector, defaultnormal)), radius)
-  const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), xvector, zvector)), radius)
+  const zVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), direction), roundRadius)
+  const xVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), zVector, defaultNormal)), radius)
+  const yVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), xVector, zVector)), radius)
 
-  vec3.add(start, start, zvector)
-  vec3.subtract(end, end, zvector)
+  vec3.add(start, start, zVector)
+  vec3.subtract(end, end, zVector)
 
-  const qsegments = Math.floor(0.25 * segments)
+  const qSegments = Math.floor(0.25 * segments)
 
-  const fromPoints = (points) => {
-    // adjust the points to center
-    const newpoints = points.map((point) => vec3.add(point, point, center))
-    return poly3.create(newpoints)
+  const fromVertices = (vertices) => {
+    // adjust the vertices to center
+    const newVertices = vertices.map((vertex) => vec3.add(vertex, vertex, center))
+    return poly3.create(newVertices)
   }
 
   const polygons = []
   const v1 = vec3.create()
   const v2 = vec3.create()
-  let prevcylinderpoint
+  let prevCylinderVertex
   for (let slice1 = 0; slice1 <= segments; slice1++) {
     const angle = TAU * slice1 / segments
-    const cylinderpoint = vec3.add(vec3.create(), vec3.scale(v1, xvector, cos(angle)), vec3.scale(v2, yvector, sin(angle)))
+    const cylinderVertex = vec3.add(vec3.create(), vec3.scale(v1, xVector, cos(angle)), vec3.scale(v2, yVector, sin(angle)))
     if (slice1 > 0) {
       // cylinder wall
-      let points = []
-      points.push(vec3.add(vec3.create(), start, cylinderpoint))
-      points.push(vec3.add(vec3.create(), start, prevcylinderpoint))
-      points.push(vec3.add(vec3.create(), end, prevcylinderpoint))
-      points.push(vec3.add(vec3.create(), end, cylinderpoint))
-      polygons.push(fromPoints(points))
-
-      let prevcospitch, prevsinpitch
-      for (let slice2 = 0; slice2 <= qsegments; slice2++) {
-        const pitch = TAU / 4 * slice2 / qsegments
-        const cospitch = cos(pitch)
-        const sinpitch = sin(pitch)
+      let vertices = []
+      vertices.push(vec3.add(vec3.create(), start, cylinderVertex))
+      vertices.push(vec3.add(vec3.create(), start, prevCylinderVertex))
+      vertices.push(vec3.add(vec3.create(), end, prevCylinderVertex))
+      vertices.push(vec3.add(vec3.create(), end, cylinderVertex))
+      polygons.push(fromVertices(vertices))
+
+      let prevCosPitch, prevSinPitch
+      let vertex
+      for (let slice2 = 0; slice2 <= qSegments; slice2++) {
+        const pitch = TAU / 4 * slice2 / qSegments
+        const cosPitch = cos(pitch)
+        const sinPitch = sin(pitch)
         if (slice2 > 0) {
           // cylinder rounding, start
-          points = []
-          let point
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevcylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch)))
-          points.push(point)
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch)))
-          points.push(point)
-          if (slice2 < qsegments) {
-            point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch)))
-            points.push(point)
+          vertices = []
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevCylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch)))
+          vertices.push(vertex)
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch)))
+          vertices.push(vertex)
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch)))
+            vertices.push(vertex)
           }
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevcylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch)))
-          points.push(point)
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevCylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch)))
+          vertices.push(vertex)
 
-          polygons.push(fromPoints(points))
+          polygons.push(fromVertices(vertices))
 
           // cylinder rounding, end
-          points = []
-          point = vec3.add(vec3.create(), vec3.scale(v1, prevcylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          point = vec3.add(vec3.create(), vec3.scale(v1, cylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          if (slice2 < qsegments) {
-            point = vec3.add(vec3.create(), vec3.scale(v1, cylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch))
-            vec3.add(point, point, end)
-            points.push(point)
+          vertices = []
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, prevCylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, cylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vec3.create(), vec3.scale(v1, cylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch))
+            vec3.add(vertex, vertex, end)
+            vertices.push(vertex)
           }
-          point = vec3.add(vec3.create(), vec3.scale(v1, prevcylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          points.reverse()
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, prevCylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          vertices.reverse()
 
-          polygons.push(fromPoints(points))
+          polygons.push(fromVertices(vertices))
         }
-        prevcospitch = cospitch
-        prevsinpitch = sinpitch
+        prevCosPitch = cosPitch
+        prevSinPitch = sinPitch
       }
     }
-    prevcylinderpoint = cylinderpoint
+    prevCylinderVertex = cylinderVertex
   }
-  const result = geom3.create(polygons)
-  return result
+  return geom3.create(polygons)
 }
-
-module.exports = roundedCylinder

package/src/primitives/roundedCylinder.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { roundedCylinder } = require('./index')
+import { roundedCylinder } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCylinder (defaults)', (t) => {
   const obs = roundedCylinder()

package/src/primitives/roundedRectangle.d.ts

@@ -1,7 +1,5 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default roundedRectangle
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface RoundedRectangleOptions {
   center?: Vec2
@@ -10,4 +8,4 @@ export interface RoundedRectangleOptions {
   segments?: number
 }
 
-declare function roundedRectangle(options?: RoundedRectangleOptions): Geom2
+export function roundedRectangle(options?: RoundedRectangleOptions): Geom2

package/src/primitives/roundedRectangle.js

@@ -1,26 +1,27 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
 
-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 { isGTE, isNumberArray } = require('./commonChecks')
-const rectangle = require('./rectangle')
+import { isGTE, isNumberArray } from './commonChecks.js'
+
+import { rectangle } from './rectangle.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with rounded corners.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rounded rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rounded rectangle; width and length
- * @param {Number} [options.roundRadius=0.2] - round radius of corners
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.roundRadius=0.2] - round radius of corners
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.roundedRectangle
  *
  * @example
  * let myshape = roundedRectangle({size: [10, 20], roundRadius: 2})
  */
-const roundedRectangle = (options) => {
+export const roundedRectangle = (options) => {
   const defaults = {
     center: [0, 0],
     size: [2, 2],
@@ -46,7 +47,7 @@ const roundedRectangle = (options) => {
   if (roundRadius > (size[0] - EPS) ||
       roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller then the radius of all dimensions')
 
-  const cornersegments = Math.floor(segments / 4)
+  const cornerSegments = Math.floor(segments / 4)
 
   // create sets of points that define the corners
   const corner0 = vec2.add(vec2.create(), center, [size[0] - roundRadius, size[1] - roundRadius])
@@ -57,8 +58,8 @@ const roundedRectangle = (options) => {
   const corner1Points = []
   const corner2Points = []
   const corner3Points = []
-  for (let i = 0; i <= cornersegments; i++) {
-    const radians = TAU / 4 * i / cornersegments
+  for (let i = 0; i <= cornerSegments; i++) {
+    const radians = TAU / 4 * i / cornerSegments
     const point = vec2.fromAngleRadians(vec2.create(), radians)
     vec2.scale(point, point, roundRadius)
     corner0Points.push(vec2.add(vec2.create(), corner0, point))
@@ -70,7 +71,6 @@ const roundedRectangle = (options) => {
     corner3Points.push(vec2.add(vec2.create(), corner3, point))
   }
 
-  return geom2.fromPoints(corner0Points.concat(corner1Points, corner2Points, corner3Points))
+  const points = corner0Points.concat(corner1Points, corner2Points, corner3Points)
+  return geom2.create([points])
 }
-
-module.exports = roundedRectangle

package/src/primitives/roundedRectangle.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { roundedRectangle } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { roundedRectangle } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('roundedRectangle (defaults)', (t) => {
   const geometry = roundedRectangle()