@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/primitives/triangle.d.ts

@@ -1,10 +1,8 @@
-import Geom2 from '../geometries/geom2/type'
-
-export default triangle
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface TriangleOptions {
   type?: 'AAA' | 'AAS' | 'ASA' | 'SAS' | 'SSA' | 'SSS'
   values?: [number, number, number]
 }
 
-declare function triangle(options?: TriangleOptions): Geom2
+export function triangle(options?: TriangleOptions): Geom2

package/src/primitives/triangle.js

@@ -1,9 +1,9 @@
-const { NEPS } = require('../maths/constants')
-const vec2 = require('../maths/vec2')
+import { NEPS } from '../maths/constants.js'
+import * as vec2 from '../maths/vec2/index.js'
 
-const geom2 = require('../geometries/geom2')
+import * as geom2 from '../geometries/geom2/index.js'
 
-const { isNumberArray } = require('./commonChecks')
+import { isNumberArray } from './commonChecks.js'
 
 // returns angle C
 const solveAngleFromSSS = (a, b, c) => Math.acos(((a * a) + (b * b) - (c * c)) / (2 * a * b))
@@ -110,23 +110,23 @@ const createTriangle = (A, B, C, a, b, c) => {
   const p1 = vec2.fromValues(c, 0)
   const p2 = vec2.fromValues(a, 0)
   vec2.add(p2, vec2.rotate(p2, p2, [0, 0], Math.PI - B), p1)
-  return geom2.fromPoints([p0, p1, p2])
+  return geom2.create([[p0, p1, p2]])
 }
 
 /**
  * Construct a triangle in two dimensional space from the given options.
  * The triangle is always constructed CCW from the origin, [0, 0, 0].
  * @see https://www.mathsisfun.com/algebra/trig-solving-triangles.html
- * @param {Object} [options] - options for construction
- * @param {String} [options.type='SSS'] - type of triangle to construct; A ~ angle, S ~ side
+ * @param {object} [options] - options for construction
+ * @param {string} [options.type='SSS'] - type of triangle to construct; A ~ angle, S ~ side
  * @param {Array} [options.values=[1,1,1]] - angle (radians) of corners or length of sides
- * @returns {geom2} new 2D geometry
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.triangle
  *
  * @example
  * let myshape = triangle({type: 'AAS', values: [degToRad(62), degToRad(35), 7]})
  */
-const triangle = (options) => {
+export const triangle = (options) => {
   const defaults = {
     type: 'SSS',
     values: [1, 1, 1]
@@ -159,5 +159,3 @@ const triangle = (options) => {
       throw new Error('invalid triangle type, try again')
   }
 }
-
-module.exports = triangle

package/src/primitives/triangle.test.js

@@ -1,12 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { triangle } = require('./index')
+import { degToRad } from '../utils/index.js'
 
-const degToRad = require('../utils/degToRad')
-const geom2 = require('../geometries/geom2')
-const { TAU } = require('../maths/constants')
+import { geom2 } from '../geometries/index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { TAU } from '../maths/constants.js'
+
+import { measureArea } from '../measurements/index.js'
+
+import { triangle } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('triangle (defaults)', (t) => {
   const geometry = triangle()
@@ -18,7 +22,8 @@ test('triangle (defaults)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 0.43301270189221935)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 })
 
@@ -33,7 +38,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 20.33316256758894)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test AAA
@@ -46,7 +52,7 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test AAS
@@ -59,7 +65,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 15.796947276180953)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test ASA
@@ -72,7 +79,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 23.384870895211314)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test SAS
@@ -85,7 +93,8 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 13.207417653898512)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 
   // test SSA
@@ -98,6 +107,7 @@ test('triangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(measureArea(geometry), 51.962298292283386)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 })

package/src/text/fonts/single-line/hershey/simplex.js

@@ -1,7 +1,7 @@
 // -- data source from from http://paulbourke.net/dataformats/hershey/
 // -- reduced to save some bytes...
 // { [ascii code]: [width, x, y, ...] } - undefined value as path separator
-module.exports = {
+export const simplex = {
   height: 14,
   32: [16],
   33: [10, 5, 21, 5, 7, undefined, 5, 2, 4, 1, 5, 0, 6, 1, 5, 2],

package/src/text/index.d.ts

@@ -1,4 +1,2 @@
-export { default as vectorChar, VectorChar, VectorCharOptions } from './vectorChar'
-export { default as vectorText, VectorText, VectorTextOptions } from './vectorText'
-
-export as namespace text
+export { vectorChar, VectorChar, VectorCharOptions } from './vectorChar.js'
+export { vectorText, VectorText, VectorTextOptions } from './vectorText.js'

package/src/text/index.js

@@ -4,9 +4,7 @@
  * Note: Only ASCII characters are supported.
  * @module modeling/text
  * @example
- * const { vectorChar, vectorText } = require('@jscad/modeling').text
+ * import { vectorChar, vectorText } from '@jscad/modeling'
  */
-module.exports = {
-  vectorChar: require('./vectorChar'),
-  vectorText: require('./vectorText')
-}
+export { vectorChar } from './vectorChar.js'
+export { vectorText } from './vectorText.js'

package/src/text/vectorChar.d.ts

@@ -1,6 +1,4 @@
-import Vec2 from '../maths/vec2/type'
-
-export default vectorChar
+import type { Vec2 } from '../maths/vec2/type.d.ts'
 
 export interface VectorChar {
   width: number
@@ -13,10 +11,6 @@ export interface VectorCharOptions {
   yOffset?: number
   height?: number
   extrudeOffset?: number
-  input?: string
 }
 
-declare function vectorChar(): VectorChar
-declare function vectorChar(char: string): VectorChar
-declare function vectorChar(options: VectorCharOptions): VectorChar
-declare function vectorChar(options: Omit<VectorCharOptions, 'input'>, char: string): VectorChar
+export function vectorChar(options: VectorCharOptions, text: string): VectorChar

package/src/text/vectorChar.js

@@ -1,60 +1,75 @@
-const vectorParams = require('./vectorParams')
+import { fromPoints } from '../geometries/path2/index.js'
+import * as vec2 from '../maths/vec2/index.js'
+
+import { simplex } from './fonts/single-line/hershey/simplex.js'
+
+const defaultsVectorParams = {
+  xOffset: 0,
+  yOffset: 0,
+  font: simplex,
+  height: 14, // old vector_xxx simplex font height
+  extrudeOffset: 0
+}
 
 /**
- * Represents a character as a list of segments
- * @typedef {Object} VectorCharObject
- * @property {Float} width - character width
- * @property {Float} height - character height (uppercase)
- * @property {Array} segments - character segments [[[x, y], ...], ...]
+ * Represents a character as an anonymous object containing a list of 2D paths.
+ * @typedef {Object} VectorChar
+ * @property {number} width - character width
+ * @property {number} height - character height (uppercase)
+ * @property {Array} paths - list of 2D paths
  */
 
-/** Construct a {@link VectorCharObject} from a ascii character whose code is between 31 and 127,
-* if the character is not supported it is replaced by a question mark.
-* @param {Object|String} [options] - options for construction or ascii character
-* @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.extrudeOffset=0] - width of the extrusion that will be applied (manually) after the creation of the character
-* @param {String} [options.input='?'] - ascii character (ignored/overwrited if provided as seconds parameter)
-* @param {String} [char='?'] - ascii character
-* @returns {VectorCharObject}
-* @alias module:modeling/text.vectorChar
-*
-* @example
-* let vectorCharObject = vectorChar()
-* let vectorCharObject = vectorChar('A')
-* let vectorCharObject = vectorChar({ xOffset: 57 }, 'C')
-* let vectorCharObject = vectorChar({ xOffset: 78, input: '!' })
-*/
-const vectorChar = (options, char) => {
+/**
+ * Construct a {@link VectorChar} from an ASCII character whose code is between 31 and 127.
+ * If the character is not supported it is replaced by a question mark.
+ *
+ * @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=21] - font size/character height (uppercase height)
+ * @param {number} [options.extrudeOffset=0] - width of the extrusion that will be applied (manually) after the creation of the character
+ * @param {string} text - ascii character
+ * @returns {VectorChar} a new vertor char object
+ * @alias module:modeling/text.vectorChar
+ *
+ * @example
+ * let mycharacter = vectorChar({ xOffset: 57 }, 'C')
+ */
+export const vectorChar = (options, text) => {
   const {
-    xOffset, yOffset, input, font, height, extrudeOffset
-  } = vectorParams(options, char)
-  let code = input.charCodeAt(0)
+    xOffset, yOffset, font, height, extrudeOffset
+  } = Object.assign({}, defaultsVectorParams, options)
+
+  if (typeof text !== 'string' || text.length !== 1) {
+    throw new Error('text must be a single character')
+  }
+
+  let code = text.charCodeAt(0)
   if (!code || !font[code]) {
-    code = 63 // 63 => ?
+    code = 63 // invalid character so use ?
   }
+
   const glyph = [].concat(font[code])
   const ratio = (height - extrudeOffset) / font.height
   const extrudeYOffset = (extrudeOffset / 2)
   const width = glyph.shift() * ratio
-  const segments = []
+
+  const paths = []
   let polyline = []
   for (let i = 0, il = glyph.length; i < il; i += 2) {
     const gx = ratio * glyph[i] + xOffset
     const gy = ratio * glyph[i + 1] + yOffset + extrudeYOffset
     if (glyph[i] !== undefined) {
-      polyline.push([gx, gy])
+      polyline.push(vec2.fromValues(gx, gy))
       continue
     }
-    segments.push(polyline)
+    paths.push(fromPoints({}, polyline))
     polyline = []
     i--
   }
   if (polyline.length) {
-    segments.push(polyline)
+    paths.push(fromPoints({}, polyline))
   }
-  return { width, height, segments }
-}
 
-module.exports = vectorChar
+  return { width, height, paths }
+}

package/src/text/vectorChar.test.js

@@ -0,0 +1,63 @@
+import test from 'ava'
+
+import { vec2 } from '../maths/index.js'
+
+import { vectorChar } from './index.js'
+
+const compareSegments = (paths, segments) => {
+  if (paths.length !== segments.length) return false
+  for (let i = 0; i < paths.length; i++) {
+    const ppoints = paths[i].points
+    const spoints = segments[i]
+    if (ppoints.length !== spoints.length) return false
+    for (let i = 0; i < ppoints.length; i++) {
+      if (!vec2.equals(ppoints[i], spoints[i])) return false
+    }
+  }
+  return true
+}
+
+test('vectorChar (char)', (t) => {
+  const obs = vectorChar({}, 'H')
+  const expSegments = [
+    [[4, 21], [4, 0]],
+    [[18, 21], [18, 0]],
+    [[4, 11], [18, 11]]
+  ]
+
+  t.deepEqual(obs.width, 22)
+  t.deepEqual(obs.height, 14)
+  t.true(compareSegments(obs.paths, expSegments))
+})
+
+test('vectorChar ({ xOffset, yOffset }, char)', (t) => {
+  const obs = vectorChar({ xOffset: 10, yOffset: 20 }, 'H')
+  const expSegments = [
+    [[14, 41], [14, 20]],
+    [[28, 41], [28, 20]],
+    [[14, 31], [28, 31]]
+  ]
+
+  t.deepEqual(obs.width, 22)
+  t.deepEqual(obs.height, 14)
+  t.true(compareSegments(obs.paths, expSegments))
+})
+
+test('vectorChar ({ height }, char)', (t) => {
+  const obs = vectorChar({ height: 10 }, 'h')
+  const expSegments = [
+    [[2.857142857142857, 15], [2.857142857142857, 0]],
+    [[2.857142857142857, 7.142857142857143], [5, 9.285714285714286], [6.428571428571429, 10], [8.571428571428571, 10], [10, 9.285714285714286], [10.714285714285715, 7.142857142857143], [10.714285714285715, 0]]
+  ]
+
+  t.deepEqual(obs.width, 13.571428571428571)
+  t.deepEqual(obs.height, 10)
+  t.true(compareSegments(obs.paths, expSegments))
+})
+
+test('vectorChar required options', (t) => {
+  t.throws(() => vectorChar(), { message: 'text must be a single character' })
+  t.throws(() => vectorChar({}), { message: 'text must be a single character' })
+  t.throws(() => vectorChar({}, ''), { message: 'text must be a single character' })
+  t.throws(() => vectorChar({}, 'ABC'), { message: 'text must be a single character' })
+})

package/src/text/vectorText.d.ts

@@ -1,6 +1,4 @@
-import Vec2 from '../maths/vec2/type'
-
-export default vectorText
+import type { Vec2 } from '../maths/vec2/type.d.ts'
 
 export interface VectorText extends Array<Array<Vec2>> {}
 
@@ -12,10 +10,6 @@ export interface VectorTextOptions {
   letterSpacing?: number
   align?: 'left' | 'center' | 'right'
   extrudeOffset?: number
-  input?: string
 }
 
-declare function vectorText(): VectorText
-declare function vectorText(text: string): VectorText
-declare function vectorText(options: VectorTextOptions): VectorText
-declare function vectorText(options: Omit<VectorTextOptions, 'input'>, text: string): VectorText
+export function vectorText(options: VectorTextOptions, text: string): VectorText

package/src/text/vectorText.js

@@ -1,92 +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()
- * let textSegments = vectorText('OpenJSCAD')
- * let textSegments = vectorText({ yOffset: -50 }, 'OpenJSCAD')
- * 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