@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/primitives/arc.test.js

@@ -1,18 +1,19 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../maths/constants')
-const path2 = require('../geometries/path2')
+import { TAU } from '../maths/constants.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { path2 } from '../geometries/index.js'
 
-const { arc } = require('./index')
+import { arc } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('arc (defaults)', (t) => {
   const geometry = arc()
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 33)
+  t.is(obs.length, 33)
 })
 
 test('arc (options)', (t) => {
@@ -40,7 +41,7 @@ test('arc (options)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
   // test radius
@@ -67,7 +68,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
   // test startAngle
@@ -91,7 +92,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 14)
+  t.is(obs.length, 14)
   t.true(comparePoints(obs, exp))
 
   // test endAngle
@@ -107,7 +108,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   // test makeTangent
@@ -136,7 +137,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 19)
+  t.is(obs.length, 19)
   t.true(comparePoints(obs, exp))
 
   // test segments
@@ -155,7 +156,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 9)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 })
 
@@ -172,7 +173,7 @@ test('arc (rotations)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   exp = [
@@ -191,7 +192,7 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
   exp = [
@@ -210,7 +211,7 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
   exp = [[-1.8369701987210297e-16, -1]]
@@ -218,6 +219,6 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 1)
+  t.is(obs.length, 1)
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/circle.d.ts

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

package/src/primitives/circle.js

@@ -1,24 +1,24 @@
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const ellipse = require('./ellipse')
+import { ellipse } from './ellipse.js'
 
-const { isGTE } = require('./commonChecks')
+import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a circle in two dimensional space where all points are at the same distance from the center.
  * @see [ellipse]{@link module:modeling/primitives.ellipse} for more options
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of circle
- * @param {Number} [options.radius=1] - radius of circle
- * @param {Number} [options.startAngle=0] - start angle of circle, in radians
- * @param {Number} [options.endAngle=TAU] - end angle of circle, in radians
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.radius=1] - radius of circle
+ * @param {number} [options.startAngle=0] - start angle of circle, in radians
+ * @param {number} [options.endAngle=TAU] - end angle of circle, in radians
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.circle
  * @example
  * let myshape = circle({radius: 10})
  */
-const circle = (options) => {
+export const circle = (options) => {
   const defaults = {
     center: [0, 0],
     radius: 1,
@@ -34,5 +34,3 @@ const circle = (options) => {
 
   return ellipse({ center, radius, startAngle, endAngle, segments })
 }
-
-module.exports = circle

package/src/primitives/circle.test.js

@@ -1,18 +1,22 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../maths/constants')
-const geom2 = require('../geometries/geom2')
+import { geom2 } from '../geometries/index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { TAU } from '../maths/constants.js'
 
-const { circle } = require('./index')
+import { measureArea } from '../measurements/measureArea.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
+
+import { circle } from './index.js'
 
 test('circle (defaults)', (t) => {
   const geometry = circle()
   const pts = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 32)
+  t.is(measureArea(geometry), 3.1214451522580537)
+  t.is(pts.length, 32)
 })
 
 test('circle (options)', (t) => {
@@ -55,7 +59,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 32)
+  t.is(measureArea(geometry), 38.23770311516116)
+  t.is(pts.length, 32)
   t.true(comparePoints(pts, exp))
 
   // test radius
@@ -81,7 +86,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 37.5029763717788)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test startAngle
@@ -105,7 +111,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 14)
+  t.is(measureArea(geometry), 28.127232278834093)
+  t.is(pts.length, 14)
   t.true(comparePoints(pts, exp))
 
   // test endAngle
@@ -121,7 +128,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 6)
+  t.is(measureArea(geometry), 9.3757440929447)
+  t.is(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
   // test full rotation with non-zero startAngle
@@ -129,7 +137,8 @@ test('circle (options)', (t) => {
   pts = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 32)
+  t.is(measureArea(geometry), 3.1214451522580537)
+  t.is(pts.length, 32)
 
   // test segments
   geometry = circle({ radius: 3.5, segments: 5 })
@@ -143,7 +152,8 @@ test('circle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 5)
+  t.is(measureArea(geometry), 29.126105811539073)
+  t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })
 
@@ -151,5 +161,6 @@ test('circle (radius zero)', (t) => {
   const geometry = circle({ radius: 0 })
   const pts = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 0)
   t.is(pts.length, 0)
 })

package/src/primitives/commonChecks.js

@@ -1,5 +1,5 @@
 // verify that the array has the given dimension, and contains Number values
-const isNumberArray = (array, dimension) => {
+export const isNumberArray = (array, dimension) => {
   if (Array.isArray(array) && array.length >= dimension) {
     return array.every((n) => Number.isFinite(n))
   }
@@ -7,13 +7,7 @@ const isNumberArray = (array, dimension) => {
 }
 
 // verify that the value is a Number greater than the constant
-const isGT = (value, constant) => (Number.isFinite(value) && value > constant)
+export const isGT = (value, constant) => (Number.isFinite(value) && value > constant)
 
 // verify that the value is a Number greater than or equal to the constant
-const isGTE = (value, constant) => (Number.isFinite(value) && value >= constant)
-
-module.exports = {
-  isNumberArray,
-  isGT,
-  isGTE
-}
+export const isGTE = (value, constant) => (Number.isFinite(value) && value >= constant)

package/src/primitives/cube.d.ts

@@ -1,11 +1,9 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default cube
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface CubeOptions {
   center?: Vec3
   size?: number
 }
 
-declare function cube(options?: CubeOptions): Geom3
+export function cube(options?: CubeOptions): Geom3

package/src/primitives/cube.js

@@ -1,19 +1,18 @@
-const cuboid = require('./cuboid')
-
-const { isGTE } = require('./commonChecks')
+import { cuboid } from './cuboid.js'
+import { isGTE } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned solid cube in three dimensional space with six square faces.
  * @see [cuboid]{@link module:modeling/primitives.cuboid} for more options
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cube
- * @param {Number} [options.size=2] - dimension of cube
- * @returns {geom3} new 3D geometry
+ * @param {number} [options.size=2] - dimension of cube
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.cube
  * @example
  * let myshape = cube({size: 10})
  */
-const cube = (options) => {
+export const cube = (options) => {
   const defaults = {
     center: [0, 0, 0],
     size: 2
@@ -26,5 +25,3 @@ const cube = (options) => {
 
   return cuboid({ center, size })
 }
-
-module.exports = cube

package/src/primitives/cube.test.js

@@ -1,15 +1,19 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { cube } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { cube } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cube (defaults)', (t) => {
   const obs = cube()
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
   t.is(pts.length, 6)
 })
 
@@ -27,6 +31,8 @@ test('cube (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 294)
+  t.is(measureVolume(obs), 343)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -43,6 +49,8 @@ test('cube (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 294)
+  t.is(measureVolume(obs), 343)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -51,5 +59,7 @@ test('cube (zero size)', (t) => {
   const obs = cube({ size: 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/cuboid.d.ts

@@ -1,11 +1,9 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default cuboid
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface CuboidOptions {
   center?: Vec3
   size?: Vec3
 }
 
-declare function cuboid(options?: CuboidOptions): Geom3
+export function cuboid(options?: CuboidOptions): Geom3

package/src/primitives/cuboid.js

@@ -1,20 +1,20 @@
-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 an axis-aligned solid cuboid in three dimensional space.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cuboid
  * @param {Array} [options.size=[2,2,2]] - dimensions of cuboid; width, depth, height
- * @returns {geom3} new 3D geometry
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.cuboid
  *
  * @example
  * let myshape = cuboid({size: [5, 10, 5]})
  */
-const cuboid = (options) => {
+export const cuboid = (options) => {
   const defaults = {
     center: [0, 0, 0],
     size: [2, 2, 2]
@@ -38,7 +38,7 @@ const cuboid = (options) => {
       [[0, 2, 3, 1], [0, 0, -1]],
       [[4, 5, 7, 6], [0, 0, +1]]
     ].map((info) => {
-      const points = info[0].map((i) => {
+      const vertices = info[0].map((i) => {
         const pos = [
           center[0] + (size[0] / 2) * (2 * !!(i & 1) - 1),
           center[1] + (size[1] / 2) * (2 * !!(i & 2) - 1),
@@ -46,10 +46,8 @@ const cuboid = (options) => {
         ]
         return pos
       })
-      return poly3.create(points)
+      return poly3.create(vertices)
     })
   )
   return result
 }
-
-module.exports = cuboid

package/src/primitives/cuboid.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 { cuboid } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { cuboid } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cuboid (defaults)', (t) => {
   const obs = cuboid()
@@ -18,6 +20,8 @@ test('cuboid (defaults)', (t) => {
     [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -36,6 +40,8 @@ test('cuboid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 216)
+  t.is(measureVolume(obs), 216)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -52,6 +58,8 @@ test('cuboid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 97.5)
+  t.is(measureVolume(obs), 47.25)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -60,5 +68,7 @@ test('cuboid (zero size)', (t) => {
   const obs = cuboid({ size: [1, 1, 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/cylinder.d.ts

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

package/src/primitives/cylinder.js

@@ -1,24 +1,22 @@
-const geom3 = require('../geometries/geom3')
-
-const cylinderElliptic = require('./cylinderElliptic')
-
-const { isGTE } = require('./commonChecks')
+import { cylinderElliptic } from './cylinderElliptic.js'
+import { isGTE } from './commonChecks.js'
+import * as geom3 from '../geometries/geom3/index.js'
 
 /**
  * Construct a Z axis-aligned cylinder in three dimensional space.
  * @see [cylinderElliptic]{@link module:modeling/primitives.cylinderElliptic} for more options
- * @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 (at both start and end)
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom3} new geometry
+ * @param {number} [options.height=2] - height of cylinder
+ * @param {number} [options.radius=1] - radius of cylinder (at both start and end)
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom3} new geometry
  * @alias module:modeling/primitives.cylinder
  *
  * @example
  * let myshape = cylinder({height: 2, radius: 10})
  */
-const cylinder = (options) => {
+export const cylinder = (options) => {
   const defaults = {
     center: [0, 0, 0],
     height: 2,
@@ -32,7 +30,7 @@ const cylinder = (options) => {
   // if size is zero return empty geometry
   if (height === 0 || radius === 0) return geom3.create()
 
-  const newoptions = {
+  const newOptions = {
     center,
     height,
     startRadius: [radius, radius],
@@ -40,7 +38,5 @@ const cylinder = (options) => {
     segments
   }
 
-  return cylinderElliptic(newoptions)
+  return cylinderElliptic(newOptions)
 }
-
-module.exports = cylinder

package/src/primitives/cylinder.test.js

@@ -1,16 +1,20 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { cylinder } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { cylinder } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cylinder (defaults)', (t) => {
   const obs = cylinder()
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 18.789084266699856)
+  t.is(measureVolume(obs), 6.2428903045161)
   t.is(pts.length, 96)
 })
 
@@ -18,6 +22,8 @@ test('cylinder (zero height)', (t) => {
   const obs = cylinder({ height: 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)
 })
 
@@ -25,6 +31,8 @@ test('cylinder (zero radius)', (t) => {
   const obs = cylinder({ 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)
 })
 
@@ -55,6 +63,8 @@ test('cylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 311.1986222206015)
+  t.is(measureVolume(obs), 380.4226065180614)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -85,6 +95,8 @@ test('cylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 16.51098762732523)
+  t.is(measureVolume(obs), 4.755282581475773)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/cylinderElliptic.d.ts

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