@jscad/modeling 3.0.0-alpha.0 → 3.0.1-alpha.0

package/src/operations/offsets/offsetGeom2.test.js

@@ -61,6 +61,7 @@ test('offset: offset of a geom2 produces expected changes to points', (t) => {
     [-10, -8]
   ]
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 395.3137084989848)
   t.is(pts.length, 12)
   t.true(comparePoints(pts, exp))
 })

package/src/operations/offsets/offsetGeom3.js

@@ -1,5 +1,3 @@
-import * as geom3 from '../../geometries/geom3/index.js'
-
 import { union } from '../booleans/union.js'
 
 import { offsetShell } from './offsetShell.js'

package/src/operations/offsets/offsetGeom3.test.js

@@ -3,8 +3,11 @@ import test from 'ava'
 import { comparePoints } from '../../../test/helpers/index.js'
 
 import { colorize } from '../../colors/index.js'
+
 import { geom3, poly3 } from '../../geometries/index.js'
-import { measureVolume } from '../../measurements/index.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
 import { cube, sphere } from '../../primitives/index.js'
 
 import { offset } from './index.js'
@@ -13,6 +16,7 @@ test('offset: offset empty geom3', (t) => {
   const geometry = geom3.create()
   const result = offset({ }, geometry)
   t.notThrows(() => geom3.validate(result))
+  t.is(measureArea(result), 0)
   t.is(measureVolume(result), 0)
   t.is(geom3.toPolygons(result).length, 0)
   t.is(geom3.toPoints(result).length, 0)
@@ -50,6 +54,8 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
   ]
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 3178.8059464475555)
+  t.is(measureVolume(obs), 13504.574121271067)
   t.is(pts.length, 62)
   t.true(comparePoints(pts[0], exp0))
   t.true(comparePoints(pts[61], exp61))
@@ -58,6 +64,8 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
   const obs2 = offset({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
   t.notThrows.skip(() => geom3.validate(obs2))
+  t.is(measureArea(obs), 3178.8059464475555)
+  t.is(measureVolume(obs), 13504.574121271067)
   t.is(pts2.length, 864)
 })
 

package/src/operations/offsets/offsetPath2.js

@@ -85,9 +85,9 @@ export const offsetPath2 = (options, geometry) => {
     internal: offsetFromPoints({ delta: -delta, corners, segments, closed }, points)
   }
 
-  const output = geometry.isClosed ?
-    createGeometryFromClosedPath(paths) :
-    createGeometryFromOpenPath(paths, segments, corners, delta)
+  const output = geometry.isClosed
+    ? createGeometryFromClosedPath(paths)
+    : createGeometryFromOpenPath(paths, segments, corners, delta)
   if (geometry.color) output.color = geometry.color
   return output
 }

package/src/operations/transforms/align.js

@@ -1,4 +1,6 @@
-import { flatten } from '../../utils/flatten.js'
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { coalesce } from '../../utils/coalesce.js'
 import { padArrayToLength } from '../../utils/padArrayToLength.js'
 
 import { measureAggregateBoundingBox } from '../../measurements/measureAggregateBoundingBox.js'
@@ -34,9 +36,9 @@ const populateRelativeToFromBounds = (relativeTo, modes, bounds) => {
   return relativeTo
 }
 
-const alignGeometries = (geometry, modes, relativeTo) => {
-  const bounds = measureAggregateBoundingBox(geometry)
-  const translation = [0, 0, 0]
+const alignGeometries = (geometries, modes, relativeTo) => {
+  const bounds = measureAggregateBoundingBox(geometries)
+  const translation = vec3.create()
   for (let i = 0; i < 3; i++) {
     if (modes[i] === 'center') {
       translation[i] = relativeTo[i] - (bounds[0][i] + bounds[1][i]) / 2
@@ -47,7 +49,7 @@ const alignGeometries = (geometry, modes, relativeTo) => {
     }
   }
 
-  return translate(translation, geometry)
+  return translate(translation, geometries)
 }
 
 /**
@@ -73,14 +75,13 @@ export const align = (options, ...geometries) => {
 
   options = validateOptions(options)
   let { modes, relativeTo, grouped } = options
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('align(): No geometries were provided to act upon')
 
   if (relativeTo.filter((val) => val == null).length) {
     const bounds = measureAggregateBoundingBox(geometries)
     relativeTo = populateRelativeToFromBounds(relativeTo, modes, bounds)
   }
   if (grouped) {
+    geometries = coalesce(geometries)
     geometries = alignGeometries(geometries, modes, relativeTo)
   } else {
     geometries = geometries.map((geometry) => alignGeometries(geometry, modes, relativeTo))

package/src/operations/transforms/align.test.js

@@ -53,7 +53,7 @@ test('align: multiple objects ungrouped returns geometry aligned, different mode
     cube({ size: 4, center: [10, 10, 10] }),
     cube({ size: 2, center: [4, 4, 4] })
   ]
-  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [30, 30, 30] }, original)
+  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [30, 30, 30] }, ...original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[28, 30, 26], [32, 34, 30]]
   t.notThrows(() => geom3.validate(aligned[0]))
@@ -79,7 +79,7 @@ test('align: multiple objects ungrouped, relativeTo is nulls, returns geometry a
     cube({ size: 2, center: [4, 4, 4] }),
     cube({ size: 4, center: [10, 10, 10] })
   ]
-  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, original)
+  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, ...original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[5.5, 3, 8], [9.5, 7, 12]]
   t.notThrows(() => geom3.validate(aligned[0]))

package/src/operations/transforms/center.js

@@ -1,10 +1,8 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
 
-import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
+import { measureAggregateBoundingBox } from '../../measurements/measureAggregateBoundingBox.js'
 
 import { translate } from './translate.js'
 
@@ -15,7 +13,7 @@ const centerGeometry = (options, object) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  const bounds = measureBoundingBox(object)
+  const bounds = measureAggregateBoundingBox(object)
   const offset = [0, 0, 0]
   if (axes[0]) offset[0] = relativeTo[0] - (bounds[0][0] + ((bounds[1][0] - bounds[0][0]) / 2))
   if (axes[1]) offset[1] = relativeTo[1] - (bounds[0][1] + ((bounds[1][1] - bounds[0][1]) / 2))
@@ -43,8 +41,6 @@ export const center = (options, ...objects) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
   if (relativeTo.length !== 3) throw new Error('relativeTo must be an array of length 3')
 
   options = { axes, relativeTo }
@@ -53,6 +49,7 @@ export const center = (options, ...objects) => {
     if (path2.isA(object)) return centerGeometry(options, object)
     if (geom2.isA(object)) return centerGeometry(options, object)
     if (geom3.isA(object)) return centerGeometry(options, object)
+    if (Array.isArray(object)) return centerGeometry(options, object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -64,7 +61,7 @@ export const center = (options, ...objects) => {
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerX
  */
-export const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
+export const centerX = (...objects) => center({ axes: [true, false, false] }, ...objects)
 
 /**
  * Center the given objects about the Y axis.
@@ -72,7 +69,7 @@ export const centerX = (...objects) => center({ axes: [true, false, false] }, ob
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerY
  */
-export const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
+export const centerY = (...objects) => center({ axes: [false, true, false] }, ...objects)
 
 /**
  * Center the given objects about the Z axis.
@@ -80,4 +77,4 @@ export const centerY = (...objects) => center({ axes: [false, true, false] }, ob
  * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerZ
  */
-export const centerZ = (...objects) => center({ axes: [false, false, true] }, objects)
+export const centerZ = (...objects) => center({ axes: [false, false, true] }, ...objects)

package/src/operations/transforms/center.test.js

@@ -4,7 +4,9 @@ import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/in
 
 import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-import { measureArea, measureVolume } from '../../measurements/index.js'
+import { measureArea, measureAggregateBoundingBox, measureVolume } from '../../measurements/index.js'
+
+import { square } from '../../primitives/index.js'
 
 import { center, centerX, centerY, centerZ } from './index.js'
 
@@ -136,3 +138,19 @@ test('center: centering of multiple objects produces expected changes', (t) => {
   t.notThrows(() => geom2.validate(centered[2]))
   t.true(comparePoints(pts2, exp2))
 })
+
+test('center multiple separate', (t) => {
+  const square1 = square({ size: 4, center: [10, 10] })
+  const square2 = square({ size: 6, center: [-10, -10] })
+  const obs = center({}, square1, square2)
+  t.notThrows(() => obs.map(geom2.validate))
+  t.deepEqual([[-3, -3, 0], [3, 3, 0]], measureAggregateBoundingBox(obs))
+})
+
+test('center multiple grouped', (t) => {
+  const square1 = square({ size: 4, center: [10, 10] })
+  const square2 = square({ size: 6, center: [-10, -10] })
+  const obs = center({}, [square1, square2])
+  t.notThrows(() => obs.map(geom2.validate))
+  t.deepEqual([[-12.5, -12.5, 0], [12.5, 12.5, 0]], measureAggregateBoundingBox(obs))
+})

package/src/operations/transforms/mirror.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 import * as plane from '../../maths/plane/index.js'
 
@@ -26,9 +24,6 @@ export const mirror = (options, ...objects) => {
   }
   const { origin, normal } = Object.assign({}, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const planeOfMirror = plane.fromNormalAndPoint(plane.create(), normal, origin)
   // verify the plane, i.e. check that the given normal was valid
   if (Number.isNaN(planeOfMirror[0])) {
@@ -41,6 +36,8 @@ export const mirror = (options, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return mirror(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -52,7 +49,7 @@ export const mirror = (options, ...objects) => {
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorX
  */
-export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
+export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, ...objects)
 
 /**
  * Mirror the given objects about the Y axis.
@@ -60,7 +57,7 @@ export const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorY
  */
-export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
+export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, ...objects)
 
 /**
  * Mirror the given objects about the Z axis.
@@ -68,4 +65,4 @@ export const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
  * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorZ
  */
-export const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, objects)
+export const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, ...objects)

package/src/operations/transforms/mirror.test.js

@@ -42,29 +42,29 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
-  let exp = [[5, -5], [0, 5], [-10, -5]]
+  let exp = [[-10, -5], [0, 5], [5, -5]]
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = geom2.toPoints(mirrored)
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[10, 5], [0, -5], [-5, 5]]
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
-  t.is(measureArea(mirrored), -measureArea(geometry))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -158,7 +158,7 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[10, 5], [0, -5], [-5, 5]]
   t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/operations/transforms/rotate.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -19,9 +17,6 @@ import * as path2 from '../../geometries/path2/index.js'
 export const rotate = (angles, ...objects) => {
   if (!Array.isArray(angles)) throw new Error('angles must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the angles if necessary
   angles = angles.slice() // don't modify the original
   while (angles.length < 3) angles.push(0)
@@ -36,6 +31,8 @@ export const rotate = (angles, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return rotate(angles, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -48,7 +45,7 @@ export const rotate = (angles, ...objects) => {
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateX
  */
-export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
+export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], ...objects)
 
 /**
  * Rotate the given objects about the Y axis, using the given options.
@@ -57,7 +54,7 @@ export const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateY
  */
-export const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
+export const rotateY = (angle, ...objects) => rotate([0, angle, 0], ...objects)
 
 /**
  * Rotate the given objects about the Z axis, using the given options.
@@ -66,4 +63,4 @@ export const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
  * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateZ
  */
-export const rotateZ = (angle, ...objects) => rotate([0, 0, angle], objects)
+export const rotateZ = (angle, ...objects) => rotate([0, 0, angle], ...objects)

package/src/operations/transforms/scale.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -19,9 +17,6 @@ import * as path2 from '../../geometries/path2/index.js'
 export const scale = (factors, ...objects) => {
   if (!Array.isArray(factors)) throw new Error('factors must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the factors if necessary
   factors = factors.slice() // don't modify the original
   while (factors.length < 3) factors.push(1)
@@ -34,6 +29,8 @@ export const scale = (factors, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return scale(factors, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -46,7 +43,7 @@ export const scale = (factors, ...objects) => {
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleX
  */
-export const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
+export const scaleX = (factor, ...objects) => scale([factor, 1, 1], ...objects)
 
 /**
  * Scale the given objects about the Y axis using the given options.
@@ -55,7 +52,7 @@ export const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleY
  */
-export const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
+export const scaleY = (factor, ...objects) => scale([1, factor, 1], ...objects)
 
 /**
  * Scale the given objects about the Z axis using the given options.
@@ -64,4 +61,4 @@ export const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
  * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleZ
  */
-export const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)
+export const scaleZ = (factor, ...objects) => scale([1, 1, factor], ...objects)

package/src/operations/transforms/transform.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
@@ -17,13 +15,12 @@ import * as path2 from '../../geometries/path2/index.js'
 export const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return transform(matrix, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/transforms/translate.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as mat4 from '../../maths/mat4/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -19,9 +17,6 @@ import * as path2 from '../../geometries/path2/index.js'
 export const translate = (offset, ...objects) => {
   if (!Array.isArray(offset)) throw new Error('offset must be an array')
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   // adjust the offset if necessary
   offset = offset.slice() // don't modify the original
   while (offset.length < 3) offset.push(0)
@@ -32,6 +27,8 @@ export const translate = (offset, ...objects) => {
     if (path2.isA(object)) return path2.transform(matrix, object)
     if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    // handle recursive arrays
+    if (Array.isArray(object)) return translate(offset, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results
@@ -44,7 +41,7 @@ export const translate = (offset, ...objects) => {
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateX
  */
-export const translateX = (offset, ...objects) => translate([offset, 0, 0], objects)
+export const translateX = (offset, ...objects) => translate([offset, 0, 0], ...objects)
 
 /**
  * Translate the given objects along the Y axis using the given options.
@@ -53,7 +50,7 @@ export const translateX = (offset, ...objects) => translate([offset, 0, 0], obje
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateY
  */
-export const translateY = (offset, ...objects) => translate([0, offset, 0], objects)
+export const translateY = (offset, ...objects) => translate([0, offset, 0], ...objects)
 
 /**
  * Translate the given objects along the Z axis using the given options.
@@ -62,4 +59,4 @@ export const translateY = (offset, ...objects) => translate([0, offset, 0], obje
  * @return {Object|Array} the translated object, or a list of translated objects
  * @alias module:modeling/transforms.translateZ
  */
-export const translateZ = (offset, ...objects) => translate([0, 0, offset], objects)
+export const translateZ = (offset, ...objects) => translate([0, 0, offset], ...objects)

package/src/primitives/arc.js

@@ -17,6 +17,8 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
  * @param {boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
  * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.arc
+ * @example
+ * let myshape = arc({ center: [-1, -1], radius: 2, endAngle: (TAU / 4)})
  */
 export const arc = (options) => {
   const defaults = {

package/src/primitives/arc.test.js

@@ -13,7 +13,7 @@ test('arc (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 33)
+  t.is(obs.length, 33)
 })
 
 test('arc (options)', (t) => {
@@ -41,7 +41,7 @@ test('arc (options)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
   // test radius
@@ -68,7 +68,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 17)
+  t.is(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
   // test startAngle
@@ -92,7 +92,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 14)
+  t.is(obs.length, 14)
   t.true(comparePoints(obs, exp))
 
   // test endAngle
@@ -108,7 +108,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   // test makeTangent
@@ -137,7 +137,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 19)
+  t.is(obs.length, 19)
   t.true(comparePoints(obs, exp))
 
   // test segments
@@ -156,7 +156,7 @@ test('arc (options)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 9)
+  t.is(obs.length, 9)
   t.true(comparePoints(obs, exp))
 })
 
@@ -173,7 +173,7 @@ test('arc (rotations)', (t) => {
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   exp = [
@@ -192,7 +192,7 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
   exp = [
@@ -211,7 +211,7 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 10)
+  t.is(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
   exp = [[-1.8369701987210297e-16, -1]]
@@ -219,6 +219,6 @@ test('arc (rotations)', (t) => {
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 1)
+  t.is(obs.length, 1)
   t.true(comparePoints(obs, exp))
 })