@jscad/modeling 3.0.2-alpha.0 → 3.0.4-alpha.0

package/src/geometries/path3/equals.js

@@ -0,0 +1,50 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { toVertices } from './toVertices.js'
+
+/**
+ * Determine if the given paths are equal.
+ *
+ * For closed paths, this includes equality by vertex order rotation.
+ *
+ * @param {Path3} a - the first path to compare
+ * @param {Path3} b - the second path to compare
+ * @returns {boolean}
+ * @alias module:modeling/path3.equals
+ *
+ * @example
+ * if (path3.equals(pathA, pathB)) { ... }
+ */
+export const equals = (a, b) => {
+  if (a.isClosed !== b.isClosed) {
+    return false
+  }
+  if (a.vertices.length !== b.vertices.length) {
+    return false
+  }
+
+  const aVertices = toVertices(a)
+  const bVertices = toVertices(b)
+
+  // closed paths might be equal under graph rotation
+  // so try comparison by rotating across all vertices
+  const length = aVertices.length
+  let offset = 0
+  do {
+    let unequal = false
+    for (let i = 0; i < length; i++) {
+      if (!vec3.equals(aVertices[i], bVertices[(i + offset) % length])) {
+        unequal = true
+        break
+      }
+    }
+    if (unequal === false) {
+      return true
+    }
+    // unequal open paths should only be compared once, never rotated
+    if (!a.isClosed) {
+      return false
+    }
+  } while (++offset < length)
+  return false
+}

package/src/geometries/path3/equals.test.js

@@ -0,0 +1,38 @@
+import test from 'ava'
+
+import { equals, fromVertices } from './index.js'
+
+test('equals: two paths with different points are not equal', (t) => {
+  const p1 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0]])
+  const p2 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  t.false(equals(p1, p2))
+
+  const p3 = fromVertices({ closed: true }, [[2, 0, 0], [2, 1, 0], [0, 1, 0], [1, 0, 0]])
+  const p4 = fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  t.false(equals(p3, p4))
+})
+
+test('equals: two open paths with the same points are equal', (t) => {
+  const p1 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  const p2 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  t.true(equals(p1, p2))
+})
+
+test('equals: two open paths with the same points rotated are unequal', (t) => {
+  t.false(equals(fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: false }, [[2, 0, 0], [2, 1, 0], [0, 1, 0], [0, 0, 0]])))
+})
+
+test('equals: two closed paths with the same points are equal', (t) => {
+  t.true(equals(fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])))
+
+  // rotated
+  t.true(equals(fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: true }, [[2, 0, 0], [2, 1, 0], [0, 1, 0], [0, 0, 0]])))
+})
+
+test('equals: closed path and open path with the same points are unequal', (t) => {
+  t.false(equals(fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])))
+})

package/src/geometries/path3/fromVertices.d.ts

@@ -0,0 +1,8 @@
+import type { Path3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+
+export interface FromVerticesOptions {
+  closed?: boolean
+}
+
+export function fromVertices(options: FromVerticesOptions, vertices: Array<Vec3>): Path3

package/src/geometries/path3/fromVertices.js

@@ -0,0 +1,44 @@
+import { EPS } from '../../maths/constants.js'
+
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { close } from './close.js'
+import { create } from './create.js'
+
+/**
+ * Create a new path from the given vertices.
+ *
+ * The vertices must be provided as an array of vertices,
+ * where each vertex is an array of three numbers.
+ *
+ * @param {Object} options - options for construction
+ * @param {boolean} [options.closed=false] - if the path should be open or closed
+ * @param {Array} vertices - array of vertices (3D) from which to create the path
+ * @returns {Path3} a new path
+ * @alias module:modeling/path3.fromVertices
+ *
+ * @example
+ * my newPath = path3.fromVertices({closed: true}, [[10, 10, 10], [-10, 10, -10]])
+ */
+export const fromVertices = (options, vertices) => {
+  const defaults = { closed: false }
+  let { closed } = Object.assign({}, defaults, options)
+
+  let created = create()
+  // FIXME why clone vertices?
+  created.vertices = vertices.map((vertex) => vec3.clone(vertex))
+
+  // check if first and last vertices are equal
+  if (created.vertices.length > 1) {
+    const p0 = created.vertices[0]
+    const pn = created.vertices[created.vertices.length - 1]
+    // FIXME correct EPS
+    if (vec3.distance(p0, pn) < (EPS * EPS)) {
+      // and close automatically
+      closed = true
+    }
+  }
+  if (closed === true) created = close(created)
+
+  return created
+}

package/src/geometries/path3/fromVertices.test.js

@@ -0,0 +1,33 @@
+import test from 'ava'
+
+import { vec3 } from '../../maths/index.js'
+
+import { fromVertices, toVertices, toString } from './index.js'
+
+test('fromVertices: creating a path from no vertices produces an open, empty non-canonical path', (t) => {
+  const created = fromVertices({}, [])
+  t.false(created.isClosed)
+  t.deepEqual(toVertices(created), [])
+})
+
+test('fromVertices: creating a path from one point produces a open, non-canonical path', (t) => {
+  const created = fromVertices({}, [[1, 1, 0]])
+  toString(created)
+
+  t.false(created.isClosed)
+  t.deepEqual(toVertices(created), [vec3.fromValues(1, 1, 0)])
+})
+
+test('fromVertices: creating a closed path from one point produces a closed, non-canonical path', (t) => {
+  const created = fromVertices({ closed: true }, [[1, 1, 0]])
+  t.true(created.isClosed)
+  t.deepEqual(toVertices(created), [vec3.fromValues(1, 1, 0)])
+
+  toString(created)
+})
+
+test('fromVertices: creating a path from a closed set of vertices creates a closed, non-canonical path', (t) => {
+  const created = fromVertices({ closed: false }, [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 0, 0]])
+  t.true(created.isClosed)
+  t.is(3, created.vertices.length) // the last given point is dropped
+})

package/src/geometries/path3/index.d.ts

@@ -0,0 +1,13 @@
+export { close } from './close.js'
+export { concat } from './concat.js'
+export { create } from './create.js'
+export { equals } from './equals.js'
+export { fromVertices, FromVerticesOptions } from './fromVertices.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toString } from './toString.js'
+export { toVertices } from './toVertices.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
+
+export type { Path3 } from './type.d.ts'

package/src/geometries/path3/index.js

@@ -0,0 +1,37 @@
+/**
+ * Represents a 3D geometry consisting of a list of ordered vertices.
+ *
+ * @see {@link Path3} for data structure information.
+ * @module modeling/path3
+ *
+ * @example
+ * import { path3 } from '@jscad/modeling'
+ * let myShape = path3.fromVertices({ closed: true }, [[0,0,0], [4,0,0], [4,3,0]])
+ */
+
+/**
+ * @typedef {Object} Path3
+ * @property {Array} vertices - list of ordered vertices
+ * @property {boolean} isClosed - true if the path is closed where start and end vertices are the same
+ * @property {Mat4} transforms - transforms to apply to the vertices, see transform()
+ *
+ * @example
+ * // data structure
+ * {
+ *   vertices: [[0,0,0], [4,0,0], [4,3,0]],
+ *   isClosed: true,
+ *   transforms: [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ * }
+ */
+
+export { close } from './close.js'
+export { concat } from './concat.js'
+export { create } from './create.js'
+export { equals } from './equals.js'
+export { fromVertices } from './fromVertices.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toString } from './toString.js'
+export { toVertices } from './toVertices.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

package/src/geometries/path3/isA.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function isA(object: any): object is Path3

package/src/geometries/path3/isA.js

@@ -0,0 +1,22 @@
+/**
+ * Determine if the given object is a path3 geometry.
+ *
+ * @param {Object} object - the object to interrogate
+ * @returns {boolean} true if the object matches a path3
+ * @alias module:modeling/path3.isA
+ *
+ * @example
+ * if (path3.isA(geometry)) { ... }
+ */
+export const isA = (object) => {
+  if (object && typeof object === 'object') {
+    // see create for the required attributes and types
+    if ('vertices' in object && 'transforms' in object && 'isClosed' in object) {
+      // NOTE: transforms should be a TypedArray, which has a read-only length
+      if (Array.isArray(object.vertices) && 'length' in object.transforms) {
+        return true
+      }
+    }
+  }
+  return false
+}

package/src/geometries/path3/isA.test.js

@@ -0,0 +1,19 @@
+import test from 'ava'
+
+import { isA, create, fromVertices } from './index.js'
+
+test('isA: identifies created paths', (t) => {
+  const p1 = create()
+  const p2 = fromVertices({}, [[0, 0, 0]])
+  t.true(isA(p1))
+  t.true(isA(p2))
+})
+
+test('isA: identifies non paths', (t) => {
+  const p1 = null
+  const p2 = {}
+  const p3 = { vertices: 1, transforms: 1, isClosed: 1 }
+  t.false(isA(p1))
+  t.false(isA(p2))
+  t.false(isA(p3))
+})

package/src/geometries/path3/reverse.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function reverse(path: Path3): Path3

package/src/geometries/path3/reverse.js

@@ -0,0 +1,18 @@
+/**
+ * Reverses the path so that the vertices are in the opposite order.
+ *
+ * This swaps the left (interior) and right (exterior) edges.
+ *
+ * @param {Path3} geometry - the path to reverse
+ * @returns {Path3} a new path
+ * @alias module:modeling/path3.reverse
+ *
+ * @example
+ * let newPath = path3.reverse(oldPath)
+ */
+export const reverse = (geometry) => {
+  // NOTE: this only updates the order of the vertices
+  const cloned = Object.assign({}, geometry)
+  cloned.vertices = geometry.vertices.slice().reverse()
+  return cloned
+}

package/src/geometries/path3/reverse.test.js

@@ -0,0 +1,9 @@
+import test from 'ava'
+
+import { reverse, equals, fromVertices } from './index.js'
+
+test('reverse: The reverse of a path has reversed points', (t) => {
+  const vertices = [[0, 0], [1, 1, 0]]
+  t.false(equals(reverse(fromVertices({}, vertices)),
+    fromVertices({}, vertices)))
+})

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

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

package/src/geometries/path3/toString.js

@@ -0,0 +1,23 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { toVertices } from './toVertices.js'
+
+/**
+ * Create a string representing the contents of the given path.
+ *
+ * @param {path} geometry - the path
+ * @returns {string} a representative string
+ * @alias module:modeling/path3.toString
+ *
+ * @example
+ * console.out(path3.toString(geometry))
+ */
+export const toString = (geometry) => {
+  const vertices = toVertices(geometry)
+  let result = 'path (' + vertices.length + ' vertices, ' + geometry.isClosed + '):\n[\n'
+  vertices.forEach((vertex) => {
+    result += '  ' + vec3.toString(vertex) + ',\n'
+  })
+  result += ']\n'
+  return result
+}

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

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

package/src/geometries/path3/toVertices.js

@@ -0,0 +1,15 @@
+import { applyTransforms } from './applyTransforms.js'
+
+/**
+ * Produces an array of vertices from the given geometry.
+ *
+ * The returned array should not be modified as the data is shared with the geometry.
+ *
+ * @param {Path3} geometry - the geometry
+ * @returns {Array} an array of vertices
+ * @alias module:modeling/path3.toVertices
+ *
+ * @example
+ * let sharedVertices = path3.toVertices(geometry)
+ */
+export const toVertices = (geometry) => applyTransforms(geometry).vertices

package/src/geometries/path3/toVertices.test.js

@@ -0,0 +1,13 @@
+import test from 'ava'
+
+import { vec3 } from '../../maths/index.js'
+
+import { toVertices, fromVertices } from './index.js'
+
+test('toVertices: An empty path produces an empty point array', (t) => {
+  t.deepEqual(toVertices(fromVertices({}, [])), [])
+})
+
+test('toVertices: An non-empty open path produces a matching point array', (t) => {
+  t.deepEqual(toVertices(fromVertices({}, [[1, 1, 0]])), [vec3.fromValues(1, 1, 0)])
+})

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

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

package/src/geometries/path3/transform.js

@@ -0,0 +1,20 @@
+import * as mat4 from '../../maths/mat4/index.js'
+
+/**
+ * Transform the given geometry using the given matrix.
+ *
+ * This is a lazy transform of the vertices, as this function only adjusts the transforms.
+ * The transforms are applied when accessing the vertices via toVertices().
+ *
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Path3} geometry - the geometry to transform
+ * @returns {Path3} a new path
+ * @alias module:modeling/path3.transform
+ *
+ * @example
+ * let newPath = path3.transform(mat4.fromZRotation(TAU / 8), oldPath)
+ */
+export const transform = (matrix, geometry) => {
+  const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  return Object.assign({}, geometry, { transforms })
+}

package/src/geometries/path3/transform.test.js

@@ -0,0 +1,50 @@
+import test from 'ava'
+
+import { mat4 } from '../../maths/index.js'
+
+import { transform, fromVertices, toVertices } from './index.js'
+
+import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
+
+test('transform: adjusts the transforms of path', (t) => {
+  const vertices = [[0, 0, 0], [1, 0, 0], [0, 1, 0]]
+  const rotation = 90 * 0.017453292519943295
+  const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
+
+  // continue with typical user scenario, several iterations of transforms and access
+
+  // expect lazy transform, i.e. only the transforms change
+  const expected = {
+    vertices: [[0, 0, 0], [1, 0, 0], [0, 1, 0]],
+    isClosed: false,
+    transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  const geometry = fromVertices({}, vertices)
+  let another = transform(rotate90, geometry)
+  t.not(geometry, another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect lazy transform, i.e. only the transforms change
+  expected.transforms = [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 5, 10, 15, 1]
+  another = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect application of the transforms to the vertices
+  expected.vertices = [[5, 10, 15], [5, 11, 15], [4, 10, 15]]
+  expected.transforms = mat4.create()
+  toVertices(another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect lazy transform, i.e. only the transforms change
+  expected.transforms = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 5, 10, 15, 1]
+  another = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+})

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

@@ -0,0 +1,10 @@
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { Color } from '../types.d.ts'
+
+export interface Path3 {
+  vertices: Array<Vec3>
+  isClosed: boolean
+  transforms: Mat4
+  color?: Color
+}

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

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

package/src/geometries/path3/validate.js

@@ -0,0 +1,44 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { isA } from './isA.js'
+
+/**
+ * Determine if the given object is a valid path3.
+ *
+ * Checks for valid vertices, and duplicate vertices.
+ *
+ * **NOTE: 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/path3.validate
+ *
+ * @example
+ * path3.vaidate(geometry)
+ */
+export const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid path3 structure')
+  }
+
+  // check for duplicate vertices
+  if (object.vertices.length > 1) {
+    for (let i = 0; i < object.vertices.length; i++) {
+      if (vec3.equals(object.vertices[i], object.vertices[(i + 1) % object.vertices.length])) {
+        throw new Error(`path3 has duplicate vertex ${object.vertices[i]}`)
+      }
+    }
+  }
+
+  // check for infinity, nan
+  object.vertices.forEach((vertex) => {
+    if (!vertex.every(Number.isFinite)) {
+      throw new Error(`path3 invalid non-finite vertex ${vertex}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`path3 invalid transforms ${object.transforms}`)
+  }
+}

package/src/geometries/poly2/arePointsInside.js

@@ -7,7 +7,10 @@ import { reverse } from './reverse.js'
  * @param {Array} points - a list of points, where each point is an array with X and Y values
  * @param {Poly2} polygon - a 2D polygon
  * @return {number} 1 if all points are inside, 0 if some or none are inside
- * @alias module:modeling/geometries/poly2.arePointsInside
+ * @alias module:modeling/poly2.arePointsInside
+ *
+ * @example
+ * if (poly2.arePointsInside([[0,0], [4,0], [4,3]], geometry) { ... }
  */
 export const arePointsInside = (points, polygon) => {
   if (points.length === 0) return 0 // nothing to check

package/src/geometries/poly2/clone.js

@@ -3,6 +3,9 @@
  *
  * @param {Poly2} polygon - polygon to clone
  * @returns {Poly2} a new polygon
- * @alias module:modeling/geometries/poly2.clone
+ * @alias module:modeling/poly2.clone
+ *
+ * @example
+ * const newPoly = poly2.clone(oldPoly)
  */
 export const clone = (polygon) => Object.assign({}, polygon)

package/src/geometries/poly2/create.js

@@ -1,23 +1,11 @@
-/**
- * Represents a 2D polygon consisting of a list of ordered points
- * which is closed between start and end points.
- * @see https://en.wikipedia.org/wiki/Polygon
- * @property {Array} points - list of ordered points (2D)
- */
-
 /**
  * Creates a new polygon with initial values.
  *
  * @param {Array} [points] - list of points (2D)
  * @returns {Poly2} a new polygon
- * @alias module:modeling/geometries/poly2.create
+ * @alias module:modeling/poly2.create
  *
  * @example
- * let polygon = create([[0,0], [4,0], [4,3]])
+ * let polygon = poly2.create([[0,0], [4,0], [4,3]])
  */
-export const create = (points) => {
-  if (points === undefined || points.length < 3) {
-    points = [] // empty contents
-  }
-  return { points }
-}
+export const create = (points = []) => ({ points })

package/src/geometries/poly2/index.js

@@ -1,12 +1,24 @@
 /**
  * Represents a 2D polygon consisting of a list of ordered points.
- * @see {@link poly2} for data structure information.
- * @module modeling/geometries/poly2
+ * @see {@link Poly2} for data structure information.
+ * @module modeling/poly2
  *
  * @example
- * import { geometries } from '@jscad/modeling'
- * const p1 = geometries.poly2.create([[0,0], [4,0], [4,3]])
+ * import { poly2 } from '@jscad/modeling'
+ * const p1 = poly2.create([[0,0], [4,0], [4,3]])
  */
+
+/**
+ * @typedef {Object} Poly2
+ * @property {Array} points - list of ordered points (2D)
+ *
+ * @example
+ * // data structure
+ * {
+ *   points: [[0,0], [4,0], [4,3]],
+ * }
+ */
+
 export { arePointsInside } from './arePointsInside.js'
 export { clone } from './clone.js'
 export { create } from './create.js'

package/src/geometries/poly2/isA.js

@@ -1,8 +1,12 @@
 /**
  * Determine if the given object is a 2D polygon.
+ *
  * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a poly2
- * @alias module:modeling/geometries/poly2.isA
+ * @alias module:modeling/poly2.isA
+ *
+ * @example
+ * if (poly2.isA(geometry)) { ... }
  */
 export const isA = (object) => {
   if (object && typeof object === 'object') {

package/src/geometries/poly2/isConvex.js

@@ -1,8 +1,12 @@
 /**
  * Check whether the given polygon is convex.
+ *
  * @param {Poly2} polygon - the polygon to interrogate
  * @returns {Boolean} true if convex
- * @alias module:modeling/geometries/poly2.isConvex
+ * @alias module:modeling/poly2.isConvex
+ *
+ * @example
+ * if (poly2.isConvex(geometry)) { ... }
  */
 export const isConvex = (polygon) => {
   const numPoints = polygon.points.length

package/src/geometries/poly2/isSimple.js

@@ -3,9 +3,13 @@ import { intersect } from '../../maths/utils/intersect.js'
 /**
  * Check whether the given polygon is simple, i.e. does not intersect itself.
  * @see https://en.wikipedia.org/wiki/Simple_polygon
+ *
  * @param {Poly2} polygon - the polygon to interrogate
  * @returns {Boolean} true if simple
- * @alias module:modeling/geometries/poly2.isSimple
+ * @alias module:modeling/poly2.isSimple
+ *
+ * @example
+ * if (poly2.isSimple(geometry)) { ... }
  */
 export const isSimple = (polygon) => {
   const numPoints = polygon.points.length

package/src/geometries/poly2/measureArea.js

@@ -5,6 +5,9 @@ import { area } from '../../maths/utils/area.js'
  *
  * @param {Poly2} polygon - the polygon to measure
  * @return {number} the area of the polygon
- * @alias module:modeling/geometries/poly2.measureArea
+ * @alias module:modeling/poly2.measureArea
+ *
+ * @example
+ * const area = poly2.measureArea(geometry)
  */
 export const measureArea = (polygon) => area(polygon.points)