@jscad/modeling 2.12.5 → 3.0.1-alpha.0

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,8 @@
-const flatten = require('../../utils/flatten')
+import * as mat4 from '../../maths/mat4/index.js'
 
-const mat4 = require('../../maths/mat4')
-
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
 
 /**
  * Scale the given objects using the given options.
@@ -16,12 +14,9 @@ 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)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the factors if necessary
   factors = factors.slice() // don't modify the original
   while (factors.length < 3) factors.push(1)
@@ -34,6 +29,8 @@ const scale = (factors, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return scale(factors, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -41,34 +38,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)

package/src/operations/transforms/scale.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 { scale, scaleX, scaleY, scaleZ } = require('./index')
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+import { scale, scaleX, scaleY, scaleZ } from './index.js'
 
 test('scale: scaling of a path2 produces expected changes to points', (t) => {
   const geometry = path2.fromPoints({}, [[0, 4], [1, 0]])
@@ -35,18 +37,20 @@ test('scale: scaling of a path2 produces expected changes to points', (t) => {
 })
 
 test('scale: scaling of a geom2 produces expected changes to points', (t) => {
-  const geometry = geom2.fromPoints([[-1, 0], [1, 0], [0, 1]])
+  const geometry = geom2.create([[[-1, 0], [1, 0], [0, 1]]])
 
   // scale X
   let scaled = scale([3], geometry)
   let obs = geom2.toPoints(scaled)
   let exp = [[-3, 0], [3, 0], [0, 1]]
   t.notThrows(() => geom2.validate(scaled))
+  t.is(measureArea(scaled), 3 * measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = geom2.toPoints(scaled)
   t.notThrows(() => geom2.validate(scaled))
+  t.is(measureArea(scaled), 3 * measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // scale Y
@@ -54,11 +58,13 @@ test('scale: scaling of a geom2 produces expected changes to points', (t) => {
   obs = geom2.toPoints(scaled)
   exp = [[-1, 0], [1, 0], [0, 3]]
   t.notThrows(() => geom2.validate(scaled))
+  t.is(measureArea(scaled), 3 * measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleY(3, geometry)
   obs = geom2.toPoints(scaled)
   t.notThrows(() => geom2.validate(scaled))
+  t.is(measureArea(scaled), 3 * measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -85,11 +91,13 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-6, -7, 18], [24, -7, 18], [24, 13, 18], [-6, 13, 18]]
   ]
   t.notThrows(() => geom3.validate(scaled))
+  t.is(measureVolume(scaled), 3 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = geom3.toPoints(scaled)
   t.notThrows(() => geom3.validate(scaled))
+  t.is(measureVolume(scaled), 3 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Y
@@ -103,11 +111,14 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-2, -3.5, -12], [-2, 6.5, -12], [8, 6.5, -12], [8, -3.5, -12]],
     [[-2, -3.5, 18], [8, -3.5, 18], [8, 6.5, 18], [-2, 6.5, 18]]
   ]
+  t.notThrows(() => geom3.validate(scaled))
+  t.is(measureVolume(scaled), 0.5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleY(0.5, geometry)
   obs = geom3.toPoints(scaled)
   t.notThrows(() => geom3.validate(scaled))
+  t.is(measureVolume(scaled), 0.5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Z
@@ -122,18 +133,20 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-2, -7, 90], [8, -7, 90], [8, 13, 90], [-2, 13, 90]]
   ]
   t.notThrows(() => geom3.validate(scaled))
+  t.is(measureVolume(scaled), 5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleZ(5, geometry)
   obs = geom3.toPoints(scaled)
   t.notThrows(() => geom3.validate(scaled))
+  t.is(measureVolume(scaled), 5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
 test('scale: scaling 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 scaled = scale([3, 1, 1], junk, geometry1, geometry2)
 
@@ -142,10 +155,12 @@ test('scale: scaling of multiple objects produces expected changes', (t) => {
   const obs1 = path2.toPoints(scaled[1])
   const exp1 = [[-15, 5], [15, 5], [-15, -5], [30, -5]]
   t.notThrows(() => path2.validate(scaled[1]))
+  t.is(measureVolume(scaled[1]), 3 * measureVolume(geometry1))
   t.true(comparePoints(obs1, exp1))
 
   const obs2 = geom2.toPoints(scaled[2])
   const exp2 = [[-15, -5], [0, 5], [30, -5]]
   t.notThrows(() => geom2.validate(scaled[2]))
+  t.is(measureVolume(scaled[2]), 3 * measureVolume(geometry2))
   t.true(comparePoints(obs2, exp2))
 })

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

@@ -1,6 +1,6 @@
-import { Geometry } from '../../geometries/types'
-import Mat4 from '../../maths/mat4/type'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export function transform<T extends Geometry>(matrix: Mat4, geometry: T): T
 export function transform<T extends Geometry>(matrix: Mat4, ...geometries: RecursiveArray<T>): Array<T>

package/src/operations/transforms/transform.js

@@ -1,32 +1,27 @@
-const flatten = require('../../utils/flatten')
-
-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'
 
 /**
  * Transform the given objects using the given matrix.
- * @param {mat4} matrix - a transformation matrix
+ * @param {Mat4} matrix - a transformation matrix
  * @param {...Object} objects - the objects to transform
  * @return {Object|Array} the transformed object, or a list of transformed objects
  * @alias module:modeling/transforms.transform
  *
  * @example
- * const newsphere = transform(mat4.rotateX(TAU / 8), sphere())
+ * const newSphere = transform(mat4.rotateX(TAU / 8), sphere())
  */
-const transform = (matrix, ...objects) => {
+export const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return transform(matrix, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
 }
-
-module.exports = transform

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

@@ -1,12 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { transform } = require('./index')
+import { transform } from './index.js'
 
 test('transform: transforming of a path2 produces expected changes to points', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 0])
@@ -21,7 +21,7 @@ test('transform: transforming of a path2 produces expected changes to points', (
 
 test('transform: transforming of a geom2 produces expected changes to sides', (t) => {
   const matrix = mat4.fromScaling(mat4.create(), [5, 5, 5])
-  let geometry = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  let geometry = geom2.create([[[0, 0], [1, 0], [0, 1]]])
 
   geometry = transform(matrix, geometry)
   const obs = geom2.toPoints(geometry)
@@ -58,7 +58,7 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
 test('transform: transforming 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 matrix = mat4.fromTranslation(mat4.create(), [2, 2, 0])
   const transformed = transform(matrix, junk, geometry1, geometry2)

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

@@ -1,8 +1,6 @@
-import { Geometry } from '../../geometries/types'
-import { Vec1, Vec2, Vec3 } from '../../maths/types'
-import RecursiveArray from '../../utils/recursiveArray'
-
-type Vec = Vec1 | Vec2 | Vec3
+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 translate<T extends Geometry>(offset: Vec, geometry: T): T
 export function translate<T extends Geometry>(offset: Vec, ...geometries: RecursiveArray<T>): Array<T>

package/src/operations/transforms/translate.js

@@ -1,10 +1,8 @@
-const flatten = require('../../utils/flatten')
+import * as mat4 from '../../maths/mat4/index.js'
 
-const mat4 = require('../../maths/mat4')
-
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
 
 /**
  * Translate the given objects using the given options.
@@ -14,14 +12,11 @@ const path2 = require('../../geometries/path2')
  * @alias module:modeling/transforms.translate
  *
  * @example
- * const newsphere = translate([5, 0, 10], sphere())
+ * const newSphere = translate([5, 0, 10], sphere())
  */
-const translate = (offset, ...objects) => {
+export const translate = (offset, ...objects) => {
   if (!Array.isArray(offset)) throw new Error('offset must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the offset if necessary
   offset = offset.slice() // don't modify the original
   while (offset.length < 3) offset.push(0)
@@ -32,6 +27,8 @@ const translate = (offset, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return translate(offset, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -39,34 +36,27 @@ const translate = (offset, ...objects) => {
 
 /**
  * Translate the given objects along the X axis using the given options.
- * @param {Number} offset - X offset of which to translate the objects
+ * @param {number} offset - X offset of which to translate the objects
  * @param {...Object} objects - the objects to translate
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateX
  */
-const translateX = (offset, ...objects) => translate([offset, 0, 0], objects)
+export const translateX = (offset, ...objects) => translate([offset, 0, 0], ...objects)
 
 /**
  * Translate the given objects along the Y axis using the given options.
- * @param {Number} offset - Y offset of which to translate the geometries
+ * @param {number} offset - Y offset of which to translate the geometries
  * @param {...Object} objects - the objects to translate
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateY
  */
-const translateY = (offset, ...objects) => translate([0, offset, 0], objects)
+export const translateY = (offset, ...objects) => translate([0, offset, 0], ...objects)
 
 /**
  * Translate the given objects along the Z axis using the given options.
- * @param {Number} offset - Z offset of which to translate the geometries
+ * @param {number} offset - Z offset of which to translate the geometries
  * @param {...Object} objects - the objects to translate
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateZ
  */
-const translateZ = (offset, ...objects) => translate([0, 0, offset], objects)
-
-module.exports = {
-  translate,
-  translateX,
-  translateY,
-  translateZ
-}
+export const translateZ = (offset, ...objects) => translate([0, 0, offset], ...objects)

package/src/operations/transforms/translate.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 { translate, translateX, translateY, translateZ } = require('./index')
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+import { translate, translateX, translateY, translateZ } from './index.js'
 
 test('translate: translating of a path2 produces expected changes to points', (t) => {
   const line = path2.fromPoints({}, [[0, 0], [1, 0]])
@@ -35,18 +37,20 @@ test('translate: translating of a path2 produces expected changes to points', (t
 })
 
 test('translate: translating 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]]])
 
   // translate X
   let translated = translate([1], geometry)
   let obs = geom2.toPoints(translated)
   let exp = [[1, 0], [2, 0], [1, 1]]
   t.notThrows(() => geom2.validate(translated))
+  t.is(measureArea(translated), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   translated = translateX(1, geometry)
   obs = geom2.toPoints(translated)
   t.notThrows(() => geom2.validate(translated))
+  t.is(measureArea(translated), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // translate Y
@@ -54,11 +58,13 @@ test('translate: translating of a geom2 produces expected changes to points', (t
   obs = geom2.toPoints(translated)
   exp = [[0, 1], [1, 1], [0, 2]]
   t.notThrows(() => geom2.validate(translated))
+  t.is(measureArea(translated), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   translated = translateY(1, geometry)
   obs = geom2.toPoints(translated)
   t.notThrows(() => geom2.validate(translated))
+  t.is(measureArea(translated), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -85,11 +91,13 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[1, -7, 18], [11, -7, 18], [11, 13, 18], [1, 13, 18]]
   ]
   t.notThrows(() => geom3.validate(translated))
+  t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateX(3, geometry)
   obs = geom3.toPoints(translated)
   t.notThrows(() => geom3.validate(translated))
+  t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translated Y
@@ -104,11 +112,13 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[-2, -4, 18], [8, -4, 18], [8, 16, 18], [-2, 16, 18]]
   ]
   t.notThrows(() => geom3.validate(translated))
+  t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateY(3, geometry)
   obs = geom3.toPoints(translated)
   t.notThrows(() => geom3.validate(translated))
+  t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translate Z
@@ -123,18 +133,20 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[-2, -7, 21], [8, -7, 21], [8, 13, 21], [-2, 13, 21]]
   ]
   t.notThrows(() => geom3.validate(translated))
+  t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateZ(3, geometry)
   obs = geom3.toPoints(translated)
   t.notThrows(() => geom3.validate(translated))
+  t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
 test('translate: translating 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 translated = translate([3, 3, 3], junk, geometry1, geometry2)
   t.is(translated[0], junk)

package/src/primitives/arc.d.ts

@@ -1,7 +1,5 @@
-import Vec2 from '../maths/vec2/type'
-import Path2 from '../geometries/path2/type'
-
-export default arc
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Path2 } from '../geometries/path2/type.d.ts'
 
 export interface ArcOptions {
   center?: Vec2
@@ -12,4 +10,4 @@ export interface ArcOptions {
   makeTangent?: boolean
 }
 
-declare function arc(options?: ArcOptions): Path2
+export function arc(options?: ArcOptions): Path2

package/src/primitives/arc.js

@@ -1,26 +1,26 @@
-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 path2 = require('../geometries/path2')
+import * as path2 from '../geometries/path2/index.js'
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an arc in two dimensional space where all points are at the same distance from the center.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of arc
- * @param {Number} [options.radius=1] - radius of arc
- * @param {Number} [options.startAngle=0] - starting angle of the arc, in radians
- * @param {Number} [options.endAngle=TAU] - ending angle of the arc, in radians
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @param {Boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
- * @returns {path2} new 2D path
+ * @param {number} [options.radius=1] - radius of arc
+ * @param {number} [options.startAngle=0] - starting angle of the arc, in radians
+ * @param {number} [options.endAngle=TAU] - ending angle of the arc, in radians
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @param {boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
+ * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.arc
  * @example
  * let myshape = arc({ center: [-1, -1], radius: 2, endAngle: (TAU / 4)})
  */
-const arc = (options) => {
+export const arc = (options) => {
   const defaults = {
     center: [0, 0],
     radius: 1,
@@ -48,39 +48,37 @@ const arc = (options) => {
     rotation = endAngle + (TAU - startAngle)
   }
 
-  const minangle = Math.acos(((radius * radius) + (radius * radius) - (EPS * EPS)) / (2 * radius * radius))
+  const minAngle = Math.acos(((radius * radius) + (radius * radius) - (EPS * EPS)) / (2 * radius * radius))
 
-  const centerv = vec2.clone(center)
+  const centerV = vec2.clone(center)
   let point
   const pointArray = []
-  if (rotation < minangle) {
+  if (rotation < minAngle) {
     // there is no rotation, just a single point
     point = vec2.fromAngleRadians(vec2.create(), startAngle)
     vec2.scale(point, point, radius)
-    vec2.add(point, point, centerv)
+    vec2.add(point, point, centerV)
     pointArray.push(point)
   } else {
-    // note: add one additional step to acheive full rotation
-    const numsteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1
-    let edgestepsize = numsteps * 0.5 / rotation // step size for half a degree
-    if (edgestepsize > 0.25) edgestepsize = 0.25
+    // note: add one additional step to achieve full rotation
+    const numSteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1
+    let edgeStepSize = numSteps * 0.5 / rotation // step size for half a degree
+    if (edgeStepSize > 0.25) edgeStepSize = 0.25
 
-    const totalsteps = makeTangent ? (numsteps + 2) : numsteps
-    for (let i = 0; i <= totalsteps; i++) {
+    const totalSteps = makeTangent ? (numSteps + 2) : numSteps
+    for (let i = 0; i <= totalSteps; i++) {
       let step = i
       if (makeTangent) {
-        step = (i - 1) * (numsteps - 2 * edgestepsize) / numsteps + edgestepsize
+        step = (i - 1) * (numSteps - 2 * edgeStepSize) / numSteps + edgeStepSize
         if (step < 0) step = 0
-        if (step > numsteps) step = numsteps
+        if (step > numSteps) step = numSteps
       }
-      const angle = startAngle + (step * (rotation / numsteps))
+      const angle = startAngle + (step * (rotation / numSteps))
       point = vec2.fromAngleRadians(vec2.create(), angle)
       vec2.scale(point, point, radius)
-      vec2.add(point, point, centerv)
+      vec2.add(point, point, centerV)
       pointArray.push(point)
     }
   }
   return path2.fromPoints({ closed: false }, pointArray)
 }
-
-module.exports = arc