@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/primitives/roundedCylinder.js

@@ -1,29 +1,30 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
+import { sin, cos } from '../maths/utils/trigonometry.js'
 
-const vec3 = require('../maths/vec3')
+import * as vec3 from '../maths/vec3/index.js'
 
-const geom3 = require('../geometries/geom3')
-const poly3 = require('../geometries/poly3')
+import * as geom3 from '../geometries/geom3/index.js'
+import * as poly3 from '../geometries/poly3/index.js'
 
-const { sin, cos } = require('../maths/utils/trigonometry')
+import { isGTE, isNumberArray } from './commonChecks.js'
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+import { cylinder } from './cylinder.js'
 
 /**
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
- * @param {Number} [options.height=2] - height of cylinder
- * @param {Number} [options.radius=1] - radius of cylinder
- * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom3} new 3D geometry
+ * @param {number} [options.height=2] - height of cylinder
+ * @param {number} [options.radius=1] - radius of cylinder
+ * @param {number} [options.roundRadius=0.2] - radius of rounded edges
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.roundedCylinder
  *
  * @example
  * let myshape = roundedCylinder({ height: 10, radius: 2, roundRadius: 0.5 })
  */
-const roundedCylinder = (options) => {
+export const roundedCylinder = (options) => {
   const defaults = {
     center: [0, 0, 0],
     height: 2,
@@ -34,12 +35,18 @@ const roundedCylinder = (options) => {
   const { center, height, radius, roundRadius, segments } = Object.assign({}, defaults, options)
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
-  if (!isGT(height, 0)) throw new Error('height must be greater then zero')
-  if (!isGT(radius, 0)) throw new Error('radius must be greater then zero')
-  if (!isGT(roundRadius, 0)) throw new Error('roundRadius must be greater then zero')
-  if (roundRadius > (radius - EPS)) throw new Error('roundRadius must be smaller then the radius')
+  if (!isGTE(height, 0)) throw new Error('height must be positive')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+  if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
+  if (roundRadius > radius) throw new Error('roundRadius must be smaller then the radius')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if size is zero return empty geometry
+  if (height === 0 || radius === 0) return geom3.create()
+
+  // if roundRadius is zero, return cylinder
+  if (roundRadius === 0) return cylinder({ center, height, radius })
+
   const start = [0, 0, -(height / 2)]
   const end = [0, 0, height / 2]
   const direction = vec3.subtract(vec3.create(), end, start)
@@ -47,94 +54,91 @@ const roundedCylinder = (options) => {
 
   if ((2 * roundRadius) > (length - EPS)) throw new Error('height must be larger than twice roundRadius')
 
-  let defaultnormal
+  let defaultNormal
   if (Math.abs(direction[0]) > Math.abs(direction[1])) {
-    defaultnormal = vec3.fromValues(0, 1, 0)
+    defaultNormal = vec3.fromValues(0, 1, 0)
   } else {
-    defaultnormal = vec3.fromValues(1, 0, 0)
+    defaultNormal = vec3.fromValues(1, 0, 0)
   }
 
-  const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), direction), roundRadius)
-  const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), zvector, defaultnormal)), radius)
-  const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), xvector, zvector)), radius)
+  const zVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), direction), roundRadius)
+  const xVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), zVector, defaultNormal)), radius)
+  const yVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), xVector, zVector)), radius)
 
-  vec3.add(start, start, zvector)
-  vec3.subtract(end, end, zvector)
+  vec3.add(start, start, zVector)
+  vec3.subtract(end, end, zVector)
 
-  const qsegments = Math.floor(0.25 * segments)
+  const qSegments = Math.floor(0.25 * segments)
 
-  const fromPoints = (points) => {
-    // adjust the points to center
-    const newpoints = points.map((point) => vec3.add(point, point, center))
-    return poly3.create(newpoints)
+  const fromVertices = (vertices) => {
+    // adjust the vertices to center
+    const newVertices = vertices.map((vertex) => vec3.add(vertex, vertex, center))
+    return poly3.create(newVertices)
   }
 
   const polygons = []
   const v1 = vec3.create()
   const v2 = vec3.create()
-  let prevcylinderpoint
+  let prevCylinderVertex
   for (let slice1 = 0; slice1 <= segments; slice1++) {
     const angle = TAU * slice1 / segments
-    const cylinderpoint = vec3.add(vec3.create(), vec3.scale(v1, xvector, cos(angle)), vec3.scale(v2, yvector, sin(angle)))
+    const cylinderVertex = vec3.add(vec3.create(), vec3.scale(v1, xVector, cos(angle)), vec3.scale(v2, yVector, sin(angle)))
     if (slice1 > 0) {
       // cylinder wall
-      let points = []
-      points.push(vec3.add(vec3.create(), start, cylinderpoint))
-      points.push(vec3.add(vec3.create(), start, prevcylinderpoint))
-      points.push(vec3.add(vec3.create(), end, prevcylinderpoint))
-      points.push(vec3.add(vec3.create(), end, cylinderpoint))
-      polygons.push(fromPoints(points))
-
-      let prevcospitch, prevsinpitch
-      for (let slice2 = 0; slice2 <= qsegments; slice2++) {
-        const pitch = TAU / 4 * slice2 / qsegments
-        const cospitch = cos(pitch)
-        const sinpitch = sin(pitch)
+      let vertices = []
+      vertices.push(vec3.add(vec3.create(), start, cylinderVertex))
+      vertices.push(vec3.add(vec3.create(), start, prevCylinderVertex))
+      vertices.push(vec3.add(vec3.create(), end, prevCylinderVertex))
+      vertices.push(vec3.add(vec3.create(), end, cylinderVertex))
+      polygons.push(fromVertices(vertices))
+
+      let prevCosPitch, prevSinPitch
+      let vertex
+      for (let slice2 = 0; slice2 <= qSegments; slice2++) {
+        const pitch = TAU / 4 * slice2 / qSegments
+        const cosPitch = cos(pitch)
+        const sinPitch = sin(pitch)
         if (slice2 > 0) {
           // cylinder rounding, start
-          points = []
-          let point
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevcylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch)))
-          points.push(point)
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch)))
-          points.push(point)
-          if (slice2 < qsegments) {
-            point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch)))
-            points.push(point)
+          vertices = []
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevCylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch)))
+          vertices.push(vertex)
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch)))
+          vertices.push(vertex)
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch)))
+            vertices.push(vertex)
           }
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevcylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch)))
-          points.push(point)
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevCylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch)))
+          vertices.push(vertex)
 
-          polygons.push(fromPoints(points))
+          polygons.push(fromVertices(vertices))
 
           // cylinder rounding, end
-          points = []
-          point = vec3.add(vec3.create(), vec3.scale(v1, prevcylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          point = vec3.add(vec3.create(), vec3.scale(v1, cylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          if (slice2 < qsegments) {
-            point = vec3.add(vec3.create(), vec3.scale(v1, cylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch))
-            vec3.add(point, point, end)
-            points.push(point)
+          vertices = []
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, prevCylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, cylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vec3.create(), vec3.scale(v1, cylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch))
+            vec3.add(vertex, vertex, end)
+            vertices.push(vertex)
           }
-          point = vec3.add(vec3.create(), vec3.scale(v1, prevcylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          points.reverse()
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, prevCylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          vertices.reverse()
 
-          polygons.push(fromPoints(points))
+          polygons.push(fromVertices(vertices))
         }
-        prevcospitch = cospitch
-        prevsinpitch = sinpitch
+        prevCosPitch = cosPitch
+        prevSinPitch = sinPitch
       }
     }
-    prevcylinderpoint = cylinderpoint
+    prevCylinderVertex = cylinderVertex
   }
-  const result = geom3.create(polygons)
-  return result
+  return geom3.create(polygons)
 }
-
-module.exports = roundedCylinder

package/src/primitives/roundedCylinder.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { roundedCylinder } = require('./index')
+import { roundedCylinder } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCylinder (defaults)', (t) => {
   const obs = roundedCylinder()
@@ -14,6 +14,27 @@ test('roundedCylinder (defaults)', (t) => {
   t.is(pts.length, 544)
 })
 
+test('roundedCylinder (zero height)', (t) => {
+  const obs = roundedCylinder({ height: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('roundedCylinder (zero radius)', (t) => {
+  const obs = roundedCylinder({ radius: 0, roundRadius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('roundedCylinder (zero roundRadius)', (t) => {
+  const obs = roundedCylinder({ roundRadius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 96)
+})
+
 test('roundedCylinder (options)', (t) => {
   // test segments
   let obs = roundedCylinder({ segments: 5 })

package/src/primitives/roundedRectangle.d.ts

@@ -1,7 +1,5 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default roundedRectangle
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface RoundedRectangleOptions {
   center?: Vec2
@@ -10,4 +8,4 @@ export interface RoundedRectangleOptions {
   segments?: number
 }
 
-declare function roundedRectangle(options?: RoundedRectangleOptions): Geom2
+export function roundedRectangle(options?: RoundedRectangleOptions): Geom2

package/src/primitives/roundedRectangle.js

@@ -1,25 +1,27 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
 
-const vec2 = require('../maths/vec2')
+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 { isGTE, isNumberArray } from './commonChecks.js'
+
+import { rectangle } from './rectangle.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with rounded corners.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rounded rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rounded rectangle; width and length
- * @param {Number} [options.roundRadius=0.2] - round radius of corners
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.roundRadius=0.2] - round radius of corners
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.roundedRectangle
  *
  * @example
  * let myshape = roundedRectangle({size: [10, 20], roundRadius: 2})
  */
-const roundedRectangle = (options) => {
+export const roundedRectangle = (options) => {
   const defaults = {
     center: [0, 0],
     size: [2, 2],
@@ -30,16 +32,22 @@ const roundedRectangle = (options) => {
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
-  if (!isGT(roundRadius, 0)) throw new Error('roundRadius must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+  if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0) return geom2.create()
+
+  // if roundRadius is zero, return rectangle
+  if (roundRadius === 0) return rectangle({ center, size })
+
   size = size.map((v) => v / 2) // convert to radius
 
   if (roundRadius > (size[0] - EPS) ||
       roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller then the radius of all dimensions')
 
-  const cornersegments = Math.floor(segments / 4)
+  const cornerSegments = Math.floor(segments / 4)
 
   // create sets of points that define the corners
   const corner0 = vec2.add(vec2.create(), center, [size[0] - roundRadius, size[1] - roundRadius])
@@ -50,8 +58,8 @@ const roundedRectangle = (options) => {
   const corner1Points = []
   const corner2Points = []
   const corner3Points = []
-  for (let i = 0; i <= cornersegments; i++) {
-    const radians = TAU / 4 * i / cornersegments
+  for (let i = 0; i <= cornerSegments; i++) {
+    const radians = TAU / 4 * i / cornerSegments
     const point = vec2.fromAngleRadians(vec2.create(), radians)
     vec2.scale(point, point, roundRadius)
     corner0Points.push(vec2.add(vec2.create(), corner0, point))
@@ -63,7 +71,6 @@ const roundedRectangle = (options) => {
     corner3Points.push(vec2.add(vec2.create(), corner3, point))
   }
 
-  return geom2.fromPoints(corner0Points.concat(corner1Points, corner2Points, corner3Points))
+  const points = corner0Points.concat(corner1Points, corner2Points, corner3Points)
+  return geom2.create([points])
 }
-
-module.exports = roundedRectangle

package/src/primitives/roundedRectangle.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { roundedRectangle } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { roundedRectangle } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('roundedRectangle (defaults)', (t) => {
   const geometry = roundedRectangle()
@@ -14,6 +14,20 @@ test('roundedRectangle (defaults)', (t) => {
   t.deepEqual(obs.length, 36)
 })
 
+test('roundedRectangle (zero size)', (t) => {
+  const obs = roundedRectangle({ size: [1, 0] })
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('roundedRectangle (zero radius)', (t) => {
+  const obs = roundedRectangle({ roundRadius: 0 })
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.deepEqual(pts.length, 4)
+})
+
 test('roundedRectangle (options)', (t) => {
   // test center
   let geometry = roundedRectangle({ center: [4, 5], segments: 16 })

package/src/primitives/sphere.d.ts

@@ -1,7 +1,5 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default sphere
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface SphereOptions {
   center?: Vec3
@@ -10,4 +8,4 @@ export interface SphereOptions {
   axes?: Vec3
 }
 
-declare function sphere(options?: SphereOptions): Geom3
+export function sphere(options?: SphereOptions): Geom3

package/src/primitives/sphere.js

@@ -1,22 +1,21 @@
-const ellipsoid = require('./ellipsoid')
-
-const { isGT } = require('./commonChecks')
+import { ellipsoid } from './ellipsoid.js'
+import { isGTE } from './commonChecks.js'
 
 /**
- * Construct a sphere in three dimensional space where all points are at the same distance from the center.
+ * Construct a sphere in three dimensional space where all vertices are at the same distance from the center.
  * @see [ellipsoid]{@link module:modeling/primitives.ellipsoid} for more options
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of sphere
- * @param {Number} [options.radius=1] - radius of sphere
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @param {number} [options.radius=1] - radius of sphere
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
  * @param {Array} [options.axes] -  an array with three vectors for the x, y and z base vectors
- * @returns {geom3} new 3D geometry
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.sphere
  *
  * @example
  * let myshape = sphere({radius: 5})
  */
-const sphere = (options) => {
+export const sphere = (options) => {
   const defaults = {
     center: [0, 0, 0],
     radius: 1,
@@ -25,11 +24,9 @@ const sphere = (options) => {
   }
   let { center, radius, segments, axes } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 
   radius = [radius, radius, radius]
 
   return ellipsoid({ center, radius, segments, axes })
 }
-
-module.exports = sphere

package/src/primitives/sphere.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { sphere } = require('./index')
+import { sphere } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('sphere (defaults)', (t) => {
   const obs = sphere()
@@ -163,3 +163,10 @@ test('sphere (options)', (t) => {
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('sphere (zero radius)', (t) => {
+  const obs = sphere({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/square.d.ts

@@ -1,11 +1,9 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default square
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface SquareOptions {
   center?: Vec2
   size?: number
 }
 
-declare function square(options?: SquareOptions): Geom2
+export function square(options?: SquareOptions): Geom2

package/src/primitives/square.js

@@ -1,31 +1,28 @@
-const rectangle = require('./rectangle')
-
-const { isGT } = require('./commonChecks')
+import { rectangle } from './rectangle.js'
+import { isGTE } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned square in two dimensional space with four equal sides at right angles.
  * @see [rectangle]{@link module:modeling/primitives.rectangle} for more options
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of square
- * @param {Number} [options.size=2] - dimension of square
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.size=2] - dimension of square
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.square
  *
  * @example
  * let myshape = square({size: 10})
  */
-const square = (options) => {
+export const square = (options) => {
   const defaults = {
     center: [0, 0],
     size: 2
   }
   let { center, size } = Object.assign({}, defaults, options)
 
-  if (!isGT(size, 0)) throw new Error('size must be greater than zero')
+  if (!isGTE(size, 0)) throw new Error('size must be positive')
 
   size = [size, size]
 
   return rectangle({ center, size })
 }
-
-module.exports = square

package/src/primitives/square.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { square } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { square } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('square (defaults)', (t) => {
   const geometry = square()
@@ -42,3 +42,10 @@ test('square (options)', (t) => {
   t.is(pts.length, 4)
   t.true(comparePoints(pts, exp))
 })
+
+test('square (zero size)', (t) => {
+  const geometry = square({ size: 0 })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})

package/src/primitives/star.d.ts

@@ -1,7 +1,5 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default star
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface StarOptions {
   center?: Vec2
@@ -12,4 +10,4 @@ export interface StarOptions {
   startAngle?: number
 }
 
-declare function star(options?: StarOptions): Geom2
+export function star(options?: StarOptions): Geom2