@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/primitives/star.js

@@ -1,9 +1,9 @@
-const { TAU } = require('../maths/constants')
-const vec2 = require('../maths/vec2')
+import { TAU } 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 { isGT, isGTE, isNumberArray } = require('./commonChecks')
+import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 // @see http://www.jdawiseman.com/papers/easymath/surds_star_inner_radius.html
 const getRadiusRatio = (vertices, density) => {
@@ -29,21 +29,21 @@ const getPoints = (vertices, radius, startAngle, center) => {
 /**
  * Construct a star in two dimensional space.
  * @see https://en.wikipedia.org/wiki/Star_polygon
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of star
- * @param {Number} [options.vertices=5] - number of vertices (P) on the star
- * @param {Number} [options.density=2] - density (Q) of star
- * @param {Number} [options.outerRadius=1] - outer radius of vertices
- * @param {Number} [options.innerRadius=0] - inner radius of vertices, or zero to calculate
- * @param {Number} [options.startAngle=0] - starting angle for first vertice, in radians
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.vertices=5] - number of vertices (P) on the star
+ * @param {number} [options.density=2] - density (Q) of star
+ * @param {number} [options.outerRadius=1] - outer radius of vertices
+ * @param {number} [options.innerRadius=0] - inner radius of vertices, or zero to calculate
+ * @param {number} [options.startAngle=0] - starting angle for first vertex, in radians
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.star
  *
  * @example
  * let star1 = star({vertices: 8, outerRadius: 10}) // star with 8/2 density
  * let star2 = star({vertices: 12, outerRadius: 40, innerRadius: 20}) // star with given radius
  */
-const star = (options) => {
+export const star = (options) => {
   const defaults = {
     center: [0, 0],
     vertices: 5,
@@ -71,10 +71,10 @@ const star = (options) => {
     innerRadius = outerRadius * getRadiusRatio(vertices, density)
   }
 
-  const centerv = vec2.clone(center)
+  const centerV = vec2.clone(center)
 
-  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerv)
-  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerv)
+  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerV)
+  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerV)
 
   const allPoints = []
   for (let i = 0; i < vertices; i++) {
@@ -82,7 +82,5 @@ const star = (options) => {
     allPoints.push(innerPoints[i])
   }
 
-  return geom2.fromPoints(allPoints)
+  return geom2.create([allPoints])
 }
-
-module.exports = star

package/src/primitives/star.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { star } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { star } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('star (defaults)', (t) => {
   const geometry = star()

package/src/primitives/torus.d.ts

@@ -1,6 +1,4 @@
-import Geom3 from '../geometries/geom3/type'
-
-export default torus
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface TorusOptions {
   innerRadius?: number
@@ -12,4 +10,4 @@ export interface TorusOptions {
   startAngle?: number
 }
 
-declare function torus(options?: TorusOptions): Geom3
+export function torus(options?: TorusOptions): Geom3

package/src/primitives/torus.js

@@ -1,30 +1,30 @@
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const extrudeRotate = require('../operations/extrusions/extrudeRotate')
-const { rotate } = require('../operations/transforms/rotate')
-const { translate } = require('../operations/transforms/translate')
+import { extrudeRotate } from '../operations/extrusions/extrudeRotate.js'
+import { rotate } from '../operations/transforms/rotate.js'
+import { translate } from '../operations/transforms/translate.js'
 
-const circle = require('./circle')
+import { circle } from './circle.js'
 
-const { isGT, isGTE } = require('./commonChecks')
+import { isGT, isGTE } from './commonChecks.js'
 
 /**
  * Construct a torus by revolving a small circle (inner) about the circumference of a large (outer) circle.
- * @param {Object} [options] - options for construction
- * @param {Number} [options.innerRadius=1] - radius of small (inner) circle
- * @param {Number} [options.outerRadius=4] - radius of large (outer) circle
- * @param {Integer} [options.innerSegments=32] - number of segments to create per rotation
- * @param {Integer} [options.outerSegments=32] - number of segments to create per rotation
- * @param {Integer} [options.innerRotation=0] - rotation of small (inner) circle in radians
- * @param {Number} [options.outerRotation=TAU] - rotation (outer) of the torus (RADIANS)
- * @param {Number} [options.startAngle=0] - start angle of the torus (RADIANS)
- * @returns {geom3} new 3D geometry
+ * @param {object} [options] - options for construction
+ * @param {number} [options.innerRadius=1] - radius of small (inner) circle
+ * @param {number} [options.outerRadius=4] - radius of large (outer) circle
+ * @param {number} [options.innerSegments=32] - number of segments to create per rotation
+ * @param {number} [options.outerSegments=32] - number of segments to create per rotation
+ * @param {number} [options.innerRotation=0] - rotation of small (inner) circle in radians
+ * @param {number} [options.outerRotation=TAU] - rotation (outer) of the torus (RADIANS)
+ * @param {number} [options.startAngle=0] - start angle of the torus (RADIANS)
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.torus
  *
  * @example
  * let myshape = torus({ innerRadius: 10, outerRadius: 100 })
  */
-const torus = (options) => {
+export const torus = (options) => {
   const defaults = {
     innerRadius: 1,
     innerSegments: 32,
@@ -60,5 +60,3 @@ const torus = (options) => {
   }
   return extrudeRotate(extrudeOptions, innerCircle)
 }
-
-module.exports = torus

package/src/primitives/torus.test.js

@@ -1,12 +1,14 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
-const measureBoundingBox = require('../measurements/measureBoundingBox')
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { geom3 } from '../geometries/index.js'
 
-const { torus } = require('./index')
+import { measureBoundingBox } from '../measurements/index.js'
+
+import { torus } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('torus (defaults)', (t) => {
   const obs = torus()

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,14 @@
-const test = require('ava')
+import test from 'ava'
 
-const { triangle } = require('./index')
+import { TAU } from '../maths/constants.js'
 
-const degToRad = require('../utils/degToRad')
-const geom2 = require('../geometries/geom2')
-const { TAU } = require('../maths/constants')
+import { degToRad } from '../utils/index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { geom2 } from '../geometries/index.js'
+
+import { triangle } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('triangle (defaults)', (t) => {
   const geometry = triangle()

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,63 +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()
-* or
-* let vectorCharObject = vectorChar('A')
-* or
-* let vectorCharObject = vectorChar({ xOffset: 57 }, 'C')
-* or
-* 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