@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/text/vectorText.js

@@ -1,95 +1,123 @@
-const vectorChar = require('./vectorChar')
-const vectorParams = require('./vectorParams')
+import * as mat4 from '../maths/mat4/index.js'
+import * as path2 from '../geometries/path2/index.js'
+
+import { simplex } from './fonts/single-line/hershey/simplex.js'
+import { vectorChar } from './vectorChar.js'
+
+const defaultsVectorParams = {
+  xOffset: 0,
+  yOffset: 0,
+  align: 'left',
+  font: simplex,
+  height: 14, // old vector_xxx simplex font height
+  lineSpacing: 30 / 14, // old vector_xxx ratio
+  letterSpacing: 0, // proportion of font size, i.e. CSS em
+  extrudeOffset: 0
+}
+
+/**
+ * Represents a line of characters as an anonymous object containing a list of VectorChar.
+ * @typedef {Object} VectorLine
+ * @property {number} width - sum of character width and letter spacing
+ * @property {number} height - maximum height of character heights
+ * @property {Array} characters - list of vector characters
+ */
+
+const matrix = mat4.create()
 
-// translate text line
 const translateLine = (options, line) => {
-  const { x, y } = Object.assign({ x: 0, y: 0 }, options || {})
-  const segments = line.segments
-  let segment = null
-  let point = null
-  for (let i = 0, il = segments.length; i < il; i++) {
-    segment = segments[i]
-    for (let j = 0, jl = segment.length; j < jl; j++) {
-      point = segment[j]
-      segment[j] = [point[0] + x, point[1] + y]
-    }
-  }
+  const { x, y } = Object.assign({ x: 0, y: 0 }, options)
+
+  mat4.identity(matrix)
+  mat4.translate(matrix, matrix, [x, y, 0])
+
+  line.chars = line.chars.map((vchar) => {
+    vchar.paths = vchar.paths.map((path) => path2.transform(matrix, path))
+    return vchar
+  })
   return line
 }
 
 /**
- * Construct an array of character segments from a ascii string whose characters code is between 31 and 127,
+ * Construct an array of character segments from an ascii string whose characters code is between 31 and 127,
  * if one character is not supported it is replaced by a question mark.
- * @param {Object|String} [options] - options for construction or ascii string
- * @param {Float} [options.xOffset=0] - x offset
- * @param {Float} [options.yOffset=0] - y offset
- * @param {Float} [options.height=21] - font size (uppercase height)
- * @param {Float} [options.lineSpacing=1.4] - line spacing expressed as a percentage of font size
- * @param {Float} [options.letterSpacing=1] - extra letter spacing expressed as a percentage of font size
- * @param {String} [options.align='left'] - multi-line text alignment: left, center, right
- * @param {Float} [options.extrudeOffset=0] - width of the extrusion that will be applied (manually) after the creation of the character
- * @param {String} [options.input='?'] - ascii string (ignored/overwrited if provided as seconds parameter)
- * @param {String} [text='?'] - ascii string
- * @returns {Array} characters segments [[[x, y], ...], ...]
+ * @param {object} options - options for text construction
+ * @param {number} [options.xOffset=0] - x offset
+ * @param {number} [options.yOffset=0] - y offset
+ * @param {number} [options.height=14] - height of requested characters (uppercase height), i.e. font height in points
+ * @param {number} [options.lineSpacing=30/14] - line spacing expressed as a percentage of height
+ * @param {number} [options.letterSpacing=0] - extra letter spacing, expressed as a proportion of height, i.e. like CSS em
+ * @param {string} [options.align='left'] - multi-line text alignment: left, center, right
+ * @param {number} [options.extrudeOffset=0] - width of the extrusion that will be applied (manually) after the creation of the character
+ * @param {string} text - ascii string
+ * @returns {Array} list of vector line objects, where each line contains a list of vector character objects
  * @alias module:modeling/text.vectorText
  *
  * @example
- * let textSegments = vectorText()
- * or
- * let textSegments = vectorText('OpenJSCAD')
- * or
- * let textSegments = vectorText({ yOffset: -50 }, 'OpenJSCAD')
- * or
- * let textSegments = vectorText({ yOffset: -80, input: 'OpenJSCAD' })
+ * let mylines = vectorText({ yOffset: -50 }, 'JSCAD')
  */
-const vectorText = (options, text) => {
+export const vectorText = (options, text) => {
   const {
-    xOffset, yOffset, input, font, height, align, extrudeOffset, lineSpacing, letterSpacing
-  } = vectorParams(options, text)
-  let [x, y] = [xOffset, yOffset]
-  let i, il, char, vect, width, diff
-  let line = { width: 0, segments: [] }
-  const lines = []
-  let output = []
-  let maxWidth = 0
-  const lineStart = x
+    xOffset, yOffset, font, height, align, extrudeOffset, lineSpacing, letterSpacing
+  } = Object.assign({}, defaultsVectorParams, options)
+
+  if (typeof text !== 'string') throw new Error('text must be a string')
+
+  // NOTE: Just like CSS letter-spacing, the spacing could be positive or negative
+  const extraLetterSpacing = (height * letterSpacing)
+
+  // manage the list of lines
+  let maxWidth = 0 // keep track of max width for final alignment
+  let line = { width: 0, height: 0, chars: [] }
+  let lines = []
+
   const pushLine = () => {
-    lines.push(line)
     maxWidth = Math.max(maxWidth, line.width)
-    line = { width: 0, segments: [] }
+
+    if (line.chars.length) lines.push(line)
+    line = { width: 0, height: 0, chars: [] }
   }
-  for (i = 0, il = input.length; i < il; i++) {
-    char = input[i]
-    vect = vectorChar({ xOffset: x, yOffset: y, font, height, extrudeOffset }, char)
-    if (char === '\n') {
-      x = lineStart
-      y -= vect.height * lineSpacing
+
+  // convert the text into a list of vector lines
+  let x = xOffset
+  let y = yOffset
+  let vchar
+  const il = text.length
+  for (let i = 0; i < il; i++) {
+    const character = text[i]
+    if (character === '\n') {
       pushLine()
+
+      // reset x and y for a new line
+      x = xOffset
+      y -= height * lineSpacing
       continue
     }
-    width = vect.width * letterSpacing
-    line.width += width
+    // convert the character
+    vchar = vectorChar({ xOffset: x, yOffset: y, font, height, extrudeOffset }, character)
+
+    const width = vchar.width + extraLetterSpacing
     x += width
-    if (char !== ' ') {
-      line.segments = line.segments.concat(vect.segments)
+
+    // update current line
+    line.width += width
+    line.height = Math.max(line.height, vchar.height)
+    if (character !== ' ') {
+      line.chars = line.chars.concat(vchar)
     }
   }
-  if (line.segments.length) {
-    pushLine()
-  }
-  for (i = 0, il = lines.length; i < il; i++) {
-    line = lines[i]
-    if (maxWidth > line.width) {
-      diff = maxWidth - line.width
-      if (align === 'right') {
-        line = translateLine({ x: diff }, line)
-      } else if (align === 'center') {
-        line = translateLine({ x: diff / 2 }, line)
-      }
+  if (line.chars.length) pushLine()
+
+  // align all lines as requested
+  lines = lines.map((line) => {
+    const diff = maxWidth - line.width
+    if (align === 'right') {
+      return translateLine({ x: diff }, line)
+    } else if (align === 'center') {
+      return translateLine({ x: diff / 2 }, line)
+    } else {
+      return line
     }
-    output = output.concat(line.segments)
-  }
-  return output
+  })
+  return lines
 }
-
-module.exports = vectorText

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/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.
  * @module modeling/utils
  * @example
- * const { flatten, insertSorted } = require('@jscad/modeling').utils
+ * import { degToRad } 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>