@jscad/modeling 2.7.2 → 2.9.1

package/src/operations/transforms/center.js

@@ -24,18 +24,18 @@ const centerGeometry = (options, object) => {
 }
 
 /**
- * Center the given geometries using the given options.
+ * Center the given objects using the given options.
  * @param {Object} options - options for centering
  * @param {Array} [options.axes=[true,true,true]] - axis of which to center, true or false
- * @param {Array} [options.relativeTo=[0,0,0]] - relative point of which to center the geometries
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometries
+ * @param {Array} [options.relativeTo=[0,0,0]] - relative point of which to center the objects
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.center
  *
  * @example
  * let myshape = center({axes: [true,false,false]}, sphere()) // center about the X axis
  */
-const center = (options, ...geometries) => {
+const center = (options, ...objects) => {
   const defaults = {
     axes: [true, true, true],
     relativeTo: [0, 0, 0]
@@ -43,13 +43,13 @@ const center = (options, ...geometries) => {
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  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 }
 
-  const results = geometries.map((object) => {
+  const results = objects.map((object) => {
     if (path2.isA(object)) return centerGeometry(options, object)
     if (geom2.isA(object)) return centerGeometry(options, object)
     if (geom3.isA(object)) return centerGeometry(options, object)
@@ -59,25 +59,25 @@ const center = (options, ...geometries) => {
 }
 
 /**
- * Center the given geometries about the X axis.
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometry
+ * Center the given objects about the X axis.
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerX
  */
 const centerX = (...objects) => center({ axes: [true, false, false] }, objects)
 
 /**
- * Center the given geometries about the Y axis.
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometry
+ * Center the given objects about the Y axis.
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerY
  */
 const centerY = (...objects) => center({ axes: [false, true, false] }, objects)
 
 /**
- * Center the given geometries about the Z axis.
- * @param {...Object} geometries - the geometries to center
- * @return {Object|Array} the centered geometry, or a list of centered geometry
+ * Center the given objects about the Z axis.
+ * @param {...Object} objects - the objects to center
+ * @return {Object|Array} the centered object, or a list of centered objects
  * @alias module:modeling/transforms.centerZ
  */
 const centerZ = (...objects) => center({ axes: [false, false, true] }, objects)

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

@@ -13,10 +13,12 @@ test('center: centering of a path2 produces expected changes to points', (t) =>
   let centered = center({ axes: [true, false, false] }, geometry)
   let pts = path2.toPoints(centered)
   const exp = [[3, 0], [-2, 3], [-3, 0]]
+  t.notThrows(() => path2.validate(centered))
   t.true(comparePoints(pts, exp))
 
   centered = centerX(geometry)
   pts = path2.toPoints(centered)
+  t.notThrows(() => path2.validate(centered))
   t.true(comparePoints(pts, exp))
 })
 
@@ -27,10 +29,12 @@ test('center: centering of a geom2 produces expected changes to points', (t) =>
   let centered = center({ axes: [false, true, false] }, geometry)
   let pts = geom2.toPoints(centered)
   const exp = [[0, -5], [10, -5], [0, 5]]
+  t.notThrows(() => geom2.validate(centered))
   t.true(comparePoints(pts, exp))
 
   centered = centerY(geometry)
   pts = geom2.toPoints(centered)
+  t.notThrows(() => geom2.validate(centered))
   t.true(comparePoints(pts, exp))
 })
 
@@ -56,10 +60,12 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-5, -7, -12], [-5, 13, -12], [5, 13, -12], [5, -7, -12]],
     [[-5, -7, 18], [5, -7, 18], [5, 13, 18], [-5, 13, 18]]
   ]
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerX(geometry)
   pts = geom3.toPoints(centered)
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Y
@@ -73,10 +79,12 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -10, -12], [-2, 10, -12], [8, 10, -12], [8, -10, -12]],
     [[-2, -10, 18], [8, -10, 18], [8, 10, 18], [-2, 10, 18]]
   ]
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerY(geometry)
   pts = geom3.toPoints(centered)
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Z
@@ -90,10 +98,12 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -7, -15], [-2, 13, -15], [8, 13, -15], [8, -7, -15]],
     [[-2, -7, 15], [8, -7, 15], [8, 13, 15], [-2, 13, 15]]
   ]
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerZ(geometry)
   pts = geom3.toPoints(centered)
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -108,9 +118,11 @@ test('center: centering of multiple objects produces expected changes', (t) => {
 
   const pts1 = path2.toPoints(centered[1])
   const exp1 = [[2.5, 20], [12.5, 20], [2.5, 10], [17.5, 10]]
+  t.notThrows(() => path2.validate(centered[1]))
   t.true(comparePoints(pts1, exp1))
 
   const pts2 = geom2.toPoints(centered[2])
   const exp2 = [[2.5, 10], [7.5, 20], [17.5, 10]]
+  t.notThrows(() => geom2.validate(centered[2]))
   t.true(comparePoints(pts2, exp2))
 })

package/src/operations/transforms/mirror.js

@@ -8,12 +8,12 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Mirror the given geometries using the given options.
+ * Mirror the given objects using the given options.
  * @param {Object} options - options for mirror
  * @param {Array} [options.origin=[0,0,0]] - the origin of the plane
  * @param {Array} [options.normal=[0,0,1]] - the normal vector of the plane
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * @param {...Object} objects - the objects to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirror
  *
  * @example
@@ -47,25 +47,25 @@ const mirror = (options, ...objects) => {
 }
 
 /**
- * Mirror the given geometries about the X axis.
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * Mirror the given objects about the X axis.
+ * @param {...Object} objects - the objects to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorX
  */
 const mirrorX = (...objects) => mirror({ normal: [1, 0, 0] }, objects)
 
 /**
- * Mirror the given geometries about the Y axis.
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * Mirror the given objects about the Y axis.
+ * @param {...Object} objects - the geometries to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorY
  */
 const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
 
 /**
- * Mirror the given object(s) about the Z axis.
- * @param {...Object} geometries - the geometries to mirror
- * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
+ * Mirror the given objects about the Z axis.
+ * @param {...Object} objects - the geometries to mirror
+ * @return {Object|Array} the mirrored object, or a list of mirrored objects
  * @alias module:modeling/transforms.mirrorZ
  */
 const mirrorZ = (...objects) => mirror({ normal: [0, 0, 1] }, objects)

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

@@ -13,20 +13,24 @@ test('mirror: mirroring of path2 about X/Y produces expected changes to points',
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = path2.toPoints(mirrored)
   let exp = [[5, 5], [-5, 5], [5, -5], [-10, -5]]
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = path2.toPoints(mirrored)
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = path2.toPoints(mirrored)
   exp = [[-5, -5], [5, -5], [-5, 5], [10, 5]]
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = path2.toPoints(mirrored)
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 })
 
@@ -37,20 +41,24 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
   let exp = [[5, -5], [0, 5], [-10, -5]]
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
+  t.notThrows(() => geom2.validate(mirrored))
   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]]
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 })
 
@@ -76,11 +84,13 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[-8, -7, -12], [-8, 13, -12], [2, 13, -12], [2, -7, -12]],
     [[2, 13, 18], [-8, 13, 18], [-8, -7, 18], [2, -7, 18]]
   ]
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
   t.deepEqual(obs, exp)
 
   mirrored = mirrorX(geometry)
   obs = geom3.toPoints(mirrored)
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Y
@@ -94,10 +104,12 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[8, 7, -12], [8, -13, -12], [-2, -13, -12], [-2, 7, -12]],
     [[-2, -13, 18], [8, -13, 18], [8, 7, 18], [-2, 7, 18]]
   ]
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom3.toPoints(mirrored)
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Z
@@ -111,10 +123,12 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[8, -7, 12], [8, 13, 12], [-2, 13, 12], [-2, -7, 12]],
     [[-2, 13, -18], [8, 13, -18], [8, -7, -18], [-2, -7, -18]]
   ]
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorZ(geometry)
   obs = geom3.toPoints(mirrored)
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -128,9 +142,11 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
 
   let obs = path2.toPoints(mirrored[1])
   let exp = [[-5, -5], [5, -5], [-5, 5], [10, 5]]
+  t.notThrows(() => path2.validate(mirrored[1]))
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
   exp = [[-5, 5], [0, -5], [10, 5]]
+  t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/operations/transforms/rotate.js

@@ -7,10 +7,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Rotate the given geometries using the given options.
+ * Rotate the given objects using the given options.
  * @param {Array} angles - angle (RADIANS) of rotations about X, Y, and Z axis
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotate
  *
  * @example
@@ -42,28 +42,28 @@ const rotate = (angles, ...objects) => {
 }
 
 /**
- * Rotate the given object(s) about the X axis, using the given options.
+ * Rotate the given objects about the X axis, using the given options.
  * @param {Number} angle - angle (RADIANS) of rotations about X
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateX
  */
 const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
 
 /**
- * Rotate the given object(s) about the Y axis, using the given options.
+ * Rotate the given objects about the Y axis, using the given options.
  * @param {Number} angle - angle (RADIANS) of rotations about Y
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateY
  */
 const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
 
 /**
- * Rotate the given object(s) about the Z axis, using the given options.
+ * Rotate the given objects about the Z axis, using the given options.
  * @param {Number} angle - angle (RADIANS) of rotations about Z
- * @param {...Object} geometries - the geometries to rotate
- * @return {Object|Array} the rotated geometry, or a list of rotated geometries
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
  * @alias module:modeling/transforms.rotateZ
  */
 const rotateZ = (angle, ...objects) => rotate([0, 0, angle], objects)

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

@@ -21,6 +21,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
 
   rotated = rotateZ(Math.PI / 2, geometry)
   obs = path2.toPoints(rotated)
+  t.notThrows(() => path2.validate(rotated))
   t.true(comparePoints(obs, exp))
 })
 
@@ -35,10 +36,12 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
     new Float32Array([0, -1]),
     new Float32Array([1, 0])
   ]
+  t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
 
   rotated = rotateZ(-Math.PI / 2, geometry)
   obs = geom2.toPoints(rotated)
+  t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
 })
 
@@ -70,10 +73,12 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[-2, -18, -6.999999999999999], [8, -18, -6.999999999999999],
       [8, -18, 13.000000000000002], [-2, -18, 13.000000000000002]]
   ]
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateX(Math.PI / 2, geometry)
   obs = geom3.toPoints(rotated)
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
@@ -93,6 +98,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[-18, -7, -1.999999999999999], [-18, -7, 8.000000000000002],
       [-18, 13, 8.000000000000002], [-18, 13, -1.999999999999999]]
   ]
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateY(-Math.PI / 2, geometry)
@@ -116,10 +122,12 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[2.000000000000001, 7, 18], [-7.999999999999999, 7.000000000000001, 18],
       [-8.000000000000002, -12.999999999999998, 18], [1.9999999999999984, -13, 18]]
   ]
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateZ(Math.PI, geometry)
   obs = geom3.toPoints(rotated)
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -134,9 +142,11 @@ test('rotate: rotating of multiple objects produces expected changes', (t) => {
 
   const obs1 = path2.toPoints(rotated[1])
   const exp1 = [[-5, -5], [-5, 5], [5, -5], [5.000000000000001, 10]]
+  t.notThrows(() => path2.validate(rotated[1]))
   t.true(comparePoints(obs1, exp1))
 
   const obs2 = geom2.toPoints(rotated[2])
   const exp2 = [[5, -5], [-5, 3.061616997868383e-16], [5.000000000000001, 10]]
+  t.notThrows(() => geom2.validate(rotated[2]))
   t.true(comparePoints(obs2, exp2))
 })

package/src/operations/transforms/scale.js

@@ -7,10 +7,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Scale the given geometries using the given options.
- * @param {Array} factors - X, Y, Z factors by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects using the given options.
+ * @param {Array} factors - X, Y, Z factors by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scale
  *
  * @example
@@ -40,31 +40,31 @@ const scale = (factors, ...objects) => {
 }
 
 /**
- * Scale the given geometries about the X axis using the given options.
- * @param {Number} factor - X factor by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects about the X axis using the given options.
+ * @param {Number} factor - X factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleX
  */
-const scaleX = (offset, ...objects) => scale([offset, 1, 1], objects)
+const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
 
 /**
- * Scale the given geometries about the Y axis using the given options.
- * @param {Number} factor - Y factor by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects about the Y axis using the given options.
+ * @param {Number} factor - Y factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleY
  */
-const scaleY = (offset, ...objects) => scale([1, offset, 1], objects)
+const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
 
 /**
- * Scale the given geometries about the Z axis using the given options.
- * @param {Number} factor - Z factor by which to scale the geometries
- * @param {...Object} geometries - the geometries to scale
- * @return {Object|Array} the scaled geometry, or a list of scaled geometries
+ * Scale the given objects about the Z axis using the given options.
+ * @param {Number} factor - Z factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
  * @alias module:modeling/transforms.scaleZ
  */
-const scaleZ = (offset, ...objects) => scale([1, 1, offset], objects)
+const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)
 
 module.exports = {
   scale,

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

@@ -13,20 +13,24 @@ test('scale: scaling of a path2 produces expected changes to points', (t) => {
   let scaled = scale([3], geometry)
   let obs = path2.toPoints(scaled)
   let exp = [[0, 4], [3, 0]]
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = path2.toPoints(scaled)
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   // scale Y
   scaled = scale([1, 0.5], geometry)
   obs = path2.toPoints(scaled)
   exp = [[0, 2], [1, 0]]
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleY(0.5, geometry)
   obs = path2.toPoints(scaled)
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 })
 
@@ -37,20 +41,24 @@ test('scale: scaling of a geom2 produces expected changes to points', (t) => {
   let scaled = scale([3], geometry)
   let obs = geom2.toPoints(scaled)
   let exp = [[-3, 0], [3, 0], [0, 1]]
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = geom2.toPoints(scaled)
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   // scale Y
   scaled = scale([1, 3], geometry)
   obs = geom2.toPoints(scaled)
   exp = [[-1, 0], [1, 0], [0, 3]]
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleY(3, geometry)
   obs = geom2.toPoints(scaled)
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 })
 
@@ -76,10 +84,12 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-6, -7, -12], [-6, 13, -12], [24, 13, -12], [24, -7, -12]],
     [[-6, -7, 18], [24, -7, 18], [24, 13, 18], [-6, 13, 18]]
   ]
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Y
@@ -97,6 +107,7 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
 
   scaled = scaleY(0.5, geometry)
   obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Z
@@ -110,10 +121,12 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-2, -7, -60], [-2, 13, -60], [8, 13, -60], [8, -7, -60]],
     [[-2, -7, 90], [8, -7, 90], [8, 13, 90], [-2, 13, 90]]
   ]
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleZ(5, geometry)
   obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -128,9 +141,11 @@ test('scale: scaling of multiple objects produces expected changes', (t) => {
 
   const obs1 = path2.toPoints(scaled[1])
   const exp1 = [[-15, 5], [15, 5], [-15, -5], [30, -5]]
+  t.notThrows(() => path2.validate(scaled[1]))
   t.true(comparePoints(obs1, exp1))
 
   const obs2 = geom2.toPoints(scaled[2])
   const exp2 = [[-15, -5], [0, 5], [30, -5]]
+  t.notThrows(() => geom2.validate(scaled[2]))
   t.true(comparePoints(obs2, exp2))
 })

package/src/operations/transforms/transform.js

@@ -5,10 +5,10 @@ const geom3 = require('../../geometries/geom3')
 const path2 = require('../../geometries/path2')
 
 /**
- * Transform the given geometries using the given matrix.
+ * Transform the given objects using the given matrix.
  * @param {mat4} matrix - a transformation matrix
- * @param {...Object} geometries - the geometries to transform
- * @return {Object|Array} the transformed geometry, or a list of transformed geometries
+ * @param {...Object} objects - the objects to transform
+ * @return {Object|Array} the transformed object, or a list of transformed objects
  * @alias module:modeling/transforms.transform
  *
  * @example

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

@@ -15,6 +15,7 @@ test('transform: transforming of a path2 produces expected changes to points', (
   geometry = transform(matrix, geometry)
   const obs = path2.toPoints(geometry)
   const exp = [[2, 2], [3, 2]]
+  t.notThrows(() => path2.validate(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -25,6 +26,7 @@ test('transform: transforming of a geom2 produces expected changes to sides', (t
   geometry = transform(matrix, geometry)
   const obs = geom2.toPoints(geometry)
   const exp = [[0, 0], [5, 0], [0, 5]]
+  t.notThrows(() => geom2.validate(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -49,6 +51,7 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
     [[-5, -10, -15], [-5, 10, -15], [5, 10, -15], [5, -10, -15]],
     [[-5, -10, 15], [5, -10, 15], [5, 10, 15], [-5, 10, 15]]
   ]
+  t.notThrows(() => geom3.validate(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -63,9 +66,11 @@ test('transform: transforming of multiple objects produces expected changes', (t
 
   let obs = path2.toPoints(transformed[1])
   let exp = [[-3, 7], [7, 7], [-3, -3], [12, -3]]
+  t.notThrows(() => path2.validate(transformed[1]))
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(transformed[2])
   exp = [[-3, -3], [2, 7], [12, -3]]
+  t.notThrows(() => geom2.validate(transformed[2]))
   t.true(comparePoints(obs, exp))
 })