@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/utils/padArrayToLength.js

@@ -2,16 +2,14 @@
  * Build an array of at minimum a specified length from an existing array and a padding value. IF the array is already larger than the target length, it will not be shortened.
  * @param {Array} anArray - the source array to copy into the result.
  * @param {*} padding - the value to add to the new array to reach the desired length.
- * @param {Number} targetLength - The desired length of the return array.
+ * @param {number} targetLength - The desired length of the return array.
  * @returns {Array} an array of at least 'targetLength' length
  * @alias module:modeling/utils.padArrayToLength
  */
-const padArrayToLength = (anArray, padding, targetLength) => {
+export const padArrayToLength = (anArray, padding, targetLength) => {
   anArray = anArray.slice()
   while (anArray.length < targetLength) {
     anArray.push(padding)
   }
   return anArray
 }
-
-module.exports = padArrayToLength

package/src/utils/padArrayToLength.test.js

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const padArrayToLength = require('./padArrayToLength')
+import { padArrayToLength } from './padArrayToLength.js'
 
 test('padArrayToLength: test an array of the proper length is unchanged.', (t) => {
   const srcArray = [2, 3, 4]

package/src/utils/radToDeg.d.ts

@@ -1,3 +1 @@
-export default radToDeg
-
-declare function radToDeg(radians: number): number
+export function radToDeg(radians: number): number

package/src/utils/radToDeg.js

@@ -1,9 +1,7 @@
 /**
  * Convert the given angle (radians) to degrees.
- * @param {Number} radians - angle in radians
- * @returns {Number} angle in degrees
+ * @param {number} radians - angle in radians
+ * @returns {number} angle in degrees
  * @alias module:modeling/utils.radToDeg
  */
-const radToDeg = (radians) => radians * 57.29577951308232
-
-module.exports = radToDeg
+export const radToDeg = (radians) => radians * 57.29577951308232

package/src/utils/radToDeg.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const { radToDeg } = require('./index')
+import { radToDeg } from './index.js'
 
 test('utils: radToDeg() should return correct values', (t) => {
   const obs1 = radToDeg(0)

package/src/utils/radiusToSegments.d.ts

@@ -1,3 +1 @@
-export default radiusToSegments
-
-declare function radiusToSegments(radius: number, minimumLength?: number, minimumAngle?: number): number
+export function radiusToSegments(radius: number, minimumLength?: number, minimumAngle?: number): number

package/src/utils/radiusToSegments.js

@@ -1,18 +1,16 @@
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
 /**
  * Calculate the number of segments from the given radius based on minimum length or angle.
- * @param {Number} radius - radius of the requested shape
- * @param {Number} minimumLength - minimum length of segments; length > 0
- * @param {Number} minimumAngle - minimum angle (radians) between segments; 0 > angle < TAU
- * @returns {Number} number of segments to complete the radius
+ * @param {number} radius - radius of the requested shape
+ * @param {number} minimumLength - minimum length of segments; length > 0
+ * @param {number} minimumAngle - minimum angle (radians) between segments; 0 > angle < TAU
+ * @returns {number} number of segments to complete the radius
  * @alias module:modeling/utils.radiusToSegments
  */
-const radiusToSegments = (radius, minimumLength, minimumAngle) => {
+export const radiusToSegments = (radius, minimumLength, minimumAngle) => {
   const ss = minimumLength > 0 ? radius * TAU / minimumLength : 0
   const as = minimumAngle > 0 ? TAU / minimumAngle : 0
   // minimum segments is four(4) for round primitives
   return Math.ceil(Math.max(ss, as, 4))
 }
-
-module.exports = radiusToSegments

package/src/utils/radiusToSegments.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const { radiusToSegments } = require('./index')
+import { radiusToSegments } from './index.js'
 
 test('utils: radiusToSegments() should return correct values', (t) => {
   // test defaults

package/src/utils/recursiveArray.d.ts

@@ -1,3 +1 @@
-export default RecursiveArray
-
-declare interface RecursiveArray<T> extends Array<T | RecursiveArray<T>> {}
+export interface RecursiveArray<T> extends Array<T | RecursiveArray<T>> {}

package/test/helpers/asserts.js

@@ -1,11 +1,12 @@
-const { toPolygons } = require('../../src/core/CSGToOther')
+import { toPolygons } from '../../src/core/CSGToOther.js'
+
 // Compare two polygons together.
 // They are identical if they are composed with the same vertices in the same
 // relative order
 // todo: could be part of csg.js
 // todo: should simplify colinear vertices
 // @return true if both polygons are identical
-const comparePolygons = (a, b) => {
+export const comparePolygons = (a, b) => {
   // First find one matching vertice
   // We try to find the first vertice of a inside b
   // If there is no such vertice, then a != b
@@ -35,7 +36,7 @@ const comparePolygons = (a, b) => {
   return true
 }
 
-const assertSameGeometry = (t, observed, expected, failMessage) => {
+export const assertSameGeometry = (t, observed, expected, failMessage) => {
   if (!containsCSG(observed, expected) || !containsCSG(observed, expected)) {
     failMessage = failMessage === undefined ? 'CSG do not have the same geometry' : failMessage
     t.fail(failMessage)
@@ -43,7 +44,7 @@ const assertSameGeometry = (t, observed, expected, failMessage) => {
 }
 
 // a contains b if b polygons are also found in a
-const containsCSG = (observed, expected) => {
+export const containsCSG = (observed, expected) => {
   console.log('Observed: ', observed)
   console.log('Expected: ', expected)
 
@@ -60,18 +61,18 @@ const containsCSG = (observed, expected) => {
   }).reduce((observed, expected) => observed && expected)
 }
 
-const simplifiedPolygon = (polygon) => {
+export const simplifiedPolygon = (polygon) => {
   const vertices = polygon.vertices.map((vertex) => [vertex.pos._x, vertex.pos._y, vertex.pos._z])
   const plane = { normal: [polygon.plane.normal._x, polygon.plane.normal._y, polygon.plane.normal._z], w: polygon.plane.w }
   return { positions: vertices, plane, shared: polygon.shared }
 }
 
-const simplifieSides = (cag) => {
+export const simplifieSides = (cag) => {
   const sides = cag.sides.map((side) => [side.vertex0.pos._x, side.vertex0.pos._y, side.vertex1.pos._x, side.vertex1.pos._y])
   return sides.sort()
 }
 
-const nearlyEquals = (a, b, epsilon = 1) => {
+export const nearlyEquals = (a, b, epsilon = 1) => {
   if (a === b) { // shortcut, also handles infinities and NaNs
     return true
   }
@@ -96,7 +97,7 @@ const nearlyEquals = (a, b, epsilon = 1) => {
   return true
 }
 
-const CAGNearlyEquals = (observed, expected, precision) => {
+export const CAGNearlyEquals = (observed, expected, precision) => {
   if (observed.sides.length !== expected.sides.length) {
     return false
   }
@@ -116,11 +117,3 @@ const CAGNearlyEquals = (observed, expected, precision) => {
 
   return true
 }
-
-module.exports = {
-  assertSameGeometry,
-  comparePolygons,
-  simplifiedPolygon,
-  simplifieSides,
-  CAGNearlyEquals
-}

package/test/helpers/comparePoints.js

@@ -1,4 +1,4 @@
-const compareVectors = require('./compareVectors')
+import { compareVectors } from './compareVectors.js'
 
 /**
  * Compare two list of points for equality
@@ -6,11 +6,9 @@ const compareVectors = require('./compareVectors')
  * @param {Array} list2 - list of points
  * @returns {boolean} result of comparison
  */
-const comparePoints = (list1, list2) => {
+export const comparePoints = (list1, list2) => {
   if (list1.length === list2.length) {
     return list1.reduce((valid, point, index) => valid && compareVectors(list1[index], list2[index]), true)
   }
   return false
 }
-
-module.exports = comparePoints

package/test/helpers/comparePolygonLists.js

@@ -1,10 +1,8 @@
-const comparePolygons = require('./comparePolygons')
+import { comparePolygons } from './comparePolygons.js'
 
-const comparePolygonLists = (polygons1, polygons2) => {
+export const comparePolygonLists = (polygons1, polygons2) => {
   if (polygons1.length === polygons2.length) {
     return polygons1.reduce((valid, polygon, index) => (valid && comparePolygons(polygons1[index], polygons2[index])), true)
   }
   return false
 }
-
-module.exports = comparePolygonLists

package/test/helpers/comparePolygons.js

@@ -1,16 +1,14 @@
-const compareVectors = require('./compareVectors')
+import { compareVectors } from './compareVectors.js'
 
 /**
  * Compare two polygons for equality
- * @param (poly3} poly1 - polygon with plane and vertices
- * @param (poly3} poly2 - polygon with plane and vertices
+ * @param {Poly3} poly1 - polygon with plane and vertices
+ * @param {Poly3} poly2 - polygon with plane and vertices
  * @returns {boolean} result of comparison
  */
-const comparePolygons = (poly1, poly2) => {
+export const comparePolygons = (poly1, poly2) => {
   if (poly1.vertices.length === poly2.vertices.length) {
     return poly1.vertices.reduce((valid, vertex, index) => valid && compareVectors(poly1.vertices[index], poly2.vertices[index]), true)
   }
   return false
 }
-
-module.exports = comparePolygons

package/test/helpers/comparePolygonsAsPoints.js

@@ -1,4 +1,4 @@
-const compareVectors = require('./compareVectors')
+import { compareVectors } from './compareVectors.js'
 
 const comparePolygons = (poly1, poly2) => {
   if (poly1.length === poly2.length) {
@@ -9,15 +9,13 @@ const comparePolygons = (poly1, poly2) => {
 
 /**
  * Compare two list of points for equality
- * @param (Array} list1 - list of polygons, represented as points
- * @param (Array} list2 - list of polygons, represented as points
+ * @param {Array} list1 - list of polygons, represented as points
+ * @param {Array} list2 - list of polygons, represented as points
  * @returns {boolean} result of comparison
  */
-const comparePolygonsAsPoints = (list1, list2) => {
+export const comparePolygonsAsPoints = (list1, list2) => {
   if (list1.length === list2.length) {
     return list1.reduce((valid, polygon, index) => valid && comparePolygons(list1[index], list2[index]), true)
   }
   return false
 }
-
-module.exports = comparePolygonsAsPoints

package/test/helpers/compareVectors.js

@@ -1,12 +1,13 @@
-const { EPS } = require('../../src/maths/constants')
+import { EPS } from '../../src/maths/constants.js'
+
 /**
  * Compare two vectors for equality
- * @param {vec} vec1 - vector (array) of values
- * @param {vec} vec2 - vector (array) of values
+ * @param {number[]} vec1 - vector (array) of values
+ * @param {number[]} vec2 - vector (array) of values
  * @param {number} eps - Epsilon - the largest difference between two numbers to consider trivial
  * @returns {boolean} result of comparison
  */
-const compareVectors = (vec1, vec2, eps = EPS) => {
+export const compareVectors = (vec1, vec2, eps = EPS) => {
   if (vec1.length === vec2.length) {
     return vec1.reduce((valid, value, index) => {
       // get the values, which also does type conversions
@@ -32,5 +33,3 @@ const compareVectors = (vec1, vec2, eps = EPS) => {
   }
   return false
 }
-
-module.exports = compareVectors

package/test/helpers/index.js

@@ -1,8 +1,6 @@
-module.exports = {
-  comparePoints: require('./comparePoints'),
-  comparePolygonLists: require('./comparePolygonLists'),
-  comparePolygons: require('./comparePolygons'),
-  comparePolygonsAsPoints: require('./comparePolygonsAsPoints'),
-  compareVectors: require('./compareVectors'),
-  nearlyEqual: require('./nearlyEqual')
-}
+export { comparePoints } from './comparePoints.js'
+export { comparePolygonLists } from './comparePolygonLists.js'
+export { comparePolygons } from './comparePolygons.js'
+export { comparePolygonsAsPoints } from './comparePolygonsAsPoints.js'
+export { compareVectors } from './compareVectors.js'
+export { nearlyEqual } from './nearlyEqual.js'

package/test/helpers/nearlyEqual.js

@@ -1,6 +1,6 @@
 // Compare two numeric values for near equality.
 // the given test is fails if the numeric values are outside the given epsilon
-const nearlyEqual = (t, a, b, epsilon, failMessage) => {
+export const nearlyEqual = (t, a, b, epsilon, failMessage) => {
   if (typeof t !== 'object') {
     throw new Error('first argument must be a test object')
   }
@@ -30,5 +30,3 @@ const nearlyEqual = (t, a, b, epsilon, failMessage) => {
     t.fail(failMessage + '(' + a + ',' + b + ')')
   }
 }
-
-module.exports = nearlyEqual

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+     "allowJs": true,
+     "checkJs": true,
+     "noEmit": true,
+     "lib": ["dom", "es2020"],
+     "target": "es2015",
+     "moduleResolution": "nodenext"
+  },
+  "include": [
+    "src/**/*.js",
+    "global.d.ts"
+  ],
+  "exclude": [
+    "src/**/*.test.js"
+  ]
+}

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

@@ -1,6 +0,0 @@
-import Geom2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default fromPoints
-
-declare function fromPoints(points: Array<Vec2>): Geom2

package/src/geometries/geom2/fromPoints.js

@@ -1,35 +0,0 @@
-const vec2 = require('../../maths/vec2')
-
-const create = require('./create')
-
-/**
- * Create a new 2D geometry from the given points.
- * The direction (rotation) of the points is not relevant,
- * as the points can define a convex or a concave polygon.
- * The geometry must not self intersect, i.e. the sides cannot cross.
- * @param {Array} points - list of points in 2D space
- * @returns {geom2} a new geometry
- * @alias module:modeling/geometries/geom2.fromPoints
- */
-const fromPoints = (points) => {
-  if (!Array.isArray(points)) {
-    throw new Error('the given points must be an array')
-  }
-  let length = points.length
-  if (length < 3) {
-    throw new Error('the given points must define a closed geometry with three or more points')
-  }
-  // adjust length if the given points are closed by the same point
-  if (vec2.equals(points[0], points[length - 1])) --length
-
-  const sides = []
-  let prevpoint = points[length - 1]
-  for (let i = 0; i < length; i++) {
-    const point = points[i]
-    sides.push([vec2.clone(prevpoint), vec2.clone(point)])
-    prevpoint = point
-  }
-  return create(sides)
-}
-
-module.exports = fromPoints

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

@@ -1,22 +0,0 @@
-const test = require('ava')
-
-const { fromPoints } = require('./index')
-
-test('fromPoints: creates populated geom2', (t) => {
-  const points = [[0, 0], [1, 0], [0, 1]]
-  const expected = {
-    sides: [[[0, 1], [0, 0]], [[0, 0], [1, 0]], [[1, 0], [0, 1]]],
-    transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
-  }
-  t.deepEqual(fromPoints(points), expected)
-
-  const points2 = [[0, 0], [1, 0], [0, 1], [0, 0]]
-  t.deepEqual(fromPoints(points2), expected)
-})
-
-test('fromPoints: throws for improper points', (t) => {
-  t.throws(() => fromPoints(), { instanceOf: Error })
-  t.throws(() => fromPoints(0, 0), { instanceOf: Error })
-  t.throws(() => fromPoints([]), { instanceOf: Error })
-  t.throws(() => fromPoints([[0, 0]]), { instanceOf: Error })
-})

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

@@ -1,5 +0,0 @@
-import Poly2 from './type'
-
-export default flip
-
-declare function flip(polygon: Poly2): Poly2

package/src/geometries/poly2/flip.js

@@ -1,15 +0,0 @@
-const create = require('./create')
-
-/**
- * Flip the give polygon, rotating the opposite direction.
- *
- * @param {poly2} polygon - the polygon to flip
- * @returns {poly2} a new polygon
- * @alias module:modeling/geometries/poly2.flip
- */
-const flip = (polygon) => {
-  const vertices = polygon.vertices.slice().reverse()
-  return create(vertices)
-}
-
-module.exports = flip

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

@@ -1,6 +0,0 @@
-import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
-
-export default fromPoints
-
-declare function fromPoints(points: Array<Vec3>): Poly3

package/src/geometries/poly3/fromPoints.js

@@ -1,25 +0,0 @@
-const vec3 = require('../../maths/vec3')
-
-const create = require('./create')
-
-/**
- * Create a polygon from the given points.
- *
- * @param {Array} points - list of points (3D)
- * @returns {poly3} a new polygon
- * @alias module:modeling/geometries/poly3.fromPoints
- *
- * @example
- * const points = [
- *   [0,  0, 0],
- *   [0, 10, 0],
- *   [0, 10, 10]
- * ]
- * const polygon = fromPoints(points)
- */
-const fromPoints = (points) => {
-  const vertices = points.map((point) => vec3.clone(point))
-  return create(vertices)
-}
-
-module.exports = fromPoints

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

@@ -1,15 +0,0 @@
-const test = require('ava')
-
-const { fromPoints } = require('./index')
-
-const { comparePolygons } = require('../../../test/helpers/index')
-
-test('poly3: fromPoints() should return a new poly3 with correct values', (t) => {
-  const exp1 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
-  const obs1 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
-  t.true(comparePolygons(obs1, exp1))
-
-  const exp2 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 0]] }
-  const obs2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]]) // opposite orientation
-  t.true(comparePolygons(obs2, exp2))
-})

package/src/geometries/poly3/fromPointsAndPlane.d.ts

@@ -1,7 +0,0 @@
-import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
-import Plane from '../../maths/plane/type'
-
-export default fromPointsAndPlane
-
-declare function fromPointsAndPlane(vertices: Array<Vec3>, plane: Plane): Poly3

package/src/geometries/poly3/toPoints.d.ts

@@ -1,6 +0,0 @@
-import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
-
-export default toPoints
-
-declare function toPoints(polygon: Poly3): Array<Vec3>

package/src/geometries/poly3/toPoints.js

@@ -1,10 +0,0 @@
-/**
- * Return the given polygon as a list of points.
- * NOTE: The returned array should not be modified as the points are shared with the geometry.
- * @param {poly3} polygon - the polygon
- * @return {Array} list of points (3D)
- * @alias module:modeling/geometries/poly3.toPoints
- */
-const toPoints = (polygon) => polygon.vertices
-
-module.exports = toPoints