@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/{operations/extrusions → geometries}/slice/toPolygons.js

@@ -1,14 +1,15 @@
-const poly3 = require('../../../geometries/poly3')
-const earcut = require('../earcut')
-const PolygonHierarchy = require('../earcut/polygonHierarchy')
+import * as poly3 from '../poly3/index.js'
+
+import { triangulate } from './earcut/index.js'
+import { PolygonHierarchy } from './earcut/polygonHierarchy.js'
 
 /**
  * Return a list of polygons which are enclosed by the slice.
- * @param {slice} slice - the slice
+ * @param {Slice} slice - the slice
  * @return {Array} a list of polygons (3D)
- * @alias module:modeling/extrusions/slice.toPolygons
+ * @alias module:modeling/geometries/slice.toPolygons
  */
-const toPolygons = (slice) => {
+export const toPolygons = (slice) => {
   const hierarchy = new PolygonHierarchy(slice)
 
   const polygons = []
@@ -26,15 +27,13 @@ const toPolygons = (slice) => {
     const data = vertices.flat()
     // Get original 3D vertex by index
     const getVertex = (i) => hierarchy.to3D(vertices[i])
-    const indices = earcut(data, holesIndex)
+    const indices = triangulate(data, holesIndex)
     for (let i = 0; i < indices.length; i += 3) {
       // Map back to original vertices
       const tri = indices.slice(i, i + 3).map(getVertex)
-      polygons.push(poly3.fromPointsAndPlane(tri, hierarchy.plane))
+      polygons.push(poly3.fromVerticesAndPlane(tri, hierarchy.plane))
     }
   })
 
   return polygons
 }
-
-module.exports = toPolygons

package/src/geometries/slice/toString.d.ts

@@ -0,0 +1,3 @@
+import type { Slice } from './type.d.ts'
+
+export function toString(slice: Slice): string

package/src/geometries/slice/toString.js

@@ -0,0 +1,16 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+/**
+ * Convert the given slice to a readable string.
+ * @param {Slice} slice - the slice
+ * @return {String} the string representation
+ * @alias module:modeling/geometries/slice.toString
+ */
+export const toString = (slice) => {
+  let result = 'slice (' + slice.contours.length + ' contours):\n[\n'
+  slice.contours.forEach((contour) => {
+    result += '  [' + contour.map(vec3.toString).join() + '],\n'
+  })
+  result += ']\n'
+  return result
+}

package/src/geometries/slice/toString.test.js

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { create, toString } from './index.js'
+
+test('toString: serialize empty slice into a string', (t) => {
+  const geometry = create()
+  const result = toString(geometry)
+  const expected = 'slice (0 contours):\n[\n]\n'
+  t.is(result, expected)
+})
+
+test('toString: serialize slice into a string', (t) => {
+  const geometry = create([[[0, 0, 3], [0, 1, 3], [2, 0, 3]]])
+  const result = toString(geometry)
+  const expected = 'slice (1 contours):\n[\n  [[0.0000000, 0.0000000, 3.0000000],[0.0000000, 1.0000000, 3.0000000],[2.0000000, 0.0000000, 3.0000000]],\n]\n'
+  t.is(result, expected)
+})

package/src/geometries/slice/toVertices.d.ts

@@ -0,0 +1,4 @@
+import type { Vec3 } from '../../maths/types.d.ts'
+import type { Slice } from './type.d.ts'
+
+export function toVertices(slice: Slice): Array<Vec3>

package/src/geometries/slice/toVertices.js

@@ -0,0 +1,19 @@
+/**
+ * Produces an array of vertices from the given slice.
+ * The returned array should not be modified as the data is shared with the slice.
+ * @param {Slice} slice - the slice
+ * @returns {Array} an array of 3D vertices
+ * @alias module:modeling/geometries/slice.toVertices
+ *
+ * @example
+ * let sharedVertices = toVertices(slice)
+ */
+export const toVertices = (slice) => {
+  const vertices = []
+  slice.contours.forEach((contour) => {
+    contour.forEach((vertex) => {
+      vertices.push(vertex)
+    })
+  })
+  return vertices
+}

package/src/geometries/slice/transform.d.ts

@@ -0,0 +1,5 @@
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+
+import type { Slice } from './type.d.ts'
+
+export function transform(matrix: Mat4, slice: Slice): Slice

package/src/geometries/slice/transform.js

@@ -0,0 +1,19 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Transform the given slice using the given matrix.
+ * @param {Mat4} matrix - transform matrix
+ * @param {Slice} slice - slice to transform
+ * @returns {Slice} the transformed slice
+ * @alias module:modeling/geometries/slice.transform
+ *
+ * @example
+ * let matrix = mat4.fromTranslation([1, 2, 3])
+ * let newSlice = transform(matrix, oldSlice)
+ */
+export const transform = (matrix, slice) => {
+  const contours = slice.contours.map((contour) => contour.map((vertex) => vec3.transform(vec3.create(), vertex, matrix)))
+  return create(contours)
+}

package/src/{operations/extrusions → geometries}/slice/transform.test.js

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { transform, fromPoints, toEdges } = require('./index')
+import { transform, fromVertices, toVertices } from './index.js'
 
 test('slice: transform() should return a new slice with correct values', (t) => {
   const identityMatrix = [
@@ -10,16 +10,12 @@ test('slice: transform() should return a new slice with correct values', (t) =>
     0, 0, 0, 1
   ]
 
-  const org1 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const org1 = fromVertices([[0, 0], [1, 0], [1, 1]])
   const ret1 = transform(identityMatrix, org1)
   t.not(org1, ret1)
 
-  const edges1 = toEdges(ret1)
-  const exp1 = [
-    [[1, 1, 0], [0, 0, 0]],
-    [[0, 0, 0], [1, 0, 0]],
-    [[1, 0, 0], [1, 1, 0]]
-  ]
+  const edges1 = toVertices(ret1)
+  const exp1 = [[0, 0, 0], [1, 0, 0], [1, 1, 0]]
   t.deepEqual(edges1, exp1)
 
   const x = 1
@@ -32,16 +28,12 @@ test('slice: transform() should return a new slice with correct values', (t) =>
     x, y, z, 1
   ]
 
-  const org2 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const org2 = fromVertices([[0, 0], [1, 0], [1, 1]])
   const ret2 = transform(translationMatrix, org2)
   t.not(org2, ret2)
 
-  const edges2 = toEdges(ret2)
-  const exp2 = [
-    [[2, 6, 7], [1, 5, 7]],
-    [[1, 5, 7], [2, 5, 7]],
-    [[2, 5, 7], [2, 6, 7]]
-  ]
+  const edges2 = toVertices(ret2)
+  const exp2 = [[1, 5, 7], [2, 5, 7], [2, 6, 7]]
   t.deepEqual(edges2, exp2)
 
   const r = (90 * 0.017453292519943295)
@@ -52,15 +44,13 @@ test('slice: transform() should return a new slice with correct values', (t) =>
     0, 0, 0, 1
   ]
 
-  const org3 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const org3 = fromVertices([[0, 0], [1, 0], [1, 1]])
   const ret3 = transform(rotateZMatrix, org3)
   t.not(org3, ret3)
 
-  const edges3 = toEdges(ret3)
+  const edges3 = toVertices(ret3)
   const exp3 = [
-    [[1, -0.9999999999999999, 0], [0, 0, 0]],
-    [[0, 0, 0], [6.123233995736766e-17, -1, 0]],
-    [[6.123233995736766e-17, -1, 0], [1, -0.9999999999999999, 0]]
+    [0, 0, 0], [6.123233995736766e-17, -1, 0], [1, -0.9999999999999999, 0]
   ]
   t.deepEqual(edges3, exp3)
 })

package/src/geometries/slice/type.d.ts

@@ -0,0 +1,7 @@
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Color } from '../types.d.ts'
+
+export interface Slice {
+  contours: Array<Array<Vec3>>
+  color?: Color
+}

package/src/geometries/slice/validate.d.ts

@@ -0,0 +1 @@
+export function validate(object: any): void

package/src/geometries/slice/validate.js

@@ -0,0 +1,48 @@
+import * as poly3 from '../../geometries/poly3/index.js'
+import * as plane from '../../maths/plane/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
+import { calculatePlane } from './calculatePlane.js'
+import { isA } from './isA.js'
+
+/**
+ * Determine if the given object is a valid slice.
+ * Checks for valid data points.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/slice.validate
+ */
+export const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid slice structure')
+  }
+
+  const slicePlane = calculatePlane(object)
+  object.contours.forEach((contour, i) => {
+    if (contour.length < 3) {
+      throw new Error(`slice contour ${i} must contain at least 3 vertices`)
+    }
+
+    // contours must be coplanar
+    const contourPlane = poly3.plane(poly3.create(contour))
+    if (!plane.equals(slicePlane, contourPlane)) {
+      throw new Error('slice contours must be coplanar')
+    }
+
+    for (let i = 0; i < contour.length; i++) {
+      const vertex = contour[i]
+      // check for infinity, nan
+      if (!vertex.every(Number.isFinite)) {
+        throw new Error(`slice contour ${i} must contain finite vertices`)
+      }
+
+      // check for duplicate points
+      const j = (i + 1) % contour.length
+      if (vec3.equals(contour[i], contour[j])) {
+        throw new Error(`slice contour ${i} has duplicate vertex ${contour[i]}`)
+      }
+    }
+  })
+}

package/src/geometries/slice/validate.test.js

@@ -0,0 +1,36 @@
+import test from 'ava'
+
+import * as vec3 from '../../maths/vec3/index.js'
+import { create, validate } from './index.js'
+
+// points of a triangle
+const a = vec3.fromValues(0, 0, 2)
+const b = vec3.fromValues(1, 0, 2)
+const c = vec3.fromValues(1, 1, 2)
+// non-coplanar
+const d = vec3.fromValues(0, 0, 0)
+
+test('validate: allow valid slice', (t) => {
+  const geometry = create([[a, b, c]])
+  t.notThrows(() => validate(geometry))
+})
+
+test('validate: throw exception for non-coplanar contours', (t) => {
+  const geometry = create([[a, b, c], [a, b, d]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for duplicate points', (t) => {
+  const geometry = create([[a, b, c, a]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for NaN', (t) => {
+  const geometry = create([[a, b, c, [0, 0, NaN]]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for infinity', (t) => {
+  const geometry = create([[a, b, c, [0, 0, Infinity]]])
+  t.throws(() => validate(geometry))
+})

package/src/geometries/types.d.ts

@@ -1,8 +1,9 @@
-import Geom2 from './geom2/type'
-import Geom3 from './geom3/type'
-import Poly3 from './poly3/type'
-import Path2 from './path2/type'
-import { RGB, RGBA } from '../colors'
+import type { Geom2 } from './geom2/type.d.ts'
+import type { Geom3 } from './geom3/type.d.ts'
+import type { Path2 } from './path2/type.d.ts'
+import type { Poly3 } from './poly3/type.d.ts'
+import type { Slice } from './slice/type.d.ts'
+import type { RGB, RGBA } from '../colors/index.d.ts'
 
 // NOTE (@ahdinosaur): Poly2 is not included as not well-supported.
 // see https://github.com/jscad/OpenJSCAD.org/pull/726#issuecomment-724575265
@@ -14,8 +15,9 @@ export interface Colored {
   color: Color
 }
 
-export { default as Geom2 } from './geom2/type'
-export { default as Geom3 } from './geom3/type'
-export { default as Poly2 } from './poly2/type'
-export { default as Poly3 } from './poly3/type'
-export { default as Path2 } from './path2/type'
+export type { Geom2 } from './geom2/type.d.ts'
+export type { Geom3 } from './geom3/type.d.ts'
+export type { Path2 } from './path2/type.d.ts'
+export type { Poly2 } from './poly2/type.d.ts'
+export type { Poly3 } from './poly3/type.d.ts'
+export type { Slice } from './slice/type.d.ts'

package/src/index.d.ts

@@ -5,13 +5,11 @@ export * as maths from './maths'
 export * as measurements from './measurements'
 export * as primitives from './primitives'
 export * as text from './text'
-export * as utils from './utils'
+export { degToRad, flatten, radiusToSegments, radToDeg } from './utils'
 
 export * as booleans from './operations/booleans'
-export * as expansions from './operations/expansions'
 export * as extrusions from './operations/extrusions'
 export * as hulls from './operations/hulls'
 export * as modifiers from './operations/modifiers'
+export * as offsets from './operations/offsets'
 export * as transforms from './operations/transforms'
-
-export as namespace modeling

package/src/index.js

@@ -1,17 +1,15 @@
-module.exports = {
-  colors: require('./colors'),
-  curves: require('./curves'),
-  geometries: require('./geometries'),
-  maths: require('./maths'),
-  measurements: require('./measurements'),
-  primitives: require('./primitives'),
-  text: require('./text'),
-  utils: require('./utils'),
+export * from './colors/index.js'
+export * from './curves/index.js'
+export * from './geometries/index.js'
+export * from './maths/index.js'
+export * from './measurements/index.js'
+export * from './primitives/index.js'
+export * from './text/index.js'
+export { degToRad, flatten, radiusToSegments, radToDeg } from './utils/index.js'
 
-  booleans: require('./operations/booleans'),
-  expansions: require('./operations/expansions'),
-  extrusions: require('./operations/extrusions'),
-  hulls: require('./operations/hulls'),
-  modifiers: require('./operations/modifiers'),
-  transforms: require('./operations/transforms')
-}
+export * from './operations/booleans/index.js'
+export * from './operations/extrusions/index.js'
+export * from './operations/hulls/index.js'
+export * from './operations/modifiers/index.js'
+export * from './operations/offsets/index.js'
+export * from './operations/transforms/index.js'

package/src/index.test-d.ts

@@ -1,12 +1,13 @@
 import { expectType, expectNotType, expectError } from 'tsd'
 
 import { geometries } from './'
+import { Geom2 } from './geometries/types'
 
 const { geom2 } = geometries
 
 expectType(geom2.create())
-expectType<geom2.Geom2>(geom2.create([]))
-expectType<geom2.Geom2>(
+expectType<Geom2>(geom2.create([]))
+expectType<Geom2>(
   geom2.create(
     [
       [[0, 0], [1, 1]],
@@ -23,4 +24,3 @@ expectNotType<
     [[1, 1, 1], [2, 2, 2]]
   ]
 )
-

package/src/maths/constants.d.ts

@@ -1,3 +1,3 @@
 export const EPS: number
 export const NEPS: number
-export const spatialResolution: number
+export const TAU: number

package/src/maths/constants.js

@@ -1,41 +1,31 @@
-/**
- * The resolution of space, currently one hundred nanometers.
- * This should be 1 / EPS.
- * @alias module:modeling/maths.spatialResolution
- * @default
- */
-const spatialResolution = 1e5
-
 /**
  * Epsilon used during determination of near zero distances.
  * This should be 1 / spacialResolution.
  * @default
  * @alias module:modeling/maths.EPS
+ * @example
+ * const { EPS } = maths.constants
  */
-const EPS = 1e-5
+export const EPS = 1e-5
 
 /**
  * Smaller epsilon used for measuring near zero distances.
  * @default
  * @alias module:modeling/maths.NEPS
+ * @example
+ * const { NEPS } = maths.constants
  */
-const NEPS = 1e-13
+export const NEPS = 1e-13
 // NEPS is derived from a series of tests to determine the optimal precision
 // for comparing coplanar polygons, as provided by the sphere primitive at high
-// segmentation. NEPS is for 64 bit Number values.
+// segmentation. NEPS is for 64-bit Number values.
 
 /**
  * The TAU property represents the ratio of the circumference of a circle to its radius.
  * Approximately 6.28318530717958647692
+ * @alias module:modeling/maths.TAU
  * @default
  * @example
- * const { TAU } = require('@jscad/modeling').maths.constants
+ * const { TAU } = maths.constants
  */
-const TAU = Math.PI * 2
-
-module.exports = {
-  EPS,
-  NEPS,
-  TAU,
-  spatialResolution
-}
+export const TAU = Math.PI * 2

package/src/maths/index.d.ts

@@ -1,11 +1,9 @@
-export * as constants from './constants'
-export * as line2 from './line2'
-export * as line3 from './line3'
-export * as mat4 from './mat4'
-export * as plane from './plane'
-export * as utils from './utils'
-export * as vec2 from './vec2'
-export * as vec3 from './vec3'
-export * as vec4 from './vec4'
-
-export as namespace maths
+export * from './constants.js'
+export * as line2 from './line2/index.js'
+export * as line3 from './line3/index.js'
+export * as mat4 from './mat4/index.js'
+export * as plane from './plane/index.js'
+export * as vec2 from './vec2/index.js'
+export * as vec3 from './vec3/index.js'
+export * as vec4 from './vec4/index.js'
+export { sin, cos } from './utils/trigonometry.js'

package/src/maths/index.js

@@ -4,16 +4,15 @@
  * @see Most computations are based upon the glMatrix library (glmatrix.net)
  * @module modeling/maths
  * @example
- * const { constants, line2, line3, mat4, plane, utils, vec2, vec3, vec4 } = require('@jscad/modeling').maths
+ * import { constants, line2, line3, mat4, plane, utils, vec2, vec3, vec4 } from '@jscad/modeling'
  */
-module.exports = {
-  constants: require('./constants'),
-  line2: require('./line2'),
-  line3: require('./line3'),
-  mat4: require('./mat4'),
-  plane: require('./plane'),
-  utils: require('./utils'),
-  vec2: require('./vec2'),
-  vec3: require('./vec3'),
-  vec4: require('./vec4')
-}
+export * from './constants.js'
+export * as line2 from './line2/index.js'
+export * as line3 from './line3/index.js'
+export * as mat4 from './mat4/index.js'
+export * as plane from './plane/index.js'
+export * as vec2 from './vec2/index.js'
+export * as vec3 from './vec3/index.js'
+export * as vec4 from './vec4/index.js'
+export { cos, sin } from './utils/trigonometry.js'
+export { area } from './utils/area.js'

package/src/maths/line2/clone.d.ts

@@ -1,5 +1,3 @@
-import Line2 from './type'
+import type { Line2 } from './type.d.ts'
 
-export default clone
-
-declare function clone(line: Line2): Line2
+export function clone(line: Line2): Line2

package/src/maths/line2/clone.js

@@ -1,18 +1,16 @@
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Create a clone of the given line.
  *
- * @param {line2} line - line to clone
- * @returns {line2} a new unbounded line
+ * @param {Line2} line - line to clone
+ * @returns {Line2} a new unbounded line
  * @alias module:modeling/maths/line2.clone
  */
-const clone = (line) => {
+export const clone = (line) => {
   const out = create()
   out[0] = line[0]
   out[1] = line[1]
   out[2] = line[2]
   return out
 }
-
-module.exports = clone

package/src/maths/line2/clone.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { clone, fromValues } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { clone, fromValues } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('line2: clone() should return a new line2 with same values', (t) => {
   const org1 = fromValues(0, 0, 0)

package/src/maths/line2/closestPoint.d.ts

@@ -1,6 +1,4 @@
-import Line2 from './type'
-import Vec2 from '../vec2/type'
+import type { Line2 } from './type.d.ts'
+import type { Vec2 } from '../vec2/type.d.ts'
 
-export default closestPoint
-
-declare function closestPoint(line: Line2, point: Vec2): Vec2
+export function closestPoint(line: Line2, point: Vec2): Vec2

package/src/maths/line2/closestPoint.js

@@ -1,17 +1,17 @@
-const vec2 = require('../vec2')
+import * as vec2 from '../vec2/index.js'
 
-const direction = require('./direction')
-const origin = require('./origin')
+import { direction } from './direction.js'
+import { origin } from './origin.js'
 
 /**
  * Determine the closest point on the given line to the given point.
  *
- * @param {line2} line - line of reference
- * @param {vec2} point - point of reference
- * @returns {vec2} closest point
+ * @param {Line2} line - line of reference
+ * @param {Vec2} point - point of reference
+ * @returns {Vec2} closest point
  * @alias module:modeling/maths/line2.closestPoint
  */
-const closestPoint = (line, point) => {
+export const closestPoint = (line, point) => {
   const orig = origin(line)
   const dir = direction(line)
 
@@ -21,5 +21,3 @@ const closestPoint = (line, point) => {
   vec2.add(v, v, orig)
   return v
 }
-
-module.exports = closestPoint

package/src/maths/line2/closestPoint.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { closestPoint, create, fromPoints } = require('./index')
+import test from 'ava'
 
-const { compareVectors } = require('../../../test/helpers/index')
+import { closestPoint, create, fromPoints } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
 
 test('line2: closestPoint() should return proper values', (t) => {
   const line1 = create()

package/src/maths/line2/copy.d.ts

@@ -1,5 +1,3 @@
-import Line2 from './type'
+import type { Line2 } from './type.d.ts'
 
-export default copy
-
-declare function copy(out: Line2, line: Line2): Line2
+export function copy(out: Line2, line: Line2): Line2

package/src/maths/line2/copy.js

@@ -1,16 +1,14 @@
 /**
  * Copy the given line to the receiving line.
  *
- * @param {line2} out - receiving line
- * @param {line2} line - line to copy
- * @returns {line2} out
+ * @param {Line2} out - receiving line
+ * @param {Line2} line - line to copy
+ * @returns {Line2} out
  * @alias module:modeling/maths/line2.copy
  */
-const copy = (out, line) => {
+export const copy = (out, line) => {
   out[0] = line[0]
   out[1] = line[1]
   out[2] = line[2]
   return out
 }
-
-module.exports = copy