@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/text/vectorText.test.js

@@ -0,0 +1,267 @@
+import test from 'ava'
+
+import { vectorText } from './index.js'
+
+test('vectorText (empty string)', (t) => {
+  const obs = vectorText({}, '')
+  t.is(obs.length, 0)
+})
+
+test('vectorText (text)', (t) => {
+  const obs = vectorText({}, 'O I') // one char with one closed path, one char with one open path
+  t.is(obs.length, 1)
+
+  const vtext = obs[0]
+  t.is(vtext.width, 46)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 2)
+
+  // 'O'
+  let vchar = vtext.chars[0]
+  t.is(vchar.width, 22)
+  t.is(vchar.height, 14)
+  t.is(vchar.paths.length, 1)
+  t.is(vchar.paths[0].isClosed, true)
+  t.is(vchar.paths[0].points.length, 20)
+
+  t.deepEqual(vchar.paths[0].points[0], [9, 21])
+
+  // 'I'
+  vchar = vtext.chars[1]
+  t.is(vchar.width, 8)
+  t.is(vchar.height, 14)
+  t.is(vchar.paths.length, 1)
+  t.is(vchar.paths[0].isClosed, false)
+
+  // NOTE: ' ' in text is not in list of vchars, but produces an xOffset
+  t.deepEqual(vchar.paths[0].points[0], [26 + 16, 21])
+})
+
+test('vectorText (multi-line-text)', (t) => {
+  // NOTE: control line spacing to verify '\n' characters are working
+  const obs = vectorText({ lineSpacing: 1 }, '\nROCKS!\n\nOpen\nJSCAD\nROCKS!\n')
+  // only those lines with characters will be returned
+  t.is(obs.length, 4)
+
+  // ROCKS!
+  let vtext = obs[0]
+  t.is(vtext.width, 115)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 6)
+
+  let vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [4, 7])
+
+  // Open
+  vtext = obs[1]
+  t.is(vtext.width, 78)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 4)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [9, -21])
+
+  // JSCAD
+  vtext = obs[2]
+  t.is(vtext.width, 96)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 5)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [12, -35])
+
+  // ROCKS!
+  vtext = obs[3]
+  t.is(vtext.width, 115)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 6)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [4, -49])
+})
+
+test('vectorText ({ yOffset }, text)', (t) => {
+  const expectedTransform = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs = vectorText({ yOffset: 20 }, 'y')
+  t.is(obs.length, 1)
+
+  const vtext = obs[0]
+  t.is(vtext.width, 16)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 1)
+
+  // 'y'
+  const vchar = vtext.chars[0]
+  t.is(vchar.width, 16)
+  t.is(vchar.height, 14)
+  t.is(vchar.paths.length, 2)
+  t.is(vchar.paths[0].points.length, 2)
+  t.is(vchar.paths[1].points.length, 6)
+
+  t.deepEqual(vchar.paths[0].points[0], [2, 34]) // Y = 14 + 20 = 34
+  t.deepEqual(vchar.paths[0].transforms, expectedTransform)
+})
+
+test('vectorText ({ xOffset }, text)', (t) => {
+  const expectedTransform = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs = vectorText({ xOffset: 20 }, 'y')
+  t.is(obs.length, 1)
+
+  const vtext = obs[0]
+  t.is(vtext.width, 16)
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 1)
+
+  // 'y'
+  const vchar = vtext.chars[0]
+  t.is(vchar.width, 16)
+  t.is(vchar.height, 14)
+  t.is(vchar.paths.length, 2)
+  t.is(vchar.paths[0].points.length, 2)
+  t.is(vchar.paths[1].points.length, 6)
+
+  t.deepEqual(vchar.paths[0].points[0], [22, 14]) // X = 2 + 20 = 22
+  t.deepEqual(vchar.paths[0].transforms, expectedTransform)
+})
+
+test('vectorText ({ letterSpacing }, text)', (t) => {
+  const obs = vectorText({ letterSpacing: 0.5 }, 'JSCAD')
+  t.is(obs.length, 1)
+
+  const vtext = obs[0]
+  t.is(vtext.height, 14)
+  t.is(vtext.chars.length, 5)
+
+  // 'J'
+  let vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [12, 21])
+
+  // 'S'
+  vchar = vtext.chars[1]
+  t.deepEqual(vchar.paths[0].points[0], [40, 18]) // X = 33 + (1 * 14 * 0.5)
+
+  // 'C'
+  vchar = vtext.chars[2]
+  t.deepEqual(vchar.paths[0].points[0], [68, 16]) // X = 54 + (2 * 14 * 0.5)
+
+  // 'A'
+  vchar = vtext.chars[3]
+  t.deepEqual(vchar.paths[0].points[0], [87, 21]) // X = 66 + (3 * 14 * 0.5)
+
+  // 'D'
+  vchar = vtext.chars[4]
+  t.deepEqual(vchar.paths[0].points[0], [107, 21]) // X = 79 + (4 * 14 * 0.5)
+})
+
+test('vectorText ({ align: center }, text)', (t) => {
+  const expectedTransformA = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    18.5, 0, 0, 1
+  ]
+  const expectedTransformAB = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    9, 0, 0, 1
+  ]
+  const expectedTransformABC = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs = vectorText({ align: 'center' }, 'a\nab\nabc')
+  t.is(obs.length, 3)
+
+  // 'a'
+  let vtext = obs[0]
+  t.is(vtext.chars.length, 1)
+
+  let vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [15, 14])
+  t.deepEqual(vchar.paths[0].transforms, expectedTransformA)
+
+  // 'a b'
+  vtext = obs[1]
+  t.is(vtext.chars.length, 2)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [15, -16])
+  t.deepEqual(vchar.paths[0].transforms, expectedTransformAB)
+
+  // 'a b c'
+  vtext = obs[2]
+  t.is(vtext.chars.length, 3)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [15, -46])
+  t.deepEqual(vchar.paths[0].transforms, expectedTransformABC)
+})
+
+test('vectorText ({ align: right }, text)', (t) => {
+  const expectedTransformA = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    37, 0, 0, 1
+  ]
+  const expectedTransformAB = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    18, 0, 0, 1
+  ]
+  const expectedTransformABC = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs = vectorText({ align: 'right' }, 'a\nab\nabc')
+  t.is(obs.length, 3)
+
+  // 'a'
+  let vtext = obs[0]
+  t.is(vtext.chars.length, 1)
+
+  let vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [15, 14])
+  t.deepEqual(vchar.paths[0].transforms, expectedTransformA)
+
+  // 'a b'
+  vtext = obs[1]
+  t.is(vtext.chars.length, 2)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [15, -16])
+  t.deepEqual(vchar.paths[0].transforms, expectedTransformAB)
+
+  // 'a b c'
+  vtext = obs[2]
+  t.is(vtext.chars.length, 3)
+
+  vchar = vtext.chars[0]
+  t.deepEqual(vchar.paths[0].points[0], [15, -46])
+  t.deepEqual(vchar.paths[0].transforms, expectedTransformABC)
+})
+
+test('vectorText required options', (t) => {
+  t.throws(() => vectorText(), { message: 'text must be a string' })
+  t.throws(() => vectorText({}), { message: 'text must be a string' })
+})

package/src/utils/areAllShapesTheSameType.d.ts

@@ -1,5 +1,3 @@
-import { Geometry } from '../geometries/types'
+import type { Geometry } from '../geometries/types.d.ts'
 
-export default areAllShapesTheSameType
-
-declare function areAllShapesTheSameType(shapes: Array<Geometry>): boolean
+export function areAllShapesTheSameType(shapes: Array<Geometry>): boolean

package/src/utils/areAllShapesTheSameType.js

@@ -1,14 +1,14 @@
 // list of supported geometries
-const geom2 = require('../geometries/geom2')
-const geom3 = require('../geometries/geom3')
-const path2 = require('../geometries/path2')
+import * as geom2 from '../geometries/geom2/index.js'
+import * as geom3 from '../geometries/geom3/index.js'
+import * as path2 from '../geometries/path2/index.js'
 
 /**
  * @param {Array} shapes - list of shapes to compare
  * @returns {Boolean} true if the given shapes are of the same type
  * @alias module:modeling/utils.areAllShapesTheSameType
  */
-const areAllShapesTheSameType = (shapes) => {
+export const areAllShapesTheSameType = (shapes) => {
   let previousType
   for (const shape of shapes) {
     let currentType = 0
@@ -21,5 +21,3 @@ const areAllShapesTheSameType = (shapes) => {
   }
   return true
 }
-
-module.exports = areAllShapesTheSameType

package/src/utils/areAllShapesTheSameType.test.js

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { cube, square } = require('../primitives')
+import { cube, square } from '../primitives/index.js'
 
-const { areAllShapesTheSameType } = require('./index')
+import { areAllShapesTheSameType } from './areAllShapesTheSameType.js'
 
 test('utils: areAllShapesTheSameType() should return correct values', (t) => {
   const geometry2 = square()

package/src/utils/coalesce.d.ts

@@ -0,0 +1,3 @@
+import type { RecursiveArray } from './recursiveArray.d.ts'
+
+export function coalesce<T>(arr: RecursiveArray<T>): Array<T>

package/src/utils/coalesce.js

@@ -0,0 +1,20 @@
+/**
+ * Flattens and filters out nullish values from the given list of arguments.
+ * The arguments can be composed of multiple depths of objects and arrays.
+ * The output is a single flat array with no missing values.
+ * @param {Array} arr - list of arguments
+ * @returns {Array} a flat list of arguments
+ * @alias module:modeling/utils.coalesce
+ */
+export const coalesce = (arr) => flattenHelper(arr, [])
+
+// Helper to recursively append to a given list.
+// This is MUCH faster than other flatten methods.
+const flattenHelper = (arr, out) => {
+  if (Array.isArray(arr)) {
+    arr.forEach((child) => flattenHelper(child, out))
+  } else if (arr != null && arr !== undefined) {
+    out.push(arr)
+  }
+  return out
+}

package/src/utils/degToRad.d.ts

@@ -1,3 +1 @@
-export default degToRad
-
-declare function degToRad(degrees: number): number
+export function degToRad(degrees: number): number

package/src/utils/degToRad.js

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

package/src/utils/degToRad.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 { degToRad } = require('./index')
+import { degToRad } from './index.js'
 
 test('utils: degToRad() should return correct values', (t) => {
   const obs1 = degToRad(0)

package/src/utils/flatten.d.ts

@@ -1,5 +1,3 @@
-import RecursiveArray from './recursiveArray'
+import type { RecursiveArray } from './recursiveArray.d.ts'
 
-export default flatten
-
-declare function flatten<T>(arr: RecursiveArray<T>): Array<T>
+export function flatten<T>(arr: RecursiveArray<T>): Array<T>

package/src/utils/flatten.js

@@ -5,6 +5,4 @@
  * @returns {Array} a flat list of arguments
  * @alias module:modeling/utils.flatten
  */
-const flatten = (arr) => arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
-
-module.exports = flatten
+export const flatten = (arr) => arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])

package/src/utils/fnNumberSort.d.ts

@@ -1,3 +1 @@
-export default fnNumberSort
-
-declare function fnNumberSort(a: number, b: number): number
+export function fnNumberSort(a: number, b: number): number

package/src/utils/fnNumberSort.js

@@ -1,6 +1,4 @@
 /**
  * @alias module:modeling/utils.fnNumberSort
  */
-const fnNumberSort = (a, b) => a - b
-
-module.exports = fnNumberSort
+export const fnNumberSort = (a, b) => a - b

package/src/utils/index.d.ts

@@ -1,9 +1,4 @@
-export { default as areAllShapesTheSameType } from './areAllShapesTheSameType'
-export { default as degToRad } from './degToRad'
-export { default as flatten } from './flatten'
-export { default as fnNumberSort } from './fnNumberSort'
-export { default as insertSorted } from './insertSorted'
-export { default as radiusToSegments } from './radiusToSegments'
-export { default as radToDeg } from './radToDeg'
-
-export as namespace utils
+export { degToRad } from './degToRad.js'
+export { flatten } from './flatten.js'
+export { radiusToSegments } from './radiusToSegments.js'
+export { radToDeg } from './radToDeg.js'

package/src/utils/index.js

@@ -2,14 +2,9 @@
  * Utility functions of various sorts, including conversions from different angular measures.
  * @module modeling/utils
  * @example
- * const { areAllShapesTheSameType, degToRad, radiusToSegments, radToDeg } = require('@jscad/modeling').utils
+ * import { degToRad, flatten, radiusToSegments, radToDeg } from '@jscad/modeling'
  */
-module.exports = {
-  areAllShapesTheSameType: require('./areAllShapesTheSameType'),
-  degToRad: require('./degToRad'),
-  flatten: require('./flatten'),
-  fnNumberSort: require('./fnNumberSort'),
-  insertSorted: require('./insertSorted'),
-  radiusToSegments: require('./radiusToSegments'),
-  radToDeg: require('./radToDeg')
-}
+export { degToRad } from './degToRad.js'
+export { flatten } from './flatten.js'
+export { radiusToSegments } from './radiusToSegments.js'
+export { radToDeg } from './radToDeg.js'

package/src/utils/insertSorted.d.ts

@@ -1,3 +1 @@
-export default insertSorted
-
-declare function insertSorted<T>(array: Array<T>, element: T, comparefunc: (a: T, b: T) => number): void
+export function insertSorted<T>(array: Array<T>, element: T, compareFunc: (a: T, b: T) => number): void

package/src/utils/insertSorted.js

@@ -2,20 +2,18 @@
  * Insert the given element into the given array using the compareFunction.
  * @alias module:modeling/utils.insertSorted
  */
-const insertSorted = (array, element, comparefunc) => {
-  let leftbound = 0
-  let rightbound = array.length
-  while (rightbound > leftbound) {
-    const testindex = Math.floor((leftbound + rightbound) / 2)
-    const testelement = array[testindex]
-    const compareresult = comparefunc(element, testelement)
-    if (compareresult > 0) { // element > testelement
-      leftbound = testindex + 1
+export const insertSorted = (array, element, compareFunc) => {
+  let leftBound = 0
+  let rightBound = array.length
+  while (rightBound > leftBound) {
+    const testIndex = Math.floor((leftBound + rightBound) / 2)
+    const testElement = array[testIndex]
+    const compareResult = compareFunc(element, testElement)
+    if (compareResult > 0) { // element > testElement
+      leftBound = testIndex + 1
     } else {
-      rightbound = testindex
+      rightBound = testIndex
     }
   }
-  array.splice(leftbound, 0, element)
+  array.splice(leftBound, 0, element)
 }
-
-module.exports = insertSorted

package/src/utils/padArrayToLength.d.ts

@@ -1,3 +1 @@
-export default padArrayToLength
-
-declare function padArrayToLength<T = number>(anArray: Array<T>, padding: T, targetLength: number): Array<T>
+export function padArrayToLength<T = number>(anArray: Array<T>, padding: T, targetLength: number): Array<T>

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>> {}