@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { distance, fromValues } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('vec2: distance() should return correct values', (t) => {
+  const vec0 = fromValues(0, 0)
+  const vec1 = fromValues(0, 0)
+  const distance1 = distance(vec0, vec1)
+  nearlyEqual(t, distance1, 0.0, EPS)
+
+  const vec2 = fromValues(1, 2)
+  const distance2 = distance(vec0, vec2)
+  nearlyEqual(t, distance2, 2.23606, EPS)
+
+  const vec3 = fromValues(1, -2)
+  const distance3 = distance(vec0, vec3)
+  nearlyEqual(t, distance3, 2.23606, EPS)
+
+  const vec4 = fromValues(-1, -2)
+  const distance4 = distance(vec0, vec4)
+  nearlyEqual(t, distance4, 2.23606, EPS)
+
+  const vec5 = fromValues(-1, 2)
+  const distance5 = distance(vec0, vec5)
+  nearlyEqual(t, distance5, 2.23606, EPS)
+
+  t.true(true)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default divide
+
+declare function divide(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/divide.js

@@ -0,0 +1,16 @@
+/**
+ * Divides 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
+ * @alias module:modeling/maths/vec2.divide
+ */
+const divide = (out, a, b) => {
+  out[0] = a[0] / b[0]
+  out[1] = a[1] / b[1]
+  return out
+}
+
+module.exports = divide

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

@@ -0,0 +1,36 @@
+const test = require('ava')
+const { divide, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: divide() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = divide(obs1, [0, 0], [0, 0])
+  t.true(compareVectors(obs1, [0 / 0, 0 / 0]))
+  t.true(compareVectors(ret1, [0 / 0, 0 / 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = divide(obs2, [0, 0], [1, 2])
+  t.true(compareVectors(obs2, [0, 0]))
+  t.true(compareVectors(ret2, [0, 0]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = divide(obs3, [6, 6], [1, 2])
+  t.true(compareVectors(obs3, [6, 3]))
+  t.true(compareVectors(ret3, [6, 3]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = divide(obs4, [-6, -6], [1, 2])
+  t.true(compareVectors(obs4, [-6, -3]))
+  t.true(compareVectors(ret4, [-6, -3]))
+
+  const obs5 = fromValues(0, 0)
+  const ret5 = divide(obs5, [6, 6], [-1, -2])
+  t.true(compareVectors(obs5, [-6, -3]))
+  t.true(compareVectors(ret5, [-6, -3]))
+
+  const obs6 = fromValues(0, 0)
+  const ret6 = divide(obs6, [-6, -6], [-1, -2])
+  t.true(compareVectors(obs6, [6, 3]))
+  t.true(compareVectors(ret6, [6, 3]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default dot
+
+declare function dot(a: Vec2, b: Vec2): number

package/src/maths/vec2/dot.js

@@ -0,0 +1,11 @@
+/**
+ * Calculates the dot product of two vectors.
+ *
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {Number} dot product
+ * @alias module:modeling/maths/vec2.dot
+ */
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1]
+
+module.exports = dot

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

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { dot, fromValues } = require('./index')
+
+test('vec2: dot() should return correct values', (t) => {
+  const veca1 = fromValues(0, 0)
+  const vecb1 = fromValues(0, 0)
+  const dot1 = dot(veca1, vecb1)
+  t.true(dot1 === 0.0)
+
+  const veca2 = fromValues(1, 1)
+  const vecb2 = fromValues(-1, -1)
+  const dot2 = dot(veca2, vecb2)
+  t.true(dot2 === -2.0)
+
+  const veca3 = fromValues(5, 5)
+  const vecb3 = fromValues(5, 5)
+  const dot3 = dot(veca3, vecb3)
+  t.true(dot3 === 50.0)
+
+  const veca4 = fromValues(5, 5)
+  const vecb4 = fromValues(-2, 3)
+  const dot4 = dot(veca4, vecb4)
+  t.true(dot4 === 5.0)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default equals
+
+declare function equals(a: Vec2, b: Vec2): boolean

package/src/maths/vec2/equals.js

@@ -0,0 +1,11 @@
+/**
+ * Compare the given vectors for equality.
+ *
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {Boolean} true if a and b are equal
+ * @alias module:modeling/maths/vec2.equals
+ */
+const equals = (a, b) => (a[0] === b[0]) && (a[1] === b[1])
+
+module.exports = equals

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

@@ -0,0 +1,17 @@
+const test = require('ava')
+const { equals, fromValues } = require('./index')
+
+test('vec2: equals() should return correct booleans', (t) => {
+  const vec0 = fromValues(0, 0)
+  const vec1 = fromValues(0, 0)
+  t.true(equals(vec0, vec1))
+
+  const vec2 = fromValues(1, 1)
+  t.false(equals(vec0, vec2))
+
+  const vec3 = fromValues(1, 0)
+  t.false(equals(vec0, vec3))
+
+  const vec4 = fromValues(0, 1)
+  t.false(equals(vec0, vec4))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default fromAngleDegrees
+
+declare function fromAngleDegrees(out: Vec2, degrees: number): Vec2

package/src/maths/vec2/fromAngleDegrees.js

@@ -0,0 +1,13 @@
+const fromAngleRadians = require('./fromAngleRadians')
+
+/**
+ * Create a new vector in the direction of the given angle.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {Number} degrees - angle in degrees
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.fromAngleDegrees
+ */
+const fromAngleDegrees = (out, degrees) => fromAngleRadians(out, degrees * 0.017453292519943295)
+
+module.exports = fromAngleDegrees

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

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromAngleDegrees, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: fromAngleDegrees() should return a new vec2 with correct values', (t) => {
+  const obs1 = fromAngleDegrees(create(), 0)
+  t.true(compareVectors(obs1, [1.0, 0.0]))
+
+  const obs2 = fromAngleDegrees(obs1, 180)
+  t.true(compareVectors(obs2, [-1, 1.2246468525851679e-16]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default fromAngleRadians
+
+declare function fromAngleRadians(out: Vec2, radians: number): Vec2

package/src/maths/vec2/fromAngleRadians.js

@@ -0,0 +1,17 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Create a new vector in the direction of the given angle.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {Number} radians - angle in radians
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.fromAngleRadians
+ */
+const fromAngleRadians = (out, radians) => {
+  out[0] = cos(radians)
+  out[1] = sin(radians)
+  return out
+}
+
+module.exports = fromAngleRadians

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

@@ -0,0 +1,15 @@
+const test = require('ava')
+
+const { TAU } = require('../constants')
+
+const { fromAngleRadians, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: fromAngleRadians() should return a new vec2 with correct values', (t) => {
+  const obs1 = fromAngleRadians(create(), 0)
+  t.true(compareVectors(obs1, [1.0, 0.0]))
+
+  const obs2 = fromAngleRadians(obs1, TAU / 2)
+  t.true(compareVectors(obs2, [-1, 1.2246468525851679e-16]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default fromScalar
+
+declare function fromScalar(out: Vec2, scalar: number): Vec2

package/src/maths/vec2/fromScalar.js

@@ -0,0 +1,15 @@
+/**
+ * Create a vector from a single scalar value.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {Number} scalar - the scalar value
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.fromScalar
+ */
+const fromScalar = (out, scalar) => {
+  out[0] = scalar
+  out[1] = scalar
+  return out
+}
+
+module.exports = fromScalar

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

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromScalar, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: fromScalar() should return a new vec2 with correct values', (t) => {
+  const obs1 = fromScalar(create(), 0)
+  t.true(compareVectors(obs1, [0, 0]))
+
+  const obs2 = fromScalar(obs1, -5)
+  t.true(compareVectors(obs2, [-5, -5]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default fromValues
+
+declare function fromValues(x: number, y: number): Vec2

package/src/maths/vec2/fromValues.js

@@ -0,0 +1,18 @@
+const create = require('./create')
+
+/**
+ * Creates a new vector initialized with the given values.
+ *
+ * @param {Number} x - X coordinate
+ * @param {Number} y - Y coordinate
+ * @returns {vec2} a new vector
+ * @alias module:modeling/maths/vec2.fromValues
+ */
+const fromValues = (x, y) => {
+  const out = create()
+  out[0] = x
+  out[1] = y
+  return out
+}
+
+module.exports = fromValues

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

@@ -0,0 +1,36 @@
+export { default as abs } from './abs'
+export { default as add } from './add'
+export { default as angle } from './angle'
+export { default as angleDegrees } from './angleDegrees'
+export { default as angleRadians } from './angleRadians'
+export { default as clone } from './clone'
+export { default as copy } from './copy'
+export { default as create } from './create'
+export { default as cross } from './cross'
+export { default as distance } from './distance'
+export { default as divide } from './divide'
+export { default as dot } from './dot'
+export { default as equals } from './equals'
+export { default as fromAngleDegrees } from './fromAngleDegrees'
+export { default as fromAngleRadians } from './fromAngleRadians'
+export { default as fromScalar } from './fromScalar'
+export { default as fromValues } from './fromValues'
+export { default as length } from './length'
+export { default as lerp } from './lerp'
+export { default as max } from './max'
+export { default as min } from './min'
+export { default as multiply } from './multiply'
+export { default as negate } from './negate'
+export { default as normal } from './normal'
+export { default as normalize } from './normalize'
+export { default as rotate } from './rotate'
+export { default as scale } from './scale'
+export { default as snap } from './snap'
+export { default as squaredDistance } from './squaredDistance'
+export { default as squaredLength } from './squaredLength'
+export { default as subtract } from './subtract'
+export { default as toString } from './toString'
+export { default as transform } from './transform'
+
+export { default as Vec2 } from './type'
+export as namespace vec2

package/src/maths/vec2/index.js

@@ -0,0 +1,39 @@
+/**
+ * Represents a two dimensional vector.
+ * @module modeling/maths/vec2
+ */
+module.exports = {
+  abs: require('./abs'),
+  add: require('./add'),
+  angle: require('./angle'),
+  angleDegrees: require('./angleDegrees'),
+  angleRadians: require('./angleRadians'),
+  clone: require('./clone'),
+  copy: require('./copy'),
+  create: require('./create'),
+  cross: require('./cross'),
+  distance: require('./distance'),
+  divide: require('./divide'),
+  dot: require('./dot'),
+  equals: require('./equals'),
+  fromAngleDegrees: require('./fromAngleDegrees'),
+  fromAngleRadians: require('./fromAngleRadians'),
+  fromScalar: require('./fromScalar'),
+  fromValues: require('./fromValues'),
+  length: require('./length'),
+  lerp: require('./lerp'),
+  max: require('./max'),
+  min: require('./min'),
+  multiply: require('./multiply'),
+  negate: require('./negate'),
+  normal: require('./normal'),
+  normalize: require('./normalize'),
+  rotate: require('./rotate'),
+  scale: require('./scale'),
+  snap: require('./snap'),
+  squaredDistance: require('./squaredDistance'),
+  squaredLength: require('./squaredLength'),
+  subtract: require('./subtract'),
+  toString: require('./toString'),
+  transform: require('./transform')
+}

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default length
+
+declare function length(vector: Vec2): number

package/src/maths/vec2/length.js

@@ -0,0 +1,10 @@
+/**
+ * Calculates the length of the given vector.
+ *
+ * @param {vec2} vector - vector of reference
+ * @returns {Number} length
+ * @alias module:modeling/maths/vec2.length
+ */
+const length = (vector) => Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1])
+
+module.exports = length

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

@@ -0,0 +1,29 @@
+const test = require('ava')
+const { length, fromValues } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('vec2: length() should return correct values', (t) => {
+  const vec1 = fromValues(0, 0)
+  const length1 = length(vec1)
+  nearlyEqual(t, length1, 0.0, EPS)
+
+  const vec2 = fromValues(1, 2)
+  const length2 = length(vec2)
+  nearlyEqual(t, length2, 2.23606, EPS)
+
+  const vec3 = fromValues(1, -2)
+  const length3 = length(vec3)
+  nearlyEqual(t, length3, 2.23606, EPS)
+
+  const vec4 = fromValues(-1, -2)
+  const length4 = length(vec4)
+  nearlyEqual(t, length4, 2.23606, EPS)
+
+  const vec5 = fromValues(-1, 2)
+  const length5 = length(vec5)
+  nearlyEqual(t, length5, 2.23606, EPS)
+
+  t.true(true)
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default lerp
+
+declare function lerp(out: Vec2, a: Vec2, b: Vec2, t: number): Vec2

package/src/maths/vec2/lerp.js

@@ -0,0 +1,19 @@
+/**
+ * Performs a linear interpolation between two vectors.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @param {Number} t - interpolation amount between the two vectors
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.lerp
+ */
+const lerp = (out, a, b, t) => {
+  const ax = a[0]
+  const ay = a[1]
+  out[0] = ax + t * (b[0] - ax)
+  out[1] = ay + t * (b[1] - ay)
+  return out
+}
+
+module.exports = lerp

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

@@ -0,0 +1,26 @@
+const test = require('ava')
+const { lerp, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: lerp() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = lerp(obs1, [0, 0], [0, 0], 0)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = lerp(obs2, [1, 2], [5, 6], 0.00)
+  t.true(compareVectors(obs2, [1, 2]))
+  t.true(compareVectors(ret2, [1, 2]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = lerp(obs3, [1, 2], [5, 6], 0.75)
+  t.true(compareVectors(obs3, [4, 5]))
+  t.true(compareVectors(ret3, [4, 5]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = lerp(obs4, [1, 2], [5, 6], 1.00)
+  t.true(compareVectors(obs4, [5, 6]))
+  t.true(compareVectors(ret4, [5, 6]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default max
+
+declare function max(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/max.js

@@ -0,0 +1,16 @@
+/**
+ * Returns the maximum coordinates of two vectors.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.max
+ */
+const max = (out, a, b) => {
+  out[0] = Math.max(a[0], b[0])
+  out[1] = Math.max(a[1], b[1])
+  return out
+}
+
+module.exports = max

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

@@ -0,0 +1,31 @@
+const test = require('ava')
+const { max, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: max() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const vec0 = fromValues(0, 0)
+  const vec1 = fromValues(0, 0)
+  const ret1 = max(obs1, vec0, vec1)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const vec2 = fromValues(1, 1)
+  const ret2 = max(obs2, vec0, vec2)
+  t.true(compareVectors(obs2, [1, 1]))
+  t.true(compareVectors(ret2, [1, 1]))
+
+  const obs3 = fromValues(0, 0)
+  const vec3 = fromValues(0, 1)
+  const ret3 = max(obs3, vec0, vec3)
+  t.true(compareVectors(obs3, [0, 1]))
+  t.true(compareVectors(ret3, [0, 1]))
+
+  const obs4 = fromValues(0, 0)
+  const vec4 = fromValues(0, 0)
+  const ret4 = max(obs4, vec0, vec4)
+  t.true(compareVectors(obs4, [0, 0]))
+  t.true(compareVectors(ret4, [0, 0]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default min
+
+declare function min(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/min.js

@@ -0,0 +1,16 @@
+/**
+ * Returns the minimum coordinates of two vectors.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.min
+ */
+const min = (out, a, b) => {
+  out[0] = Math.min(a[0], b[0])
+  out[1] = Math.min(a[1], b[1])
+  return out
+}
+
+module.exports = min

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

@@ -0,0 +1,31 @@
+const test = require('ava')
+const { min, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: min() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const vec0 = fromValues(0, 0)
+  const vec1 = fromValues(0, 0)
+  const ret1 = min(obs1, vec0, vec1)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const vec2 = fromValues(1, 1)
+  const ret2 = min(obs2, vec0, vec2)
+  t.true(compareVectors(obs2, [0, 0]))
+  t.true(compareVectors(ret2, [0, 0]))
+
+  const obs3 = fromValues(0, 0)
+  const vec3 = fromValues(0, 1)
+  const ret3 = min(obs3, vec0, vec3)
+  t.true(compareVectors(obs3, [0, 0]))
+  t.true(compareVectors(ret3, [0, 0]))
+
+  const obs4 = fromValues(0, 0)
+  const vec4 = fromValues(0, 0)
+  const ret4 = min(obs4, vec0, vec4)
+  t.true(compareVectors(obs4, [0, 0]))
+  t.true(compareVectors(ret4, [0, 0]))
+})

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

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default multiply
+
+declare function multiply(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/multiply.js

@@ -0,0 +1,16 @@
+/**
+ * Multiplies 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
+ * @alias module:modeling/maths/vec2.multiply
+ */
+const multiply = (out, a, b) => {
+  out[0] = a[0] * b[0]
+  out[1] = a[1] * b[1]
+  return out
+}
+
+module.exports = multiply