@jscad/modeling 2.12.0 → 3.0.0-alpha.0

package/src/geometries/geom3/toString.js

@@ -1,17 +1,17 @@
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
-const toPolygons = require('./toPolygons')
+import { toPolygons } from './toPolygons.js'
 
 /**
  * Create a string representing the contents of the given geometry.
- * @param {geom3} geometry - the geometry
- * @returns {String} a representative string
+ * @param {Geom3} geometry - the geometry
+ * @returns {string} a representative string
  * @alias module:modeling/geometries/geom3.toString
  *
  * @example
  * console.out(toString(geometry))
  */
-const toString = (geometry) => {
+export const toString = (geometry) => {
   const polygons = toPolygons(geometry)
   let result = 'geom3 (' + polygons.length + ' polygons):\n'
   polygons.forEach((polygon) => {
@@ -19,5 +19,3 @@ const toString = (geometry) => {
   })
   return result
 }
-
-module.exports = toString

package/src/geometries/geom3/toString.test.js

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { create, fromPoints, toString } from './index.js'
+
+test('toString: serialize empty geom3 into a string', (t) => {
+  const geometry = create()
+  const result = toString(geometry)
+  const expected = 'geom3 (0 polygons):\n'
+  t.is(result, expected)
+})
+
+test('toString: serialize geom3 into a string', (t) => {
+  const geometry = fromPoints([[[0, 0, 3], [0, 1, 3], [2, 0, 3]]])
+  const result = toString(geometry)
+  const expected = 'geom3 (1 polygons):\n  poly3: [[0.0000000, 0.0000000, 3.0000000], [0.0000000, 1.0000000, 3.0000000], [2.0000000, 0.0000000, 3.0000000]]\n'
+  t.is(result, expected)
+})

package/src/geometries/geom3/transform.d.ts

@@ -1,6 +1,4 @@
-import Geom3 from './type'
-import Mat4 from '../../maths/mat4/type'
+import type { Geom3 } from './type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
 
-export default transform
-
-declare function transform(matrix: Mat4, geometry: Geom3): Geom3
+export function transform(matrix: Mat4, geometry: Geom3): Geom3

package/src/geometries/geom3/transform.js

@@ -1,20 +1,18 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the polygons, as this function only adjusts the transforms.
  * See applyTransforms() for the actual application of the transforms to the polygons.
- * @param {mat4} matrix - the matrix to transform with
- * @param {geom3} geometry - the geometry to transform
- * @returns {geom3} a new geometry
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Geom3} geometry - the geometry to transform
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.transform
  *
  * @example
- * let newgeometry = transform(fromXRotation(degToRad(90)), geometry)
+ * let newGeometry = transform(fromXRotation(TAU / 4), geometry)
  */
-const transform = (matrix, geometry) => {
+export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
   return Object.assign({}, geometry, { transforms })
 }
-
-module.exports = transform

package/src/geometries/geom3/transform.test.js

@@ -1,13 +1,13 @@
-const test = require('ava')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { transform, fromPoints, toPolygons } = require('./index')
+import { transform, fromPoints, toPolygons } from './index.js'
 
-const { comparePolygons, compareVectors } = require('../../../test/helpers/')
+import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
 test('transform: Adjusts the transforms of a populated geom3', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
   const rotation = 90 * 0.017453292519943295
   const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
 
@@ -20,7 +20,7 @@ test('transform: Adjusts the transforms of a populated geom3', (t) => {
     ],
     transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = fromPoints(vertices)
   let another = transform(rotate90, geometry)
   t.not(geometry, another)
   t.true(comparePolygons(another.polygons[0], expected.polygons[0]))

package/src/geometries/geom3/type.d.ts

@@ -1,10 +1,8 @@
-import Poly3 from '../poly3/type'
-import Mat4 from '../../maths/mat4/type'
-import { Color } from '../types'
+import type { Poly3 } from '../poly3/type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { Color } from '../types.d.ts'
 
-export default Geom3
-
-declare interface Geom3 {
+export interface Geom3 {
   polygons: Array<Poly3>
   transforms: Mat4
   color?: Color

package/src/geometries/geom3/validate.d.ts

@@ -1,3 +1 @@
-export default validate
-
-declare function validate(object: any): void
+export function validate(object: any): void

package/src/geometries/geom3/validate.js

@@ -1,5 +1,6 @@
-const poly3 = require('../poly3')
-const isA = require('./isA')
+import * as poly3 from '../poly3/index.js'
+
+import { isA } from './isA.js'
 
 /**
  * Determine if the given object is a valid 3D geometry.
@@ -7,11 +8,11 @@ const isA = require('./isA')
  *
  * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
  *
- * @param {Object} object - the object to interrogate
+ * @param {object} object - the object to interrogate
  * @throws {Error} error if the geometry is not valid
  * @alias module:modeling/geometries/geom3.validate
  */
-const validate = (object) => {
+export const validate = (object) => {
   if (!isA(object)) {
     throw new Error('invalid geom3 structure')
   }
@@ -58,5 +59,3 @@ const validateManifold = (object) => {
     throw new Error(`non-manifold edges ${nonManifold.length}\n${nonManifold.join('\n')}`)
   }
 }
-
-module.exports = validate

package/src/geometries/geom3/validate.test.js

@@ -0,0 +1,26 @@
+import test from 'ava'
+
+import * as vec3 from '../../maths/vec3/index.js'
+import { fromPoints, validate } from './index.js'
+
+// tetrahedron
+const a = vec3.fromValues(-1, -1, 1)
+const b = vec3.fromValues(-1, 1, -1)
+const c = vec3.fromValues(1, -1, -1)
+const d = vec3.fromValues(1, 1, 1)
+
+test('validate: allow valid geom3', (t) => {
+  // simplest valid geometry
+  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, d]])
+  t.notThrows(() => validate(geometry))
+})
+
+test('validate: throw exception for nan', (t) => {
+  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, NaN]]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for infinity', (t) => {
+  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, Infinity]]])
+  t.throws(() => validate(geometry))
+})

package/src/geometries/index.d.ts

@@ -1,7 +1,6 @@
-export * as geom2 from './geom2'
-export * as geom3 from './geom3'
-export * as path2 from './path2'
-export * as poly2 from './poly2'
-export * as poly3 from './poly3'
-
-export as namespace geometries
+export * as geom2 from './geom2/index.js'
+export * as geom3 from './geom3/index.js'
+export * as path2 from './path2/index.js'
+export * as poly2 from './poly2/index.js'
+export * as poly3 from './poly3/index.js'
+export * as slice from './slice/index.js'

package/src/geometries/index.js

@@ -2,20 +2,21 @@
  * Geometries are objects that represent the contents of primitives or the results of operations.
  * Note: Geometries are considered immutable, so never change the contents directly.
  *
- * @see {@link geom2} - 2D geometry consisting of sides
+ * @see {@link geom2} - 2D geometry consisting of 2D outlines
  * @see {@link geom3} - 3D geometry consisting of polygons
  * @see {@link path2} - 2D geometry consisting of ordered points
  * @see {@link poly2} - 2D polygon consisting of ordered vertices
  * @see {@link poly3} - 3D polygon consisting of ordered vertices
+ * @see {@link slice} - 3D geometry consisting of 3D outlines
  *
  * @module modeling/geometries
  * @example
- * const { geom2, geom3, path2, poly2, poly3 } = require('@jscad/modeling').geometries
+ * import { geometries } from '@jscad/modeling'
+ * const { geom2, geom3, path2, poly2, poly3 } = geometries
  */
-module.exports = {
-  geom2: require('./geom2'),
-  geom3: require('./geom3'),
-  path2: require('./path2'),
-  poly2: require('./poly2'),
-  poly3: require('./poly3')
-}
+export * as geom2 from './geom2/index.js'
+export * as geom3 from './geom3/index.js'
+export * as path2 from './path2/index.js'
+export * as poly2 from './poly2/index.js'
+export * as poly3 from './poly3/index.js'
+export * as slice from './slice/index.js'

package/src/geometries/path2/appendArc.d.ts

@@ -1,15 +1,13 @@
-import Path2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default appendArc
+import type { Path2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
 export interface AppendArcOptions {
   endpoint: Vec2
   radius?: Vec2
-  xaxisrotation?: number
+  xaxisRotation?: number
   clockwise?: boolean
   large?: boolean
   segments?: number
 }
 
-declare function appendArc(options: AppendArcOptions, geometry: Path2): Path2
+export function appendArc(options: AppendArcOptions, geometry: Path2): Path2

package/src/geometries/path2/appendArc.js

@@ -1,38 +1,38 @@
-const { TAU } = require('../../maths/constants')
-const vec2 = require('../../maths/vec2')
+import { TAU } from '../../maths/constants.js'
+import * as vec2 from '../../maths/vec2/index.js'
 
-const fromPoints = require('./fromPoints')
-const toPoints = require('./toPoints')
+import { fromPoints } from './fromPoints.js'
+import { toPoints } from './toPoints.js'
 
 /**
  * Append a series of points to the given geometry that represent an arc.
  * This implementation follows the SVG specifications.
  * @see http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
- * @param {Object} options - options for construction
- * @param {vec2} options.endpoint - end point of arc (REQUIRED)
- * @param {vec2} [options.radius=[0,0]] - radius of arc (X and Y)
- * @param {Number} [options.xaxisrotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
- * @param {Boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
- * @param {Boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
- * @param {Number} [options.segments=16] - number of segments per full rotation
- * @param {path2} geometry - the path of which to append the arc
- * @returns {path2} a new path with the appended points
+ * @param {object} options - options for construction
+ * @param {Vec2} options.endpoint - end point of arc (REQUIRED)
+ * @param {Vec2} [options.radius=[0,0]] - radius of arc (X and Y)
+ * @param {number} [options.xaxisRotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
+ * @param {boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
+ * @param {boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
+ * @param {number} [options.segments=16] - number of segments per full rotation
+ * @param {Path2} geometry - the path of which to append the arc
+ * @returns {Path2} a new path with the appended points
  * @alias module:modeling/geometries/path2.appendArc
  *
  * @example
- * let p1 = path2.fromPoints({}, [[27.5,-22.96875]]);
- * p1 = path2.appendPoints([[27.5,-3.28125]], p1);
- * p1 = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, p1);
+ * let myShape = fromPoints({}, [[27.5,-22.96875]]);
+ * myShape = appendPoints([[27.5,-3.28125]], myShape);
+ * myShape = appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
  */
-const appendArc = (options, geometry) => {
+export const appendArc = (options, geometry) => {
   const defaults = {
     radius: [0, 0], // X and Y radius
-    xaxisrotation: 0,
+    xaxisRotation: 0,
     clockwise: false,
     large: false,
     segments: 16
   }
-  let { endpoint, radius, xaxisrotation, clockwise, large, segments } = Object.assign({}, defaults, options)
+  let { endpoint, radius, xaxisRotation, clockwise, large, segments } = Object.assign({}, defaults, options)
 
   // validate the given options
   if (!Array.isArray(endpoint)) throw new Error('endpoint must be an array of X and Y values')
@@ -56,59 +56,59 @@ const appendArc = (options, geometry) => {
     throw new Error('the given path must contain one or more points (as the starting point for the arc)')
   }
 
-  let xradius = radius[0]
-  let yradius = radius[1]
+  let xRadius = radius[0]
+  let yRadius = radius[1]
   const startpoint = points[points.length - 1]
 
   // round to precision in order to have determinate calculations
-  xradius = Math.round(xradius * decimals) / decimals
-  yradius = Math.round(yradius * decimals) / decimals
+  xRadius = Math.round(xRadius * decimals) / decimals
+  yRadius = Math.round(yRadius * decimals) / decimals
   endpoint = vec2.fromValues(Math.round(endpoint[0] * decimals) / decimals, Math.round(endpoint[1] * decimals) / decimals)
 
   const sweepFlag = !clockwise
-  let newpoints = []
-  if ((xradius === 0) || (yradius === 0)) {
+  let newPoints = []
+  if ((xRadius === 0) || (yRadius === 0)) {
     // http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes:
     // If rx = 0 or ry = 0, then treat this as a straight line from (x1, y1) to (x2, y2) and stop
-    newpoints.push(endpoint)
+    newPoints.push(endpoint)
   } else {
-    xradius = Math.abs(xradius)
-    yradius = Math.abs(yradius)
+    xRadius = Math.abs(xRadius)
+    yRadius = Math.abs(yRadius)
 
     // see http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes :
-    const phi = xaxisrotation
-    const cosphi = Math.cos(phi)
-    const sinphi = Math.sin(phi)
-    const minushalfdistance = vec2.subtract(vec2.create(), startpoint, endpoint)
-    vec2.scale(minushalfdistance, minushalfdistance, 0.5)
+    const phi = xaxisRotation
+    const cosPhi = Math.cos(phi)
+    const sinPhi = Math.sin(phi)
+    const minusHalfDistance = vec2.subtract(vec2.create(), startpoint, endpoint)
+    vec2.scale(minusHalfDistance, minusHalfDistance, 0.5)
     // F.6.5.1:
     // round to precision in order to have determinate calculations
-    const x = Math.round((cosphi * minushalfdistance[0] + sinphi * minushalfdistance[1]) * decimals) / decimals
-    const y = Math.round((-sinphi * minushalfdistance[0] + cosphi * minushalfdistance[1]) * decimals) / decimals
+    const x = Math.round((cosPhi * minusHalfDistance[0] + sinPhi * minusHalfDistance[1]) * decimals) / decimals
+    const y = Math.round((-sinPhi * minusHalfDistance[0] + cosPhi * minusHalfDistance[1]) * decimals) / decimals
     const startTranslated = vec2.fromValues(x, y)
     // F.6.6.2:
-    const biglambda = (startTranslated[0] * startTranslated[0]) / (xradius * xradius) + (startTranslated[1] * startTranslated[1]) / (yradius * yradius)
-    if (biglambda > 1.0) {
+    const bigLambda = (startTranslated[0] * startTranslated[0]) / (xRadius * xRadius) + (startTranslated[1] * startTranslated[1]) / (yRadius * yRadius)
+    if (bigLambda > 1.0) {
       // F.6.6.3:
-      const sqrtbiglambda = Math.sqrt(biglambda)
-      xradius *= sqrtbiglambda
-      yradius *= sqrtbiglambda
+      const sqrtBigLambda = Math.sqrt(bigLambda)
+      xRadius *= sqrtBigLambda
+      yRadius *= sqrtBigLambda
       // round to precision in order to have determinate calculations
-      xradius = Math.round(xradius * decimals) / decimals
-      yradius = Math.round(yradius * decimals) / decimals
+      xRadius = Math.round(xRadius * decimals) / decimals
+      yRadius = Math.round(yRadius * decimals) / decimals
     }
     // F.6.5.2:
-    let multiplier1 = Math.sqrt((xradius * xradius * yradius * yradius - xradius * xradius * startTranslated[1] * startTranslated[1] - yradius * yradius * startTranslated[0] * startTranslated[0]) / (xradius * xradius * startTranslated[1] * startTranslated[1] + yradius * yradius * startTranslated[0] * startTranslated[0]))
+    let multiplier1 = Math.sqrt((xRadius * xRadius * yRadius * yRadius - xRadius * xRadius * startTranslated[1] * startTranslated[1] - yRadius * yRadius * startTranslated[0] * startTranslated[0]) / (xRadius * xRadius * startTranslated[1] * startTranslated[1] + yRadius * yRadius * startTranslated[0] * startTranslated[0]))
     if (sweepFlag === large) multiplier1 = -multiplier1
-    const centerTranslated = vec2.fromValues(xradius * startTranslated[1] / yradius, -yradius * startTranslated[0] / xradius)
+    const centerTranslated = vec2.fromValues(xRadius * startTranslated[1] / yRadius, -yRadius * startTranslated[0] / xRadius)
     vec2.scale(centerTranslated, centerTranslated, multiplier1)
     // F.6.5.3:
-    let center = vec2.fromValues(cosphi * centerTranslated[0] - sinphi * centerTranslated[1], sinphi * centerTranslated[0] + cosphi * centerTranslated[1])
+    let center = vec2.fromValues(cosPhi * centerTranslated[0] - sinPhi * centerTranslated[1], sinPhi * centerTranslated[0] + cosPhi * centerTranslated[1])
     center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, endpoint), 0.5))
 
     // F.6.5.5:
-    const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xradius, (startTranslated[1] - centerTranslated[1]) / yradius)
-    const vector2 = vec2.fromValues((-startTranslated[0] - centerTranslated[0]) / xradius, (-startTranslated[1] - centerTranslated[1]) / yradius)
+    const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xRadius, (startTranslated[1] - centerTranslated[1]) / yRadius)
+    const vector2 = vec2.fromValues((-startTranslated[0] - centerTranslated[0]) / xRadius, (-startTranslated[1] - centerTranslated[1]) / yRadius)
     const theta1 = vec2.angleRadians(vector1)
     const theta2 = vec2.angleRadians(vector2)
     let deltatheta = theta2 - theta1
@@ -120,23 +120,21 @@ const appendArc = (options, geometry) => {
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numsteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
-    if (numsteps < 1) numsteps = 1
-    for (let step = 1; step < numsteps; step++) {
-      const theta = theta1 + step / numsteps * deltatheta
-      const costheta = Math.cos(theta)
-      const sintheta = Math.sin(theta)
+    let numSteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
+    if (numSteps < 1) numSteps = 1
+    for (let step = 1; step < numSteps; step++) {
+      const theta = theta1 + step / numSteps * deltatheta
+      const cosTheta = Math.cos(theta)
+      const sinTheta = Math.sin(theta)
       // F.6.3.1:
-      const point = vec2.fromValues(cosphi * xradius * costheta - sinphi * yradius * sintheta, sinphi * xradius * costheta + cosphi * yradius * sintheta)
+      const point = vec2.fromValues(cosPhi * xRadius * cosTheta - sinPhi * yRadius * sinTheta, sinPhi * xRadius * cosTheta + cosPhi * yRadius * sinTheta)
       vec2.add(point, point, center)
-      newpoints.push(point)
+      newPoints.push(point)
     }
     // ensure end point is precisely what user gave as parameter
-    if (numsteps) newpoints.push(options.endpoint)
+    if (numSteps) newPoints.push(options.endpoint)
   }
-  newpoints = points.concat(newpoints)
-  const result = fromPoints({}, newpoints)
+  newPoints = points.concat(newPoints)
+  const result = fromPoints({}, newPoints)
   return result
 }
-
-module.exports = appendArc

package/src/geometries/path2/appendArc.test.js

@@ -1,10 +1,11 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../../maths/constants')
+import { TAU } from '../../maths/constants.js'
+import * as vec2 from '../../maths/vec2/index.js'
 
-const { appendArc, fromPoints, toPoints } = require('./index')
+import { appendArc, fromPoints, toPoints } from './index.js'
 
-const { comparePoints } = require('../../../test/helpers/')
+import { comparePoints } from '../../../test/helpers/index.js'
 
 test('appendArc: appending to an empty path produces an error', (t) => {
   const p1 = fromPoints({}, [])
@@ -49,8 +50,8 @@ test('appendArc: appending to a path produces a new path', (t) => {
   pts = toPoints(obs)
   t.is(pts.length, 16)
 
-  // test xaxisrotation
-  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisrotation: TAU / 4 }, p2)
+  // test xaxisRotation
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisRotation: TAU / 4 }, p2)
   pts = toPoints(obs)
   exp = [
     [27, -22],
@@ -73,7 +74,7 @@ test('appendArc: appending to a path produces a new path', (t) => {
 
 test('appendArc: appending to a path produces exact endpoint', (t) => {
   let p1 = fromPoints({}, [[18, 1.8], [1, 3]])
-  const endpoint = [1, -3]
+  const endpoint = vec2.fromValues(1, -3)
 
   p1 = appendArc({
     endpoint,

package/src/geometries/path2/appendBezier.d.ts

@@ -1,11 +1,9 @@
-import Path2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default appendBezier
+import type { Path2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
 export interface AppendBezierOptions {
   controlPoints: Array<Vec2 | null>
   segments?: number
 }
 
-declare function appendBezier(options: AppendBezierOptions, geometry: Path2): Path2
+export function appendBezier(options: AppendBezierOptions, geometry: Path2): Path2

package/src/geometries/path2/appendBezier.js

@@ -1,30 +1,30 @@
-const { TAU } = require('../../maths/constants')
-const vec2 = require('../../maths/vec2')
-const vec3 = require('../../maths/vec2')
+import { TAU } from '../../maths/constants.js'
+import * as vec2 from '../../maths/vec2/index.js'
+import * as vec3 from '../../maths/vec3/index.js' // FIXME why vec3?
 
-const appendPoints = require('./appendPoints')
-const toPoints = require('./toPoints')
+import { appendPoints } from './appendPoints.js'
+import { toPoints } from './toPoints.js'
 
 /**
- * Append a series of points to the given geometry that represent a Bezier curve.
+ * Append a series of points to the given geometry that represent a Bézier curve.
  * The Bézier curve starts at the last point in the given geometry, and ends at the last control point.
  * The other control points are intermediate control points to transition the curve from start to end points.
  * The first control point may be null to ensure a smooth transition occurs. In this case,
- * the second to last point of the given geometry is mirrored into the control points of the Bezier curve.
+ * the second to last point of the given geometry is mirrored into the control points of the Bézier curve.
  * In other words, the trailing gradient of the geometry matches the new gradient of the curve.
- * @param {Object} options - options for construction
- * @param {Array} options.controlPoints - list of control points (2D) for the bezier curve
- * @param {Number} [options.segment=16] - number of segments per 360 rotation
- * @param {path2} geometry - the path of which to appended points
- * @returns {path2} a new path with the appended points
+ * @param {object} options - options for construction
+ * @param {Array} options.controlPoints - list of control points (2D) for the Bézier curve
+ * @param {number} [options.segment=16] - number of segments per 360 rotation
+ * @param {Path2} geometry - the path of which to append points
+ * @returns {Path2} a new path with the appended points
  * @alias module:modeling/geometries/path2.appendBezier
  *
  * @example
- * let p5 = path2.create({}, [[10,-20]])
- * p5 = path2.appendBezier({controlPoints: [[10,-10],[25,-10],[25,-20]]}, p5);
- * p5 = path2.appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, p5)
+ * let myShape = fromPoints({}, [[10,-20]])
+ * myShape = appendBezier({controlPoints: [[10,-10],[25,-10],[25,-20]]}, myShape);
+ * myShape = appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, myShape)
  */
-const appendBezier = (options, geometry) => {
+export const appendBezier = (options, geometry) => {
   const defaults = {
     segments: 16
   }
@@ -64,10 +64,10 @@ const appendBezier = (options, geometry) => {
       throw new Error('the given path must contain TWO or more points if given a null control point')
     }
     // replace the first control point with the mirror of the last bezier control point
-    const controlpoint = vec2.scale(vec2.create(), points[points.length - 1], 2)
-    vec2.subtract(controlpoint, controlpoint, lastBezierControlPoint)
+    const controlPoint = vec2.scale(vec2.create(), points[points.length - 1], 2)
+    vec2.subtract(controlPoint, controlPoint, lastBezierControlPoint)
 
-    controlPoints[0] = controlpoint
+    controlPoints[0] = controlPoint
   }
 
   // add a control point for the previous end point
@@ -106,38 +106,38 @@ const appendBezier = (options, geometry) => {
     return point
   }
 
-  const newpoints = []
-  const newpointsT = []
-  const numsteps = bezierOrder + 1
-  for (let i = 0; i < numsteps; ++i) {
-    const t = i / (numsteps - 1)
+  const newPoints = []
+  const newPointsT = []
+  const numSteps = bezierOrder + 1
+  for (let i = 0; i < numSteps; ++i) {
+    const t = i / (numSteps - 1)
     const point = getPointForT(t)
-    newpoints.push(point)
-    newpointsT.push(t)
+    newPoints.push(point)
+    newPointsT.push(t)
   }
 
-  // subdivide each segment until the angle at each vertex becomes small enough:
+  // subdivide each segment until the angle becomes small enough:
   let subdivideBase = 1
-  const maxangle = TAU / segments
-  const maxsinangle = Math.sin(maxangle)
-  while (subdivideBase < newpoints.length - 1) {
-    const dir1 = vec2.subtract(v0, newpoints[subdivideBase], newpoints[subdivideBase - 1])
+  const maxAngle = TAU / segments
+  const maxSinAngle = Math.sin(maxAngle)
+  while (subdivideBase < newPoints.length - 1) {
+    const dir1 = vec2.subtract(v0, newPoints[subdivideBase], newPoints[subdivideBase - 1])
     vec2.normalize(dir1, dir1)
-    const dir2 = vec2.subtract(v1, newpoints[subdivideBase + 1], newpoints[subdivideBase])
+    const dir2 = vec2.subtract(v1, newPoints[subdivideBase + 1], newPoints[subdivideBase])
     vec2.normalize(dir2, dir2)
-    const sinangle = vec2.cross(v3, dir1, dir2) // the sine of the angle
-    if (Math.abs(sinangle[2]) > maxsinangle) {
+    const sinAngle = vec2.cross(v3, dir1, dir2) // the sine of the angle
+    if (Math.abs(sinAngle[2]) > maxSinAngle) {
       // angle is too big, we need to subdivide
-      const t0 = newpointsT[subdivideBase - 1]
-      const t1 = newpointsT[subdivideBase + 1]
+      const t0 = newPointsT[subdivideBase - 1]
+      const t1 = newPointsT[subdivideBase + 1]
       const newt0 = t0 + (t1 - t0) * 1 / 3
       const newt1 = t0 + (t1 - t0) * 2 / 3
       const point0 = getPointForT(newt0)
       const point1 = getPointForT(newt1)
       // remove the point at subdivideBase and replace with 2 new points:
-      newpoints.splice(subdivideBase, 1, point0, point1)
-      newpointsT.splice(subdivideBase, 1, newt0, newt1)
-      // re - evaluate the angles, starting at the previous junction since it has changed:
+      newPoints.splice(subdivideBase, 1, point0, point1)
+      newPointsT.splice(subdivideBase, 1, newt0, newt1)
+      // reevaluate the angles, starting at the previous junction since it has changed:
       subdivideBase--
       if (subdivideBase < 1) subdivideBase = 1
     } else {
@@ -147,10 +147,8 @@ const appendBezier = (options, geometry) => {
 
   // append to the new points to the given path
   // but skip the first new point because it is identical to the last point in the given path
-  newpoints.shift()
-  const result = appendPoints(newpoints, geometry)
+  newPoints.shift()
+  const result = appendPoints(newPoints, geometry)
   result.lastBezierControlPoint = controlPoints[controlPoints.length - 2]
   return result
 }
-
-module.exports = appendBezier