@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/maths/utils/area.js

@@ -1,10 +1,10 @@
 /**
  * Calculate the area under the given points.
  * @param {Array} points - list of 2D points
- * @return {Number} area under the given points
+ * @return {number} area under the given points
  * @alias module:modeling/maths/utils.area
  */
-const area = (points) => {
+export const area = (points) => {
   let area = 0
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length
@@ -13,5 +13,3 @@ const area = (points) => {
   }
   return (area / 2.0)
 }
-
-module.exports = area

package/src/maths/utils/interpolateBetween2DPointsForY.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default interpolateBetween2DPointsForY
-
-declare function interpolateBetween2DPointsForY(point1: Vec2, point2: Vec2, y: number): number
+export function interpolateBetween2DPointsForY(point1: Vec2, point2: Vec2, y: number): number

package/src/maths/utils/interpolateBetween2DPointsForY.js

@@ -1,13 +1,13 @@
 /**
  * Get the X coordinate of a point with a certain Y coordinate, interpolated between two points.
  * Interpolation is robust even if the points have the same Y coordinate
- * @param {vec2} point1
- * @param {vec2} point2
- * @param {Number} y
+ * @param {Vec2} point1
+ * @param {Vec2} point2
+ * @param {number} y
  * @return {Array} X and Y of interpolated point
  * @alias module:modeling/maths/utils.interpolateBetween2DPointsForY
  */
-const interpolateBetween2DPointsForY = (point1, point2, y) => {
+export const interpolateBetween2DPointsForY = (point1, point2, y) => {
   let f1 = y - point1[1]
   let f2 = point2[1] - point1[1]
   if (f2 < 0) {
@@ -27,5 +27,3 @@ const interpolateBetween2DPointsForY = (point1, point2, y) => {
   const result = point1[0] + t * (point2[0] - point1[0])
   return result
 }
-
-module.exports = interpolateBetween2DPointsForY

package/src/maths/utils/intersect.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default intersect
-
-declare function intersect(p1: Vec2, p2: Vec2, p3: Vec2, p4: Vec2): Vec2
+export function intersect(p1: Vec2, p2: Vec2, p3: Vec2, p4: Vec2, endpointTouch?: boolean): Vec2

package/src/maths/utils/intersect.js

@@ -1,15 +1,17 @@
 /**
- * Calculate the intersect point of the two line segments (p1-p2 and p3-p4), end points included.
+ * Calculate the intersect point of the two line segments (p1-p2 and p3-p4).
+ * If the endpointTouch parameter is false, intersections at segment end points are excluded.
  * Note: If the line segments do NOT intersect then undefined is returned.
  * @see http://paulbourke.net/geometry/pointlineplane/
- * @param {vec2} p1 - first point of first line segment
- * @param {vec2} p2 - second point of first line segment
- * @param {vec2} p3 - first point of second line segment
- * @param {vec2} p4 - second point of second line segment
- * @returns {vec2} intersection point of the two line segments, or undefined
+ * @param {Vec2} p1 - first point of first line segment
+ * @param {Vec2} p2 - second point of first line segment
+ * @param {Vec2} p3 - first point of second line segment
+ * @param {Vec2} p4 - second point of second line segment
+ * @param {boolean} endpointTouch - include intersections at segment endpoints
+ * @returns {Vec2} intersection point of the two line segments, or undefined
  * @alias module:modeling/maths/utils.intersect
  */
-const intersect = (p1, p2, p3, p4) => {
+export const intersect = (p1, p2, p3, p4, endpointTouch = true) => {
   // Check if none of the lines are of length 0
   if ((p1[0] === p2[0] && p1[1] === p2[1]) || (p3[0] === p4[0] && p3[1] === p4[1])) {
     return undefined
@@ -30,11 +32,14 @@ const intersect = (p1, p2, p3, p4) => {
     return undefined
   }
 
+  // is the intersection at the end of a segment
+  if (!endpointTouch && (ua === 0 || ua === 1 || ub === 0 || ub === 1)) {
+    return undefined
+  }
+
   // Return the x and y coordinates of the intersection
   const x = p1[0] + ua * (p2[0] - p1[0])
   const y = p1[1] + ua * (p2[1] - p1[1])
 
   return [x, y]
 }
-
-module.exports = intersect

package/src/maths/utils/intersect.test.js

@@ -0,0 +1,40 @@
+import test from 'ava'
+
+import * as vec2 from '../vec2/index.js'
+import { intersect } from './intersect.js'
+
+//   A     __F
+//  / \ __E
+// B   D   \
+//  \ /     \
+//   C       G
+
+const a = vec2.fromValues(0, 1)
+const b = vec2.fromValues(-1, 0)
+const c = vec2.fromValues(0, -1)
+const d = vec2.fromValues(1, 0)
+const e = vec2.fromValues(2, 0.5)
+const f = vec2.fromValues(3, 1)
+const g = vec2.fromValues(2, -1)
+
+test('utils: intersect() for intersecting lines', (t) => {
+  t.deepEqual(intersect(a, c, b, d), [0, 0])
+  t.deepEqual(intersect(a, b, b, c), b)
+  t.deepEqual(intersect(d, f, e, g), e)
+})
+
+test('utils: intersect() for non-intersecting lines', (t) => {
+  t.is(intersect(a, a, b, c), undefined)
+  t.is(intersect(a, d, b, c), undefined)
+  t.is(intersect(a, b, d, e), undefined)
+})
+
+test('utils: intersect() endpointTouch parameter', (t) => {
+  // endpoint touching
+  t.deepEqual(intersect(a, b, b, c), b)
+  t.deepEqual(intersect(a, b, b, c, true), b)
+  t.deepEqual(intersect(a, b, b, c, false), undefined)
+  t.deepEqual(intersect(d, f, e, g), e)
+  t.deepEqual(intersect(d, f, e, g, true), e)
+  t.deepEqual(intersect(d, f, e, g, false), undefined)
+})

package/src/maths/utils/solve2Linear.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../vec2/type'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default solve2Linear
-
-declare function solve2Linear(a: number, b: number, c: number, d: number, u: number, v: number): Vec2
+export function solve2Linear(a: number, b: number, c: number, d: number, u: number, v: number): Vec2

package/src/maths/utils/solve2Linear.js

@@ -1,4 +1,4 @@
-const solve2Linear = (a, b, c, d, u, v) => {
+export const solve2Linear = (a, b, c, d, u, v) => {
   const det = a * d - b * c
   const invdet = 1.0 / det
   let x = u * d - b * v
@@ -7,5 +7,3 @@ const solve2Linear = (a, b, c, d, u, v) => {
   y *= invdet
   return [x, y]
 }
-
-module.exports = solve2Linear

package/src/maths/utils/trigonometry.js

@@ -1,4 +1,4 @@
-const { NEPS } = require('../constants')
+import { NEPS } from '../constants.js'
 
 /*
  * Returns zero if n is within epsilon of zero, otherwise return n
@@ -9,26 +9,24 @@ const rezero = (n) => Math.abs(n) < NEPS ? 0 : n
  * Return Math.sin but accurate for TAU / 4 rotations.
  * Fixes rounding errors when sin should be 0.
  *
- * @param {Number} radians - angle in radians
- * @returns {Number} sine of the given angle
+ * @param {number} radians - angle in radians
+ * @returns {number} sine of the given angle
  * @alias module:modeling/utils.sin
  * @example
  * sin(TAU / 2) == 0
  * sin(TAU) == 0
  */
-const sin = (radians) => rezero(Math.sin(radians))
+export const sin = (radians) => rezero(Math.sin(radians))
 
 /**
  * Return Math.cos but accurate for TAU / 4 rotations.
  * Fixes rounding errors when cos should be 0.
  *
- * @param {Number} radians - angle in radians
- * @returns {Number} cosine of the given angle
+ * @param {number} radians - angle in radians
+ * @returns {number} cosine of the given angle
  * @alias module:modeling/utils.cos
  * @example
  * cos(TAU * 0.25) == 0
  * cos(TAU * 0.75) == 0
  */
-const cos = (radians) => rezero(Math.cos(radians))
-
-module.exports = { sin, cos }
+export const cos = (radians) => rezero(Math.cos(radians))

package/src/maths/utils/trigonometry.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../constants')
+import { TAU } from '../constants.js'
 
-const { cos, sin } = require('./trigonometry')
+import { cos, sin } from './trigonometry.js'
 
 test('utils: sin() should return rounded values', (t) => {
   t.is(sin(0), 0)

package/src/maths/vec1/type.d.ts

@@ -1,3 +1 @@
-export default Vec1
-
-declare type Vec1 = [number]
+export type Vec1 = [number]

package/src/maths/vec2/abs.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default abs
-
-declare function abs(out: Vec2, vector: Vec2): Vec2
+export function abs(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/abs.js

@@ -1,15 +1,13 @@
 /**
  * Calculates the absolute coordinates of the given vector.
  *
- * @param {vec2} out - receiving vector
- * @param {vec2} vector - vector of reference
- * @returns {vec2} out
+ * @param {Vec2} out - receiving vector
+ * @param {Vec2} vector - vector of reference
+ * @returns {Vec2} out
  * @alias module:modeling/maths/vec2.abs
  */
-const abs = (out, vector) => {
+export const abs = (out, vector) => {
   out[0] = Math.abs(vector[0])
   out[1] = Math.abs(vector[1])
   return out
 }
-
-module.exports = abs

package/src/maths/vec2/abs.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { abs, create } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { abs, create } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: abs() with two params should update a vec2 with correct values', (t) => {
   const vec1 = create()

package/src/maths/vec2/add.d.ts

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

package/src/maths/vec2/add.js

@@ -1,16 +1,14 @@
 /**
  * Adds the coordinates of two vectors (A+B).
  *
- * @param {vec2} out - receiving vector
- * @param {vec2} a - first operand
- * @param {vec2} b - second operand
- * @returns {vec2} out
+ * @param {Vec2} out - receiving vector
+ * @param {Vec2} a - first operand
+ * @param {Vec2} b - second operand
+ * @returns {Vec2} out
  * @alias module:modeling/maths/vec2.add
  */
-const add = (out, a, b) => {
+export const add = (out, a, b) => {
   out[0] = a[0] + b[0]
   out[1] = a[1] + b[1]
   return out
 }
-
-module.exports = add

package/src/maths/vec2/add.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { add, fromValues } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { add, fromValues } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: add() called with three parameters should update a vec2 with correct values', (t) => {
   const obs1 = fromValues(0, 0)

package/src/maths/vec2/angle.d.ts

@@ -1,3 +1 @@
-import angleRadians from './angleRadians'
-
-export default angleRadians
+export { angleRadians as angle } from './angleRadians.js'

package/src/maths/vec2/angle.js

@@ -1 +1 @@
-module.exports = require('./angleRadians')
+export { angleRadians as angle } from './angleRadians.js'

package/src/maths/vec2/angleDegrees.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default angleDegrees
-
-declare function angleDegrees(vector: Vec2): number
+export function angleDegrees(vector: Vec2): number

package/src/maths/vec2/angleDegrees.js

@@ -1,12 +1,10 @@
-const angleRadians = require('./angleRadians')
+import { angleRadians } from './angleRadians.js'
 
 /**
  * Calculate the angle of the given vector.
  *
- * @param {vec2} vector - vector of reference
- * @returns {Number} angle in degrees
+ * @param {Vec2} vector - vector of reference
+ * @returns {number} angle in degrees
  * @alias module:modeling/maths/vec2.angleDegrees
  */
-const angleDegrees = (vector) => angleRadians(vector) * 57.29577951308232
-
-module.exports = angleDegrees
+export const angleDegrees = (vector) => angleRadians(vector) * 57.29577951308232

package/src/maths/vec2/angleDegrees.test.js

@@ -1,8 +1,10 @@
-const test = require('ava')
-const { angleDegrees } = require('./index')
+import test from 'ava'
 
-const { nearlyEqual } = require('../../../test/helpers/index')
-const { EPS } = require('../constants')
+import { EPS } from '../constants.js'
+
+import { angleDegrees } from './index.js'
+
+import { nearlyEqual } from '../../../test/helpers/index.js'
 
 test('vec2: angleDegrees() should return correct values', (t) => {
   const distance1 = angleDegrees([0, 0])

package/src/maths/vec2/angleRadians.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default angleRadians
-
-declare function angleRadians(vector: Vec2): number
+export function angleRadians(vector: Vec2): number

package/src/maths/vec2/angleRadians.js

@@ -1,10 +1,8 @@
 /**
  * Calculate the angle of the given vector.
  *
- * @param {vec2} vector - vector of reference
- * @returns {Number} angle in radians
+ * @param {Vec2} vector - vector of reference
+ * @returns {number} angle in radians
  * @alias module:modeling/maths/vec2.angleRadians
  */
-const angleRadians = (vector) => Math.atan2(vector[1], vector[0]) // y=sin, x=cos
-
-module.exports = angleRadians
+export const angleRadians = (vector) => Math.atan2(vector[1], vector[0]) // y=sin, x=cos

package/src/maths/vec2/angleRadians.test.js

@@ -1,8 +1,10 @@
-const test = require('ava')
-const { angleRadians } = require('./index')
+import test from 'ava'
 
-const { nearlyEqual } = require('../../../test/helpers/index')
-const { EPS } = require('../constants')
+import { EPS } from '../constants.js'
+
+import { angleRadians } from './index.js'
+
+import { nearlyEqual } from '../../../test/helpers/index.js'
 
 test('vec2: angleRadians() should return correct values', (t) => {
   const distance1 = angleRadians([0, 0])

package/src/maths/vec2/clone.d.ts

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

package/src/maths/vec2/clone.js

@@ -1,17 +1,15 @@
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Create a clone of the given vector.
  *
- * @param {vec2} vector - vector to clone
- * @returns {vec2} a new vector
+ * @param {Vec2} vector - vector to clone
+ * @returns {Vec2} a new vector
  * @alias module:modeling/maths/vec2.clone
  */
-const clone = (vector) => {
+export const clone = (vector) => {
   const out = create()
   out[0] = vector[0]
   out[1] = vector[1]
   return out
 }
-
-module.exports = clone

package/src/maths/vec2/clone.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { clone, fromValues } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { clone, fromValues } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: clone() should return a new vec2 with same values', (t) => {
   const org1 = fromValues(0, 0)

package/src/maths/vec2/copy.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from './type'
+import type { Vec2 } from './type.d.ts'
 
-export default copy
-
-declare function copy(out: Vec2, vector: Vec2): Vec2
+export function copy(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/copy.js

@@ -1,15 +1,13 @@
 /**
  * Create a copy of the given vector.
  *
- * @param {vec2} out - receiving vector
- * @param {vec2} vector - source vector
- * @returns {vec2} out
+ * @param {Vec2} out - receiving vector
+ * @param {Vec2} vector - source vector
+ * @returns {Vec2} out
  * @alias module:modeling/maths/vec2.copy
  */
-const copy = (out, vector) => {
+export const copy = (out, vector) => {
   out[0] = vector[0]
   out[1] = vector[1]
   return out
 }
-
-module.exports = copy

package/src/maths/vec2/copy.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { copy, create, fromValues } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { copy, create, fromValues } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: copy() with two params should update a vec2 with same values', (t) => {
   const out1 = create()

package/src/maths/vec2/create.d.ts

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

package/src/maths/vec2/create.js

@@ -1,15 +1,12 @@
 /**
  * Represents a two dimensional vector.
  * See fromValues().
- * @typedef {Array} vec2
  */
 
 /**
  * Creates a new vector, initialized to [0,0].
  *
- * @returns {vec2} a new vector
+ * @returns {Vec2} a new vector
  * @alias module:modeling/maths/vec2.create
  */
-const create = () => [0, 0]
-
-module.exports = create
+export const create = () => [0, 0]

package/src/maths/vec2/create.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { create } = require('./index')
+import { create } from './index.js'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: create() should return a vec2 with initial values', (t) => {
   const obs = create()

package/src/maths/vec2/cross.d.ts

@@ -1,6 +1,4 @@
-import Vec2 from './type'
-import Vec3 from '../vec3/type'
+import type { Vec2 } from './type.d.ts'
+import type { Vec3 } from '../vec3/type.d.ts'
 
-export default cross
-
-declare function cross(out: Vec3, a: Vec2, b: Vec2): Vec3
+export function cross(out: Vec3, a: Vec2, b: Vec2): Vec3

package/src/maths/vec2/cross.js

@@ -1,17 +1,15 @@
 /**
  * Computes the cross product (3D) of two vectors.
  *
- * @param {vec3} out - receiving vector (3D)
- * @param {vec2} a - first operand
- * @param {vec2} b - second operand
- * @returns {vec3} out
+ * @param {Vec3} out - receiving vector (3D)
+ * @param {Vec2} a - first operand
+ * @param {Vec2} b - second operand
+ * @returns {Vec3} out
  * @alias module:modeling/maths/vec2.cross
  */
-const cross = (out, a, b) => {
+export const cross = (out, a, b) => {
   out[0] = 0
   out[1] = 0
   out[2] = a[0] * b[1] - a[1] * b[0]
   return out
 }
-
-module.exports = cross

package/src/maths/vec2/cross.test.js

@@ -1,50 +1,52 @@
-const test = require('ava')
-const { cross } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import * as vec3 from '../vec3/index.js'
+import { cross } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('vec2: cross() called with three parameters should update a vec2 with correct values', (t) => {
-  const obs1 = [0, 0, 0]
+  const obs1 = vec3.create()
   const ret1 = cross(obs1, [0, 0], [0, 0])
   t.true(compareVectors(obs1, [0, 0, 0]))
   t.true(compareVectors(ret1, [0, 0, 0]))
 
-  const obs2 = [0, 0, 0]
+  const obs2 = vec3.create()
   const ret2 = cross(obs2, [5, 5], [10, 20])
   t.true(compareVectors(obs2, [0, 0, 50]))
   t.true(compareVectors(ret2, [0, 0, 50]))
 
-  const obs3 = [0, 0, 0]
+  const obs3 = vec3.create()
   const ret3 = cross(obs3, [5, 5], [10, -20])
   t.true(compareVectors(obs3, [0, 0, -150]))
   t.true(compareVectors(ret3, [0, 0, -150]))
 
-  const obs4 = [0, 0, 0]
+  const obs4 = vec3.create()
   const ret4 = cross(obs4, [5, 5], [-10, -20])
   t.true(compareVectors(obs4, [0, 0, -50]))
   t.true(compareVectors(ret4, [0, 0, -50]))
 
-  const obs5 = [0, 0, 0]
+  const obs5 = vec3.create()
   const ret5 = cross(obs5, [5, 5], [-10, 20])
   t.true(compareVectors(obs5, [0, 0, 150]))
   t.true(compareVectors(ret5, [0, 0, 150]))
 
-  const obs6 = [0, 0, 0]
+  const obs6 = vec3.create()
   const ret6 = cross(obs6, [5, 5], [10, 20])
   t.true(compareVectors(obs6, [0, 0, 50]))
   t.true(compareVectors(ret6, [0, 0, 50]))
 
-  const obs7 = [0, 0, 0]
+  const obs7 = vec3.create()
   const ret7 = cross(obs7, [5, 5], [10, -20])
   t.true(compareVectors(obs7, [0, 0, -150]))
   t.true(compareVectors(ret7, [0, 0, -150]))
 
-  const obs8 = [0, 0, 0]
+  const obs8 = vec3.create()
   const ret8 = cross(obs8, [5, 5], [-10, -20])
   t.true(compareVectors(obs8, [0, 0, -50]))
   t.true(compareVectors(ret8, [0, 0, -50]))
 
-  const obs9 = [0, 0, 0]
+  const obs9 = vec3.create()
   const ret9 = cross(obs9, [5, 5], [-10, 20])
   t.true(compareVectors(obs9, [0, 0, 150]))
   t.true(compareVectors(ret9, [0, 0, 150]))

package/src/maths/vec2/distance.d.ts

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