@jscad/modeling 2.11.1 → 3.0.0-alpha.0

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()

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

@@ -1,20 +1,19 @@
-export { default as appendArc, AppendArcOptions } from './appendArc'
-export { default as appendBezier, AppendBezierOptions } from './appendBezier'
-export { default as appendPoints } from './appendPoints'
-export { default as clone } from './clone'
-export { default as close } from './close'
-export { default as concat } from './concat'
-export { default as create } from './create'
-export { default as equals } from './equals'
-export { default as fromPoints, FromPointsOptions } from './fromPoints'
-export { default as fromCompactBinary } from './fromCompactBinary'
-export { default as isA } from './isA'
-export { default as reverse } from './reverse'
-export { default as toPoints } from './toPoints'
-export { default as toString } from './toString'
-export { default as toCompactBinary } from './toCompactBinary'
-export { default as transform } from './transform'
-export { default as validate } from './validate'
+export { appendArc, AppendArcOptions } from './appendArc.js'
+export { appendBezier, AppendBezierOptions } from './appendBezier.js'
+export { appendPoints } from './appendPoints.js'
+export { clone } from './clone.js'
+export { close } from './close.js'
+export { concat } from './concat.js'
+export { create } from './create.js'
+export { equals } from './equals.js'
+export { fromPoints, FromPointsOptions } from './fromPoints.js'
+export { fromCompactBinary } from './fromCompactBinary.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toPoints } from './toPoints.js'
+export { toString } from './toString.js'
+export { toCompactBinary } from './toCompactBinary.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
 
-export { default as Path2 } from './type'
-export as namespace path2
+export type { Path2 } from './type.d.ts'

package/src/geometries/path2/index.js

@@ -4,32 +4,23 @@
  * @module modeling/geometries/path2
  *
  * @example
- * colorize([0,0,0,1], path2.fromPoints({ closed: true }, [[0,0], [4,0], [4,3]]))
- *
- * @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],
- *   "color": [0,0,0,1]
- * }
+ * import { geometries } from '@jscad/modeling'
+ * let myShape = geometries.path2.fromPoints({ closed: true }, [[0,0], [4,0], [4,3]])
  */
-module.exports = {
-  appendArc: require('./appendArc'),
-  appendBezier: require('./appendBezier'),
-  appendPoints: require('./appendPoints'),
-  clone: require('./clone'),
-  close: require('./close'),
-  concat: require('./concat'),
-  create: require('./create'),
-  equals: require('./equals'),
-  fromPoints: require('./fromPoints'),
-  fromCompactBinary: require('./fromCompactBinary'),
-  isA: require('./isA'),
-  reverse: require('./reverse'),
-  toPoints: require('./toPoints'),
-  toString: require('./toString'),
-  toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform'),
-  validate: require('./validate')
-}
+export { appendArc } from './appendArc.js'
+export { appendBezier } from './appendBezier.js'
+export { appendPoints } from './appendPoints.js'
+export { clone } from './clone.js'
+export { close } from './close.js'
+export { concat } from './concat.js'
+export { create } from './create.js'
+export { equals } from './equals.js'
+export { fromPoints } from './fromPoints.js'
+export { fromCompactBinary } from './fromCompactBinary.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toPoints } from './toPoints.js'
+export { toString } from './toString.js'
+export { toCompactBinary } from './toCompactBinary.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

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

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

package/src/geometries/path2/isA.js

@@ -1,10 +1,10 @@
 /**
  * Determine if the given object is a path2 geometry.
- * @param {Object} object - the object to interrogate
+ * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a path2
  * @alias module:modeling/geometries/path2.isA
  */
-const isA = (object) => {
+export const isA = (object) => {
   if (object && typeof object === 'object') {
     // see create for the required attributes and types
     if ('points' in object && 'transforms' in object && 'isClosed' in object) {
@@ -16,5 +16,3 @@ const isA = (object) => {
   }
   return false
 }
-
-module.exports = isA

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isA, create, fromPoints } = require('./index')
+import { isA, create, fromPoints } from './index.js'
 
 test('isA: identifies created paths', (t) => {
   const p1 = create()

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

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

package/src/geometries/path2/reverse.js

@@ -1,20 +1,18 @@
-const clone = require('./clone')
+import { clone } from './clone.js'
 
 /**
  * Reverses the path so that the points are in the opposite order.
  * This swaps the left (interior) and right (exterior) edges.
- * @param {path2} geometry - the path to reverse
- * @returns {path2} a new path
+ * @param {Path2} geometry - the path to reverse
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.reverse
  *
  * @example
- * let newpath = reverse(mypath)
+ * let newPath = reverse(myPath)
  */
-const reverse = (geometry) => {
+export const reverse = (geometry) => {
   // NOTE: this only updates the order of the points
   const cloned = clone(geometry)
   cloned.points = geometry.points.slice().reverse()
   return cloned
 }
-
-module.exports = reverse

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { reverse, equals, fromPoints } = require('./index')
+import { reverse, equals, fromPoints } from './index.js'
 
 test('reverse: The reverse of a path has reversed points', (t) => {
   const pointArray = [[0, 0], [1, 1]]

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

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

package/src/geometries/path2/toCompactBinary.js

@@ -1,10 +1,10 @@
 /**
  * Produce a compact binary representation from the given path.
- * @param {path2} geometry - the path geometry
+ * @param {Path2} geometry - the path geometry
  * @returns {TypedArray} compact binary representation
  * @alias module:modeling/geometries/path2.toCompactBinary
  */
-const toCompactBinary = (geometry) => {
+export const toCompactBinary = (geometry) => {
   const points = geometry.points
   const transforms = geometry.transforms
   let color = [-1, -1, -1, -1]
@@ -48,5 +48,3 @@ const toCompactBinary = (geometry) => {
   // TODO: how about custom properties or fields ?
   return compacted
 }
-
-module.exports = toCompactBinary

package/src/geometries/path2/toPoints.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 toPoints
-
-declare function toPoints(geometry: Path2): Array<Vec2>
+export function toPoints(geometry: Path2): Array<Vec2>

package/src/geometries/path2/toPoints.js

@@ -1,15 +1,13 @@
-const applyTransforms = require('./applyTransforms')
+import { applyTransforms } from './applyTransforms.js'
 
 /**
  * Produces an array of points from the given geometry.
  * The returned array should not be modified as the data is shared with the geometry.
- * @param {path2} geometry - the geometry
+ * @param {Path2} geometry - the geometry
  * @returns {Array} an array of points
  * @alias module:modeling/geometries/path2.toPoints
  *
  * @example
- * let sharedpoints = toPoints(geometry)
+ * let sharedPoints = toPoints(geometry)
  */
-const toPoints = (geometry) => applyTransforms(geometry).points
-
-module.exports = toPoints
+export const toPoints = (geometry) => applyTransforms(geometry).points

package/src/geometries/path2/toPoints.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 { toPoints, fromPoints } = require('./index')
+import { toPoints, fromPoints } from './index.js'
 
 test('toPoints: An empty path produces an empty point array', (t) => {
   t.deepEqual(toPoints(fromPoints({}, [])), [])

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

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

package/src/geometries/path2/toString.js

@@ -1,17 +1,17 @@
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-const toPoints = require('./toPoints')
+import { toPoints } from './toPoints.js'
 
 /**
  * Create a string representing the contents of the given path.
- * @param {path2} geometry - the path
- * @returns {String} a representative string
+ * @param {Path2} geometry - the path
+ * @returns {string} a representative string
  * @alias module:modeling/geometries/path2.toString
  *
  * @example
  * console.out(toString(path))
  */
-const toString = (geometry) => {
+export const toString = (geometry) => {
   const points = toPoints(geometry)
   let result = 'path (' + points.length + ' points, ' + geometry.isClosed + '):\n[\n'
   points.forEach((point) => {
@@ -20,5 +20,3 @@ const toString = (geometry) => {
   result += ']\n'
   return result
 }
-
-module.exports = toString

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

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

package/src/geometries/path2/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 points, as this function only adjusts the transforms.
  * The transforms are applied when accessing the points via toPoints().
- * @param {mat4} matrix - the matrix to transform with
- * @param {path2} geometry - the geometry to transform
- * @returns {path2} a new path
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Path2} geometry - the geometry to transform
+ * @returns {Path2} a new path
  * @alias module:modeling/geometries/path2.transform
  *
  * @example
- * let newpath = transform(fromZRotation(TAU / 8), path)
+ * let newPath = transform(fromZRotation(TAU / 8), path)
  */
-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/path2/transform.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { transform, fromPoints, toPoints } = require('./index')
+import { transform, fromPoints, toPoints } from './index.js'
 
-const { comparePoints, compareVectors } = require('../../../test/helpers/')
+import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
 
 test('transform: adjusts the transforms of path', (t) => {
   const points = [[0, 0], [1, 0], [0, 1]]
@@ -33,7 +33,7 @@ test('transform: adjusts the transforms of path', (t) => {
   t.false(another.isClosed)
   t.true(compareVectors(another.transforms, expected.transforms))
 
-  // expect application of the transforms to the sides
+  // expect application of the transforms to the points
   expected.points = [[5, 10], [5, 11], [4, 10]]
   expected.transforms = mat4.create()
   toPoints(another)

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

@@ -1,10 +1,8 @@
-import Vec2 from '../../maths/vec2/type'
-import Mat4 from '../../maths/mat4/type'
-import { Color } from '../types'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { Color } from '../types.d.ts'
 
-export default Path2
-
-declare interface Path2 {
+export interface Path2 {
   points: Array<Vec2>
   isClosed: boolean
   transforms: Mat4

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

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

package/src/geometries/path2/validate.js

@@ -1,5 +1,6 @@
-const vec2 = require('../../maths/vec2')
-const isA = require('./isA')
+import * as vec2 from '../../maths/vec2/index.js'
+
+import { isA } from './isA.js'
 
 /**
  * Determine if the given object is a valid path2.
@@ -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/path2.validate
  */
-const validate = (object) => {
+export const validate = (object) => {
   if (!isA(object)) {
     throw new Error('invalid path2 structure')
   }
@@ -20,7 +21,7 @@ const validate = (object) => {
   if (object.points.length > 1) {
     for (let i = 0; i < object.points.length; i++) {
       if (vec2.equals(object.points[i], object.points[(i + 1) % object.points.length])) {
-        throw new Error(`path2 duplicate points ${object.points[i]}`)
+        throw new Error(`path2 has duplicate point ${object.points[i]}`)
       }
     }
   }
@@ -37,5 +38,3 @@ const validate = (object) => {
     throw new Error(`path2 invalid transforms ${object.transforms}`)
   }
 }
-
-module.exports = validate

package/src/geometries/poly2/arePointsInside.d.ts

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

package/src/geometries/poly2/arePointsInside.js

@@ -1,25 +1,24 @@
-const measureArea = require('./measureArea')
-const flip = require('./flip')
+import { measureArea } from './measureArea.js'
+import { reverse } from './reverse.js'
 
 /**
  * Determine if the given points are inside the given polygon.
  *
  * @param {Array} points - a list of points, where each point is an array with X and Y values
- * @param {poly2} polygon - a 2D polygon
- * @return {Integer} 1 if all points are inside, 0 if some or none are inside
+ * @param {Poly2} polygon - a 2D polygon
+ * @return {number} 1 if all points are inside, 0 if some or none are inside
  * @alias module:modeling/geometries/poly2.arePointsInside
  */
-const arePointsInside = (points, polygon) => {
+export const arePointsInside = (points, polygon) => {
   if (points.length === 0) return 0 // nothing to check
 
-  const vertices = polygon.vertices
-  if (vertices.length < 3) return 0 // nothing can be inside an empty polygon
+  if (polygon.points.length < 3) return 0 // nothing can be inside an empty polygon
 
   if (measureArea(polygon) < 0) {
-    polygon = flip(polygon) // CCW is required
+    polygon = reverse(polygon) // CCW is required
   }
 
-  const sum = points.reduce((acc, point) => acc + isPointInside(point, vertices), 0)
+  const sum = points.reduce((acc, point) => acc + isPointInside(point, polygon.points), 0)
   return sum === points.length ? 1 : 0
 }
 
@@ -29,42 +28,42 @@ const arePointsInside = (points, polygon) => {
  * @see http://erich.realtimerendering.com/ptinpoly/ (Crossings Test)
  * @param {Array} point - an array with X and Y values
  * @param {Array} polygon - a list of points, where each point is an array with X and Y values
- * @return {Integer} 1 if the point is inside, 0 if outside
+ * @return {number} 1 if the point is inside, 0 if outside
  */
 const isPointInside = (point, polygon) => {
-  const numverts = polygon.length
+  const numPoints = polygon.length
 
   const tx = point[0]
   const ty = point[1]
 
-  let vtx0 = polygon[numverts - 1]
+  let vtx0 = polygon[numPoints - 1]
   let vtx1 = polygon[0]
 
-  let yflag0 = (vtx0[1] > ty)
+  let yFlag0 = (vtx0[1] > ty)
 
   let insideFlag = 0
 
   let i = 0
-  for (let j = (numverts + 1); --j;) {
+  for (let j = (numPoints + 1); --j;) {
     /*
      * check if Y endpoints straddle (are on opposite sides) of point's Y
      * if so, +X ray could intersect this edge.
      */
-    const yflag1 = (vtx1[1] > ty)
-    if (yflag0 !== yflag1) {
+    const yFlag1 = (vtx1[1] > ty)
+    if (yFlag0 !== yFlag1) {
       /*
        * check if X endpoints are on same side of the point's X
        * if so, it's easy to test if edge hits or misses.
        */
-      const xflag0 = (vtx0[0] > tx)
-      const xflag1 = (vtx1[0] > tx)
-      if (xflag0 && xflag1) {
+      const xFlag0 = (vtx0[0] > tx)
+      const xFlag1 = (vtx1[0] > tx)
+      if (xFlag0 && xFlag1) {
         /* if edge's X values are both right of the point, then the point must be inside */
         insideFlag = !insideFlag
       } else {
         /*
          * if X endpoints straddle the point, then
-         * the compute intersection of polygon edge with +X ray
+         * compute the intersection of polygon edge with +X ray
          * if intersection >= point's X then the +X ray hits it.
          */
         if ((vtx1[0] - (vtx1[1] - ty) * (vtx0[0] - vtx1[0]) / (vtx0[1] - vtx1[1])) >= tx) {
@@ -72,19 +71,10 @@ const isPointInside = (point, polygon) => {
         }
       }
     }
-    /* move to next pair of vertices, retaining info as possible */
-    yflag0 = yflag1
+    /* move to next pair of points, retaining info as possible */
+    yFlag0 = yFlag1
     vtx0 = vtx1
     vtx1 = polygon[++i]
   }
   return insideFlag
 }
-
-/*
- * > 0 : p2 is left of the line p0 -> p1
- * = 0 : p2 is on the line p0 -> p1
- * < 0 : p2 is right of the line p0 -> p1
- */
-const isLeft = (p0, p1, p2) => (p1[0] - p0[0]) * (p2[1] - p0[1]) - (p2[0] - p0[0]) * (p1[1] - p0[1])
-
-module.exports = arePointsInside

package/src/geometries/poly2/arePointsInside.test.js

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { arePointsInside, create } = require('./index')
+import { arePointsInside, create } from './index.js'
 
 test('poly2: arePointsInside() should return proper values', (t) => {
   let polygon = create()

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

@@ -0,0 +1,3 @@
+import type { Poly2 } from './type.d.ts'
+
+export function clone(polygon: Poly2): Poly2

package/src/geometries/poly2/clone.js

@@ -0,0 +1,8 @@
+/**
+ * Create a shallow clone of the given polygon.
+ *
+ * @param {Poly2} polygon - polygon to clone
+ * @returns {Poly2} a new polygon
+ * @alias module:modeling/geometries/poly2.clone
+ */
+export const clone = (polygon) => Object.assign({}, polygon)