@jscad/modeling 2.12.5 → 3.0.1-alpha.0

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

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { appendBezier, fromPoints, toPoints } = require('./index')
+import { appendBezier, fromPoints, toPoints } from './index.js'
 
-const { comparePoints } = require('../../../test/helpers/')
+import { comparePoints } from '../../../test/helpers/index.js'
 
 test('appendBezier: appending to an empty path produces an error', (t) => {
   const p1 = fromPoints({}, [])

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

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

package/src/geometries/path2/appendPoints.js

@@ -1,15 +1,13 @@
-const concat = require('./concat')
-const create = require('./create')
+import { concat } from './concat.js'
+import { create } from './create.js'
 
 /**
  * Append the given list of points to the end of the given geometry.
  * @param {Array} points - the points (2D) to append to the given path
- * @param {path2} geometry - the given path
- * @returns {path2} a new path with the appended points
+ * @param {Path2} geometry - the given path
+ * @returns {Path2} a new path with the appended points
  * @alias module:modeling/geometries/path2.appendPoints
  * @example
- * let newpath = appendPoints([[3, 4], [4, 5]], oldpath)
+ * let newPath = appendPoints([[3, 4], [4, 5]], oldPath)
  */
-const appendPoints = (points, geometry) => concat(geometry, create(points))
-
-module.exports = appendPoints
+export const appendPoints = (points, geometry) => concat(geometry, create(points))

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { appendPoints, fromPoints, toPoints } = require('./index')
+import { appendPoints, fromPoints, toPoints } from './index.js'
 
 test('appendPoints: appending to an empty path produces a new path with expected points', (t) => {
   const p1 = fromPoints({}, [])

package/src/geometries/path2/applyTransforms.js

@@ -1,5 +1,5 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec2 from '../../maths/vec2/index.js'
 
 /*
  * Apply the transforms of the given geometry.
@@ -9,12 +9,10 @@ const vec2 = require('../../maths/vec2')
  * @example
  * geometry = applyTransforms(geometry)
  */
-const applyTransforms = (geometry) => {
+export const applyTransforms = (geometry) => {
   if (mat4.isIdentity(geometry.transforms)) return geometry
 
   geometry.points = geometry.points.map((point) => vec2.transform(vec2.create(), point, geometry.transforms))
   geometry.transforms = mat4.create()
   return geometry
 }
-
-module.exports = applyTransforms

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

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { fromPoints } = require('./index')
+import { fromPoints } from './index.js'
 
-const applyTransforms = require('./applyTransforms')
+import { applyTransforms } from './applyTransforms.js'
 
-const { comparePoints, compareVectors } = require('../../../test/helpers/')
+import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
 
 test('applyTransforms: Updates a populated path with transformed points', (t) => {
   const points = [[0, 0], [1, 0], [0, 1]]

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

@@ -1,5 +1,3 @@
-import Path2 from './type'
+import type { Path2 } from './type.d.ts'
 
-export default clone
-
-declare function clone(geometry: Path2): Path2
+export function clone(geometry: Path2): Path2

package/src/geometries/path2/clone.js

@@ -1,9 +1,7 @@
 /**
  * Performs a shallow clone of the give geometry.
- * @param {path2} geometry - the geometry to clone
- * @returns {path2} a new path
+ * @param {Path2} geometry - the geometry to clone
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.clone
  */
-const clone = (geometry) => Object.assign({}, geometry)
-
-module.exports = clone
+export const clone = (geometry) => Object.assign({}, geometry)

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

@@ -1,5 +1,3 @@
-import Path2 from './type'
+import type { Path2 } from './type.d.ts'
 
-export default close
-
-declare function close(geometry: Path2): Path2
+export function close(geometry: Path2): Path2

package/src/geometries/path2/close.js

@@ -1,16 +1,16 @@
-const { EPS } = require('../../maths/constants')
+import { EPS } from '../../maths/constants.js'
 
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-const clone = require('./clone')
+import { clone } from './clone.js'
 
 /**
  * Close the given geometry.
- * @param {path2} geometry - the path to close
- * @returns {path2} a new path
+ * @param {Path2} geometry - the path to close
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.close
  */
-const close = (geometry) => {
+export const close = (geometry) => {
   if (geometry.isClosed) return geometry
 
   const cloned = clone(geometry)
@@ -29,5 +29,3 @@ const close = (geometry) => {
   }
   return cloned
 }
-
-module.exports = close

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { close, create, fromPoints } = require('./index')
+import { close, create, fromPoints } from './index.js'
 
 test('close: closes an empty path', (t) => {
   const p1 = create()

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

@@ -1,5 +1,3 @@
-import Path2 from './type'
+import type { Path2 } from './type.d.ts'
 
-export default concat
-
-declare function concat(...paths: Array<Path2>): Path2
+export function concat(...paths: Array<Path2>): Path2

package/src/geometries/path2/concat.js

@@ -1,7 +1,7 @@
-const fromPoints = require('./fromPoints')
-const toPoints = require('./toPoints')
+import { equals } from '../../maths/vec2/index.js'
 
-const { equals } = require('../../maths/vec2')
+import { fromPoints } from './fromPoints.js'
+import { toPoints } from './toPoints.js'
 
 /**
  * Concatenate the given paths.
@@ -10,27 +10,25 @@ const { equals } = require('../../maths/vec2')
  * A concatenation of zero paths is an empty, open path.
  * A concatenation of one closed path to a series of open paths produces a closed path.
  * A concatenation of a path to a closed path is an error.
- * @param {...path2} paths - the paths to concatenate
- * @returns {path2} a new path
+ * @param {...Path2} paths - the paths to concatenate
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.concat
  *
  * @example
- * let newpath = concat(fromPoints({}, [[1, 2]]), fromPoints({}, [[3, 4]]))
+ * let newPath = concat(fromPoints({}, [[1, 2]]), fromPoints({}, [[3, 4]]))
  */
-const concat = (...paths) => {
+export const concat = (...paths) => {
   // Only the last path can be closed, producing a closed path.
   let isClosed = false
-  let newpoints = []
+  let newPoints = []
   paths.forEach((path, i) => {
     const tmp = toPoints(path).slice()
-    if (newpoints.length > 0 && tmp.length > 0 && equals(tmp[0], newpoints[newpoints.length - 1])) tmp.shift()
+    if (newPoints.length > 0 && tmp.length > 0 && equals(tmp[0], newPoints[newPoints.length - 1])) tmp.shift()
     if (tmp.length > 0 && isClosed) {
       throw new Error(`Cannot concatenate to a closed path; check the ${i}th path`)
     }
     isClosed = path.isClosed
-    newpoints = newpoints.concat(tmp)
+    newPoints = newPoints.concat(tmp)
   })
-  return fromPoints({ closed: isClosed }, newpoints)
+  return fromPoints({ closed: isClosed }, newPoints)
 }
-
-module.exports = concat

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { concat, equals, fromPoints } = require('./index')
+import { concat, equals, fromPoints } from './index.js'
 
 test('concat: No paths produces an empty open path', (t) => {
   t.true(equals(concat(), fromPoints({ closed: false }, [])))

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

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

package/src/geometries/path2/create.js

@@ -1,22 +1,27 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Represents a 2D geometry consisting of a list of ordered points.
- * @typedef {Object} path2
  * @property {Array} points - list of ordered points
- * @property {Boolean} isClosed - true if the path is closed where start and end points are the same
- * @property {mat4} transforms - transforms to apply to the points, see transform()
+ * @property {boolean} isClosed - true if the path is closed where start and end points are the same
+ * @property {Mat4} transforms - transforms to apply to the points, see transform()
+ * @example
+ * {
+ *   "points": [[0,0], [4,0], [4,3]],
+ *   "isClosed": true,
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ * }
  */
 
 /**
  * Create an empty, open path.
- * @returns {path2} a new path
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.create
  *
  * @example
- * let newpath = create()
+ * let newPath = create()
  */
-const create = (points) => {
+export const create = (points) => {
   if (points === undefined) {
     points = []
   }
@@ -26,5 +31,3 @@ const create = (points) => {
     transforms: mat4.create()
   }
 }
-
-module.exports = create

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { create, equals, fromPoints } = require('./index')
+import { create, equals, fromPoints } from './index.js'
 
 test('create: Creates an empty path', (t) => {
   t.true(equals(create(), fromPoints({ closed: false }, [])))

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

@@ -1,5 +1,3 @@
-import Path2 from './type'
+import type { Path2 } from './type.d.ts'
 
-export default equals
-
-declare function equals(a: Path2, b: Path2): boolean
+export function equals(a: Path2, b: Path2): boolean

package/src/geometries/path2/equals.js

@@ -1,16 +1,16 @@
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-const toPoints = require('./toPoints')
+import { toPoints } from './toPoints.js'
 
 /**
   * Determine if the given paths are equal.
   * For closed paths, this includes equality under point order rotation.
-  * @param {path2} a - the first path to compare
-  * @param {path2} b - the second path to compare
+  * @param {Path2} a - the first path to compare
+  * @param {Path2} b - the second path to compare
   * @returns {Boolean}
   * @alias module:modeling/geometries/path2.equals
   */
-const equals = (a, b) => {
+export const equals = (a, b) => {
   if (a.isClosed !== b.isClosed) {
     return false
   }
@@ -18,17 +18,17 @@ const equals = (a, b) => {
     return false
   }
 
-  const apoints = toPoints(a)
-  const bpoints = toPoints(b)
+  const aPoints = toPoints(a)
+  const bPoints = toPoints(b)
 
   // closed paths might be equal under graph rotation
   // so try comparison by rotating across all points
-  const length = apoints.length
+  const length = aPoints.length
   let offset = 0
   do {
     let unequal = false
     for (let i = 0; i < length; i++) {
-      if (!vec2.equals(apoints[i], bpoints[(i + offset) % length])) {
+      if (!vec2.equals(aPoints[i], bPoints[(i + offset) % length])) {
         unequal = true
         break
       }
@@ -43,5 +43,3 @@ const equals = (a, b) => {
   } while (++offset < length)
   return false
 }
-
-module.exports = equals

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { equals, fromPoints } = require('./index')
+import { equals, fromPoints } from './index.js'
 
 test('equals: two paths with different points are not equal', (t) => {
   const p1 = fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1]])

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

@@ -1,5 +1,3 @@
-import Path2 from './type'
+import type { Path2 } from './type.d.ts'
 
-export default fromCompactBinary
-
-declare function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Path2
+export function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Path2

package/src/geometries/path2/fromCompactBinary.js

@@ -1,15 +1,15 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec2 from '../../maths/vec2/index.js'
 
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Create a new path from the given compact binary data.
  * @param {TypedArray} data - compact binary data
- * @returns {path2} a new path
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.fromCompactBinary
  */
-const fromCompactBinary = (data) => {
+export const fromCompactBinary = (data) => {
   if (data[0] !== 2) throw new Error('invalid compact binary data')
 
   const created = create()
@@ -29,5 +29,3 @@ const fromCompactBinary = (data) => {
   // TODO: how about custom properties or fields ?
   return created
 }
-
-module.exports = fromCompactBinary

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

@@ -1,10 +1,8 @@
-import Path2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default fromPoints
+import type { Path2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
 export interface FromPointsOptions {
   closed?: boolean
 }
 
-declare function fromPoints(options: FromPointsOptions, points: Array<Vec2>): Path2
+export function fromPoints(options: FromPointsOptions, points: Array<Vec2>): Path2

package/src/geometries/path2/fromPoints.js

@@ -1,24 +1,24 @@
-const { EPS } = require('../../maths/constants')
+import { EPS } from '../../maths/constants.js'
 
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-const close = require('./close')
-const create = require('./create')
+import { close } from './close.js'
+import { create } from './create.js'
 
 /**
  * Create a new path from the given points.
  * The points must be provided an array of points,
  * where each point is an array of two numbers.
- * @param {Object} options - options for construction
- * @param {Boolean} [options.closed=false] - if the path should be open or closed
+ * @param {object} options - options for construction
+ * @param {boolean} [options.closed=false] - if the path should be open or closed
  * @param {Array} points - array of points (2D) from which to create the path
- * @returns {path2} a new path
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.fromPoints
  *
  * @example:
- * my newpath = fromPoints({closed: true}, [[10, 10], [-10, 10]])
+ * my newPath = fromPoints({closed: true}, [[10, 10], [-10, 10]])
  */
-const fromPoints = (options, points) => {
+export const fromPoints = (options, points) => {
   const defaults = { closed: false }
   let { closed } = Object.assign({}, defaults, options)
 
@@ -38,5 +38,3 @@ const fromPoints = (options, points) => {
 
   return created
 }
-
-module.exports = fromPoints

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const vec2 = require('../../maths/vec2')
+import { vec2 } from '../../maths/index.js'
 
-const { fromPoints, toPoints, toString } = require('./index')
+import { fromPoints, toPoints, toString } from './index.js'
 
 test('fromPoints: creating a path from no points produces an open, empty non-canonical path', (t) => {
   const created = fromPoints({}, [])

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { fromCompactBinary, toCompactBinary, create, fromPoints } = require('./index')
+import { fromCompactBinary, toCompactBinary, create, fromPoints } from './index.js'
 
 test('toCompactBinary: converts path2 into a compact form', (t) => {
   const geometry1 = create()