@jscad/modeling 2.11.1 → 3.0.0-alpha.0

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

@@ -0,0 +1,62 @@
+import test from 'ava'
+
+import { transform, create } from './index.js'
+
+import { comparePoints } from '../../../test/helpers/index.js'
+
+test('poly2: transform() should return a new poly2 with correct values', (t) => {
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const exp1 = { points: [[0, 0], [1, 0], [1, 1]] }
+  const org1 = create([[0, 0], [1, 0], [1, 1]])
+  const ret1 = transform(identityMatrix, org1)
+  t.true(comparePoints(ret1.points, exp1.points))
+  t.not(org1, ret1)
+
+  const x = 1
+  const y = 5
+  const z = 0
+  const translationMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    x, y, z, 1
+  ]
+
+  const exp2 = { points: [[1, 5], [2, 5], [2, 6]] }
+  const org2 = create([[0, 0], [1, 0], [1, 1]])
+  const ret2 = transform(translationMatrix, org2)
+  t.true(comparePoints(ret2.points, exp2.points))
+  t.not(org2, ret2)
+
+  const r = (90 * 0.017453292519943295)
+  const rotateZMatrix = [
+    Math.cos(r), -Math.sin(r), 0, 0,
+    Math.sin(r), Math.cos(r), 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const exp3 = { points: [[0, 0], [0, -1], [1, -1]] }
+  const org3 = create([[0, 0], [1, 0], [1, 1]])
+  const ret3 = transform(rotateZMatrix, org3)
+  t.true(comparePoints(ret3.points, exp3.points))
+  t.not(org3, ret3)
+
+  const mirrorMatrix = [
+    -1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+  const exp4 = { points: [[-1, 1], [-1, 0], [0, 0]] }
+  const org4 = create([[0, 0], [1, 0], [1, 1]])
+  const ret4 = transform(mirrorMatrix, org4)
+  t.true(comparePoints(ret4.points, exp4.points))
+  t.not(org4, ret4)
+})

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

@@ -1,7 +1,7 @@
-import Vec2 from '../../maths/vec2/type'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
-export default Poly2
-
-declare interface Poly2 {
-  vertices: Array<Vec2>
+export declare interface Poly2 {
+  points: Array<Vec2>
 }
+
+export default Poly2

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

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

package/src/geometries/poly2/validate.js

@@ -0,0 +1,46 @@
+import * as vec2 from '../../maths/vec2/index.js'
+
+import { isA } from './isA.js'
+import { measureArea } from './measureArea.js'
+
+/**
+ * Determine if the given object is a valid polygon.
+ * Checks for valid data structure, convex polygons, and duplicate 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/poly2.validate
+ */
+export const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid poly2 structure')
+  }
+
+  // check for empty polygon
+  if (object.points.length < 3) {
+    throw new Error(`poly2 not enough points ${object.points.length}`)
+  }
+  // check area
+  if (measureArea(object) <= 0) {
+    throw new Error('poly2 area must be greater than zero')
+  }
+
+  // check for duplicate points
+  for (let i = 0; i < object.points.length; i++) {
+    if (vec2.equals(object.points[i], object.points[(i + 1) % object.points.length])) {
+      throw new Error(`poly2 duplicate point at ${i}: [${object.points[i]}]`)
+    }
+  }
+
+  // check for infinity, nan
+  object.points.forEach((point) => {
+    if (point.length !== 2) {
+      throw new Error(`poly2 invalid point ${point}`)
+    }
+    if (!point.every(Number.isFinite)) {
+      throw new Error(`poly2 invalid point ${point}`)
+    }
+  })
+}

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

@@ -0,0 +1,31 @@
+import test from 'ava'
+
+import { validate, create } from './index.js'
+
+test('validate: identifies polygons', (t) => {
+  const ply1 = create()
+  t.throws(() => validate(ply1), { message: 'poly2 not enough points 0' })
+
+  const ply2 = create([[0, 0], [1, 0], [1, 1]])
+  t.notThrows(() => validate(ply2))
+
+  // Clockwise
+  const ply3 = create([[5, 5], [5, -5], [-5, -5], [-5, 5]])
+  t.throws(() => validate(ply3), { message: 'poly2 area must be greater than zero' })
+
+  // Counterclockwise
+  const ply4 = create([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  t.notThrows(() => validate(ply4))
+
+  // CCW With V-side
+  const ply5 = create([[5, 5], [-5, 5], [0, 0], [-5, -5], [5, -5]])
+  t.notThrows(() => validate(ply5))
+
+  // STAR
+  const ply6 = create([[0, 0], [5, 5], [5, -5], [0, 0], [-5, -5], [-5, 5]])
+  t.throws(() => validate(ply6), { message: 'poly2 area must be greater than zero' })
+
+  // Counterclockwise with duplicate points
+  const ply7 = create([[5, 5], [-5, 5], [-5, 5], [-5, -5], [5, -5]])
+  t.throws(() => validate(ply7), { message: 'poly2 duplicate point at 1: [-5,5]' })
+})

package/src/geometries/poly3/clone.d.ts

@@ -1,6 +1,4 @@
-import Poly3 from './type'
+import type { Poly3 } from './type.d.ts'
 
-export default clone
-
-declare function clone(polygon: Poly3): Poly3
-declare function clone(out: Poly3, polygon: Poly3): Poly3
+export function clone(polygon: Poly3): Poly3
+export function clone(out: Poly3, polygon: Poly3): Poly3

package/src/geometries/poly3/clone.js

@@ -1,16 +1,16 @@
-const create = require('./create')
+import * as vec3 from '../../maths/vec3/index.js'
 
-const vec3 = require('../../maths/vec3')
+import { create } from './create.js'
 
 /**
  * Create a deep clone of the given polygon
  *
- * @param {poly3} [out] - receiving polygon
- * @param {poly3} polygon - polygon to clone
- * @returns {poly3} a new polygon
+ * @param {Poly3} [out] - receiving polygon
+ * @param {Poly3} polygon - polygon to clone
+ * @returns {Poly3} a new polygon
  * @alias module:modeling/geometries/poly3.clone
  */
-const clone = (...params) => {
+export const clone = (...params) => {
   let out
   let poly3
   if (params.length === 1) {
@@ -24,5 +24,3 @@ const clone = (...params) => {
   out.vertices = poly3.vertices.map((vec) => vec3.clone(vec))
   return out
 }
-
-module.exports = clone

package/src/geometries/poly3/clone.test.js

@@ -1,7 +1,8 @@
-const test = require('ava')
-const { create, clone, fromPoints } = require('./index')
+import test from 'ava'
 
-const { comparePolygons } = require('../../../test/helpers/index')
+import { create, clone } from './index.js'
+
+import { comparePolygons } from '../../../test/helpers/index.js'
 
 test('poly3: clone() should return a new poly3 with same values', (t) => {
   const org1 = create()
@@ -9,7 +10,7 @@ test('poly3: clone() should return a new poly3 with same values', (t) => {
   t.true(comparePolygons(ret1, org1))
   t.not(ret1, org1)
 
-  const org2 = fromPoints([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
+  const org2 = create([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
   const ret2 = clone(org2)
   t.true(comparePolygons(ret2, org2))
   t.not(ret2, org2)
@@ -25,7 +26,7 @@ test('poly3: clone() with two params should update a poly3 with same values', (t
   t.not(ret1, org1)
   t.is(ret1, out1)
 
-  const org2 = fromPoints([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
+  const org2 = create([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
   const out2 = create()
   const ret2 = clone(out2, org2)
   t.true(comparePolygons(ret2, org2))

package/src/geometries/poly3/create.d.ts

@@ -1,6 +1,4 @@
-import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import type { Poly3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
 
-export default create
-
-declare function create(vertices?: Array<Vec3>): Poly3
+export function create(vertices?: Array<Vec3>): Poly3

package/src/geometries/poly3/create.js

@@ -1,24 +1,24 @@
-
 /**
  * Represents a convex 3D polygon. The vertices used to initialize a polygon must
  * be coplanar and form a convex shape. The vertices do not have to be `vec3`
  * instances but they must behave similarly.
- * @typedef {Object} poly3
  * @property {Array} vertices - list of ordered vertices (3D)
+ * @example
+ * {"vertices": [[0,0,0], [4,0,0], [4,3,12]]}
  */
 
 /**
  * Creates a new 3D polygon with initial values.
  *
  * @param {Array} [vertices] - a list of vertices (3D)
- * @returns {poly3} a new polygon
+ * @returns {Poly3} a new polygon
  * @alias module:modeling/geometries/poly3.create
+ * @example
+ * const polygon = create([[1, 0], [0, 1], [0, 0]])
  */
-const create = (vertices) => {
+export const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
   return { vertices }
 }
-
-module.exports = create

package/src/geometries/poly3/create.test.js

@@ -1,9 +1,21 @@
-const test = require('ava')
+import test from 'ava'
 
-const { create } = require('./index')
+import { create } from './index.js'
 
-test('poly3: create() should return a poly3 with initial values', (t) => {
+import { comparePolygons } from '../../../test/helpers/index.js'
+
+test('poly3: create() should return an empty poly3', (t) => {
   const obs = create()
   const exp = { vertices: [] }
   t.deepEqual(obs, exp)
 })
+
+test('poly3: create() should return a new poly3 with correct values', (t) => {
+  const exp1 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
+  const obs1 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  t.true(comparePolygons(obs1, exp1))
+
+  const exp2 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 0]] }
+  const obs2 = create([[1, 1, 0], [1, 0, 0], [0, 0, 0]]) // opposite orientation
+  t.true(comparePolygons(obs2, exp2))
+})

package/src/geometries/poly3/fromVerticesAndPlane.d.ts

@@ -0,0 +1,5 @@
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Plane } from '../../maths/plane/type.d.ts'
+import type { Poly3 } from './type.d.ts'
+
+export function fromVerticesAndPlane(vertices: Array<Vec3>, plane: Plane): Poly3

package/src/geometries/poly3/{fromPointsAndPlane.js → fromVerticesAndPlane.js}

@@ -1,17 +1,15 @@
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Create a polygon from the given vertices and plane.
  * NOTE: No checks are performed on the parameters.
  * @param {Array} vertices - list of vertices (3D)
- * @param {plane} plane - plane of the polygon
- * @returns {poly3} a new polygon
- * @alias module:modeling/geometries/poly3.fromPointsAndPlane
+ * @param {Plane} plane - plane of the polygon
+ * @returns {Poly3} a new polygon
+ * @alias module:modeling/geometries/poly3.fromVerticesAndPlane
  */
-const fromPointsAndPlane = (vertices, plane) => {
+export const fromVerticesAndPlane = (vertices, plane) => {
   const poly = create(vertices)
   poly.plane = plane // retain the plane for later use
   return poly
 }
-
-module.exports = fromPointsAndPlane

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

@@ -1,19 +1,17 @@
-export { default as clone } from './clone'
-export { default as create } from './create'
-export { default as fromPoints } from './fromPoints'
-export { default as fromPointsAndPlane } from './fromPointsAndPlane'
-export { default as invert } from './invert'
-export { default as isA } from './isA'
-export { default as isConvex } from './isConvex'
-export { default as measureArea } from './measureArea'
-export { default as measureBoundingBox } from './measureBoundingBox'
-export { default as measureBoundingSphere } from './measureBoundingSphere'
-export { default as measureSignedVolume } from './measureSignedVolume'
-export { default as plane } from './plane'
-export { default as toPoints } from './toPoints'
-export { default as toString } from './toString'
-export { default as transform } from './transform'
-export { default as validate } from './validate'
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromVerticesAndPlane } from './fromVerticesAndPlane.js'
+export { invert } from './invert.js'
+export { isA } from './isA.js'
+export { isConvex } from './isConvex.js'
+export { measureArea } from './measureArea.js'
+export { measureBoundingBox } from './measureBoundingBox.js'
+export { measureBoundingSphere } from './measureBoundingSphere.js'
+export { measureSignedVolume } from './measureSignedVolume.js'
+export { plane } from './plane.js'
+export { toVertices } from './toVertices.js'
+export { toString } from './toString.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
 
-export { default as Poly3 } from './type'
-export as namespace poly3
+export type { Poly3 } from './type.d.ts'

package/src/geometries/poly3/index.js

@@ -4,26 +4,21 @@
  * @module modeling/geometries/poly3
  *
  * @example
- * poly3.create([[0,0,0], [4,0,0], [4,3,12]])
- *
- * @example
- * {"vertices": [[0,0,0], [4,0,0], [4,3,12]]}
+ * import { geometries } from '@jscad/modeling'
+ * const polygon = geometries.poly3.create([[0,0,0], [4,0,0], [4,3,12]])
  */
-module.exports = {
-  clone: require('./clone'),
-  create: require('./create'),
-  fromPoints: require('./fromPoints'),
-  fromPointsAndPlane: require('./fromPointsAndPlane'),
-  invert: require('./invert'),
-  isA: require('./isA'),
-  isConvex: require('./isConvex'),
-  measureArea: require('./measureArea'),
-  measureBoundingBox: require('./measureBoundingBox'),
-  measureBoundingSphere: require('./measureBoundingSphere'),
-  measureSignedVolume: require('./measureSignedVolume'),
-  plane: require('./plane'),
-  toPoints: require('./toPoints'),
-  toString: require('./toString'),
-  transform: require('./transform'),
-  validate: require('./validate')
-}
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromVerticesAndPlane } from './fromVerticesAndPlane.js'
+export { invert } from './invert.js'
+export { isA } from './isA.js'
+export { isConvex } from './isConvex.js'
+export { measureArea } from './measureArea.js'
+export { measureBoundingBox } from './measureBoundingBox.js'
+export { measureBoundingSphere } from './measureBoundingSphere.js'
+export { measureSignedVolume } from './measureSignedVolume.js'
+export { plane } from './plane.js'
+export { toVertices } from './toVertices.js'
+export { toString } from './toString.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

package/src/geometries/poly3/invert.d.ts

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

package/src/geometries/poly3/invert.js

@@ -1,14 +1,15 @@
-const plane = require('../../maths/plane')
-const create = require('./create')
+import * as plane from '../../maths/plane/index.js'
+
+import { create } from './create.js'
 
 /**
  * Invert the give polygon to face the opposite direction.
  *
- * @param {poly3} polygon - the polygon to invert
- * @returns {poly3} a new poly3
+ * @param {Poly3} polygon - the polygon to invert
+ * @returns {Poly3} a new poly3
  * @alias module:modeling/geometries/poly3.invert
  */
-const invert = (polygon) => {
+export const invert = (polygon) => {
   const vertices = polygon.vertices.slice().reverse()
   const inverted = create(vertices)
   if (polygon.plane) {
@@ -17,5 +18,3 @@ const invert = (polygon) => {
   }
   return inverted
 }
-
-module.exports = invert

package/src/geometries/poly3/invert.test.js

@@ -1,17 +1,17 @@
-const test = require('ava')
+import test from 'ava'
 
-const { invert, fromPoints } = require('./index')
+import { create, invert } from './index.js'
 
-const { comparePolygons } = require('../../../test/helpers/index')
+import { comparePolygons } from '../../../test/helpers/index.js'
 
 test('poly3: invert() should return a new poly3 with correct values', (t) => {
   const exp1 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 0]] }
-  const org1 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const org1 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   const ret1 = invert(org1)
   t.true(comparePolygons(ret1, exp1))
 
   const exp2 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
-  const org2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
+  const org2 = create([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
   const ret2 = invert(org2)
   t.true(comparePolygons(ret2, exp2))
   t.false(comparePolygons(ret2, org2)) // the original should NOT change

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

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

package/src/geometries/poly3/isA.js

@@ -1,10 +1,10 @@
 /**
  * Determine if the given object is a polygon.
- * @param {Object} object - the object to interrogate
+ * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a poly3
  * @alias module:modeling/geometries/poly3.isA
  */
-const isA = (object) => {
+export const isA = (object) => {
   if (object && typeof object === 'object') {
     if ('vertices' in object) {
       if (Array.isArray(object.vertices)) {
@@ -14,5 +14,3 @@ const isA = (object) => {
   }
   return false
 }
-
-module.exports = isA

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

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isA, create, fromPoints } = require('./index')
+import { isA, create } from './index.js'
 
 test('isA: identifies created poly3', (t) => {
   const p1 = create()
-  const p2 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const p2 = create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
   t.true(isA(p1))
   t.true(isA(p2))
 })

package/src/geometries/poly3/isConvex.d.ts

@@ -1,5 +1,3 @@
-import Poly3 from './type'
+import type { Poly3 } from './type.d.ts'
 
-export default isConvex
-
-declare function isConvex(polygon: Poly3): boolean
+export function isConvex(polygon: Poly3): boolean

package/src/geometries/poly3/isConvex.js

@@ -1,44 +1,42 @@
-const plane = require('../../maths/plane')
-const vec3 = require('../../maths/vec3')
+import * as plane from '../../maths/plane/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
 /**
  * Check whether the given polygon is convex.
- * @param {poly3} polygon - the polygon to interrogate
+ * @param {Poly3} polygon - the polygon to interrogate
  * @returns {Boolean} true if convex
  * @alias module:modeling/geometries/poly3.isConvex
  */
-const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
+export const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
 
 const areVerticesConvex = (vertices) => {
-  const numvertices = vertices.length
-  if (numvertices > 2) {
-    // note: plane ~= normal point
+  const numVertices = vertices.length
+  if (numVertices > 2) {
+    // note: plane ~= normal vertex
     const normal = plane.fromPoints(plane.create(), ...vertices)
-    let prevprevpos = vertices[numvertices - 2]
-    let prevpos = vertices[numvertices - 1]
-    for (let i = 0; i < numvertices; i++) {
+    let prevPrevPos = vertices[numVertices - 2]
+    let prevPos = vertices[numVertices - 1]
+    for (let i = 0; i < numVertices; i++) {
       const pos = vertices[i]
-      if (!isConvexPoint(prevprevpos, prevpos, pos, normal)) {
+      if (!isConvexVertex(prevPrevPos, prevPos, pos, normal)) {
         return false
       }
-      prevprevpos = prevpos
-      prevpos = pos
+      prevPrevPos = prevPos
+      prevPos = pos
     }
   }
   return true
 }
 
-// calculate whether three points form a convex corner
-//  prevpoint, point, nextpoint: the 3 coordinates (Vector3D instances)
+// calculate whether three vertices form a convex corner
+//  prevVertex, vertex, nextVertex: the 3 coordinates (Vector3D instances)
 //  normal: the normal vector of the plane
-const isConvexPoint = (prevpoint, point, nextpoint, normal) => {
-  const crossproduct = vec3.cross(
+const isConvexVertex = (prevVertex, vertex, nextVertex, normal) => {
+  const crossProduct = vec3.cross(
     vec3.create(),
-    vec3.subtract(vec3.create(), point, prevpoint),
-    vec3.subtract(vec3.create(), nextpoint, point)
+    vec3.subtract(vec3.create(), vertex, prevVertex),
+    vec3.subtract(vec3.create(), nextVertex, vertex)
   )
-  const crossdotnormal = vec3.dot(crossproduct, normal)
-  return crossdotnormal >= 0
+  const crossDotNormal = vec3.dot(crossProduct, normal)
+  return crossDotNormal >= 0
 }
-
-module.exports = isConvex

package/src/geometries/poly3/isConvex.test.js

@@ -1,24 +1,24 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isConvex, create, fromPoints } = require('./index')
+import { create, isConvex } from './index.js'
 
 test('poly3: isConvex() should return correct values', (t) => {
   const ply1 = create()
   t.true(isConvex(ply1))
 
-  const ply2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
+  const ply2 = create([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
   t.true(isConvex(ply2))
 
-  const points2ccw = [[0, 0, 3], [10, 10, 3], [0, 5, 3]]
-  const ply3 = fromPoints(points2ccw)
+  const vertices2ccw = [[0, 0, 3], [10, 10, 3], [0, 5, 3]]
+  const ply3 = create(vertices2ccw)
   t.true(isConvex(ply3))
 
-  const points2cw = [[0, 0, 3], [-10, 10, 3], [0, 5, 3]]
-  const ply4 = fromPoints(points2cw)
+  const vertices2cw = [[0, 0, 3], [-10, 10, 3], [0, 5, 3]]
+  const ply4 = create(vertices2cw)
   t.true(isConvex(ply4))
 
   // V-shape
-  const pointsV = [[0, 0, 3], [-10, 10, 3], [0, 5, 3], [10, 10, 3]]
-  const ply5 = fromPoints(pointsV)
+  const verticesV = [[0, 0, 3], [-10, 10, 3], [0, 5, 3], [10, 10, 3]]
+  const ply5 = create(verticesV)
   t.false(isConvex(ply5))
 })

package/src/geometries/poly3/measureArea.d.ts

@@ -1,5 +1,3 @@
-import Poly3 from './type'
+import type { Poly3 } from './type.d.ts'
 
-export default measureArea
-
-declare function measureArea(polygon: Poly3): number
+export function measureArea(polygon: Poly3): number