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

package/src/primitives/cylinder.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cylinder (defaults)', (t) => {
   const obs = cylinder()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.789084266699856)
@@ -20,7 +20,7 @@ test('cylinder (defaults)', (t) => {
 
 test('cylinder (zero height)', (t) => {
   const obs = cylinder({ height: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -29,7 +29,7 @@ test('cylinder (zero height)', (t) => {
 
 test('cylinder (zero radius)', (t) => {
   const obs = cylinder({ radius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -38,7 +38,7 @@ test('cylinder (zero radius)', (t) => {
 
 test('cylinder (options)', (t) => {
   let obs = cylinder({ height: 10, radius: 4, segments: 5 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 0, -5], [1.2360679774997898, 3.804226065180614, -5], [4, 0, -5]],
     [[1.2360679774997898, 3.804226065180614, -5], [1.2360679774997898, 3.804226065180614, 5],
@@ -70,7 +70,7 @@ test('cylinder (options)', (t) => {
 
   // test center
   obs = cylinder({ center: [-5, -5, -5], segments: 5 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-5, -5, -6], [-4.6909830056250525, -4.048943483704846, -6], [-4, -5, -6]],
     [[-4.6909830056250525, -4.048943483704846, -6], [-4.6909830056250525, -4.048943483704846, -4],

package/src/primitives/cylinderElliptic.test.js

@@ -12,7 +12,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cylinderElliptic (defaults)', (t) => {
   const obs = cylinderElliptic()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.789084266699856)
@@ -23,7 +23,7 @@ test('cylinderElliptic (defaults)', (t) => {
 test('cylinderElliptic (options)', (t) => {
   // test height
   let obs = cylinderElliptic({ height: 10, segments: 12 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 0, -5], [0.8660254037844387, 0.49999999999999994, -5], [1, 0, -5]],
     [[0.8660254037844387, 0.49999999999999994, -5], [0.8660254037844387, 0.49999999999999994, 5],
@@ -83,7 +83,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test startRadius and endRadius
   obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], segments: 12 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[0, 0, -1], [0.8660254037844387, 0.9999999999999999, -1], [1, 0, -1]],
     [[1, 0, -1], [0.8660254037844387, 0.9999999999999999, -1], [2, 0, 1]],
@@ -143,7 +143,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test startAngle and endAngle
   obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: TAU / 4, endAngle: TAU * 0.75, segments: 12 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 22.17105015072561)
@@ -152,7 +152,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test startAngle and endAngle
   obs = cylinderElliptic({ startAngle: 1, endAngle: 1 + TAU })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.78908426669986)
@@ -161,7 +161,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test segments
   obs = cylinderElliptic({ segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 17.902724085175244)
@@ -170,7 +170,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test center
   obs = cylinderElliptic({ center: [-5, -5, -5], height: 3, segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-5, -5, -6.5], [-4.292893218813452, -4.292893218813452, -6.5], [-4, -5, -6.5]],
     [[-4.292893218813452, -4.292893218813452, -6.5], [-4.292893218813452, -4.292893218813452, -3.5],
@@ -215,7 +215,7 @@ test('cylinderElliptic (options)', (t) => {
 
 test('cylinderElliptic (cone)', (t) => {
   const obs = cylinderElliptic({ endRadius: [0, 0] })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 10.128239395900382)
@@ -225,7 +225,7 @@ test('cylinderElliptic (cone)', (t) => {
 
 test('cylinderElliptic (squished)', (t) => {
   const obs = cylinderElliptic({ startRadius: [1, 0], endRadius: [0, 1], segments: 4 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 8.47213595499958)

package/src/primitives/ellipsoid.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('ellipsoid (defaults)', (t) => {
   const obs = ellipsoid()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 12.465694088650583)
@@ -21,7 +21,7 @@ test('ellipsoid (defaults)', (t) => {
 test('ellipsoid (options)', (t) => {
   // test radius
   let obs = ellipsoid({ radius: [3, 5, 7], segments: 12 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[3, 0, 0], [2.598076211353316, -2.4999999999999996, 0],
       [2.25, -2.1650635094610964, -3.4999999999999996], [2.598076211353316, 0, -3.4999999999999996]],
@@ -152,14 +152,14 @@ test('ellipsoid (options)', (t) => {
 
   // test segments
   obs = ellipsoid({ segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 11.013439076647456)
   t.is(measureVolume(obs), 3.2189514164974597)
   t.is(pts.length, 32)
 
   obs = ellipsoid({ center: [-3, 5, 7], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-2, 5, 7], [-2.2928932188134525, 4.292893218813452, 7],
       [-2.5, 4.5, 6.292893218813452], [-2.2928932188134525, 5, 6.292893218813452]],
@@ -220,7 +220,7 @@ test('ellipsoid (options)', (t) => {
 
 test('ellipsoid (zero radius)', (t) => {
   const obs = ellipsoid({ radius: [1, 1, 0] })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/geodesicSphere.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('geodesicSphere (defaults)', (t) => {
   const obs = geodesicSphere()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 20)
 })
@@ -18,7 +18,7 @@ test('geodesicSphere (defaults)', (t) => {
 test('geodesicSphere (options)', (t) => {
   // test radius
   let obs = geodesicSphere({ radius: 5 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   const exp = [
     [[4.253254557317035, 0, 2.628654726407001], [2.628654726407001, -4.253254557317035, 0], [4.253254557317035, 0, -2.628654726407001]],
     [[4.253254557317035, 0, -2.628654726407001], [2.628654726407001, 4.253254557317035, 0], [4.253254557317035, 0, 2.628654726407001]],
@@ -50,7 +50,7 @@ test('geodesicSphere (options)', (t) => {
 
   // test frequency
   obs = geodesicSphere({ radius: 5, frequency: 18 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(measureArea(obs), 303.76605423529395)
@@ -60,7 +60,7 @@ test('geodesicSphere (options)', (t) => {
 
 test('geodesicSphere (zero radius)', (t) => {
   const obs = geodesicSphere({ radius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/polyhedron.test.js

@@ -14,7 +14,7 @@ test('polyhedron (points and faces)', (t) => {
   let faces = [[0, 1, 2, 3], [5, 6, 7, 4], [0, 5, 4, 1], [3, 2, 7, 6], [0, 3, 6, 5], [1, 4, 7, 2]]
   const colors = [[0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0.5, 0.5, 0.5, 1], [1, 1, 1, 1]]
   let obs = polyhedron({ points, faces, colors })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
     [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
@@ -33,7 +33,7 @@ test('polyhedron (points and faces)', (t) => {
   points = [[10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10]]
   faces = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3]]
   obs = polyhedron({ points: points, faces: faces, orientation: 'inward' })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[0, 0, 10], [10, -10, 0], [10, 10, 0]],
     [[0, 0, 10], [-10, -10, 0], [10, -10, 0]],

package/src/primitives/roundedCuboid.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCuboid (defaults)', (t) => {
   const obs = roundedCuboid()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 21.87859958298585)
@@ -20,7 +20,7 @@ test('roundedCuboid (defaults)', (t) => {
 
 test('roundedCuboid (zero size)', (t) => {
   const obs = roundedCuboid({ size: [1, 1, 0] })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -29,7 +29,7 @@ test('roundedCuboid (zero size)', (t) => {
 
 test('roundedCuboid (zero radius)', (t) => {
   const obs = roundedCuboid({ roundRadius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 24)
   t.is(measureVolume(obs), 7.999999999999999)
@@ -39,7 +39,7 @@ test('roundedCuboid (zero radius)', (t) => {
 test('roundedCuboid (options)', (t) => {
   // test segments
   let obs = roundedCuboid({ segments: 8 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = []
 
   t.notThrows(() => geom3.validate(obs))
@@ -49,7 +49,7 @@ test('roundedCuboid (options)', (t) => {
 
   // test center
   obs = roundedCuboid({ center: [4, 5, 6], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
   ]
 
@@ -60,7 +60,7 @@ test('roundedCuboid (options)', (t) => {
 
   // test size
   obs = roundedCuboid({ size: [8, 10, 12], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[4, 4.8, -5.8], [3.9414213562373095, 4.941421356237309, -5.8],
       [3.9414213562373095, 4.941421356237309, 5.8], [4, 4.8, 5.8]],
@@ -163,7 +163,7 @@ test('roundedCuboid (options)', (t) => {
 
   // test roundRadius
   obs = roundedCuboid({ size: [8, 10, 12], roundRadius: 2, segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[4, 3, -4], [3.414213562373095, 4.414213562373095, -4],
       [3.414213562373095, 4.414213562373095, 4], [4, 3, 4]],

package/src/primitives/roundedCylinder.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCylinder (defaults)', (t) => {
   const obs = roundedCylinder()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 16.844951865908268)
@@ -20,7 +20,7 @@ test('roundedCylinder (defaults)', (t) => {
 
 test('roundedCylinder (zero height)', (t) => {
   const obs = roundedCylinder({ height: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -29,7 +29,7 @@ test('roundedCylinder (zero height)', (t) => {
 
 test('roundedCylinder (zero radius)', (t) => {
   const obs = roundedCylinder({ radius: 0, roundRadius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -38,7 +38,7 @@ test('roundedCylinder (zero radius)', (t) => {
 
 test('roundedCylinder (zero roundRadius)', (t) => {
   const obs = roundedCylinder({ roundRadius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.789084266699856)
   t.is(measureVolume(obs), 6.2428903045161)
@@ -48,7 +48,7 @@ test('roundedCylinder (zero roundRadius)', (t) => {
 test('roundedCylinder (options)', (t) => {
   // test segments
   let obs = roundedCylinder({ segments: 5 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
   ]
 
@@ -59,7 +59,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test center
   obs = roundedCylinder({ segments: 5, center: [-5, -5, -5] })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-4.048943483704846, -4.6909830056250525, -5.8], [-5, -4, -5.8],
       [-5, -4, -4.2], [-4.048943483704846, -4.6909830056250525, -4.2]],
@@ -91,7 +91,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test height
   obs = roundedCylinder({ segments: 5, height: 20 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[0.9510565162951535, 0.30901699437494745, -9.8], [0, 1, -9.8],
       [0, 1, 9.8], [0.9510565162951535, 0.30901699437494745, 9.8]],
@@ -123,7 +123,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test radius
   obs = roundedCylinder({ segments: 5, radius: 10 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[9.510565162951535, 3.0901699437494745, -0.8], [0, 10, -0.8],
       [0, 10, 0.8], [9.510565162951535, 3.0901699437494745, 0.8]],
@@ -154,7 +154,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test round radius
   obs = roundedCylinder({ segments: 5, height: 20, radius: 5, roundRadius: 2 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[4.755282581475767, 1.5450849718747373, -8], [0, 5, -8],
       [0, 5, 8], [4.755282581475767, 1.5450849718747373, 8]],

package/src/primitives/sphere.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('sphere (defaults)', (t) => {
   const obs = sphere()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 12.465694088650583)
@@ -21,7 +21,7 @@ test('sphere (defaults)', (t) => {
 test('sphere (options)', (t) => {
   // test radius
   let obs = sphere({ radius: 5, segments: 12 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = []
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 296.5322084069296)
@@ -31,7 +31,7 @@ test('sphere (options)', (t) => {
 
   // test segments
   obs = sphere({ segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[1, 0, 0], [0.7071067811865476, -0.7071067811865475, 0],
       [0.5000000000000001, -0.5, -0.7071067811865475], [0.7071067811865476, 0, -0.7071067811865475]],
@@ -116,7 +116,7 @@ test('sphere (options)', (t) => {
 
   // test center
   obs = sphere({ center: [-3, 5, 7], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-2, 5, 7], [-2.2928932188134525, 4.292893218813452, 7],
       [-2.5, 4.5, 6.292893218813452], [-2.2928932188134525, 5, 6.292893218813452]],
@@ -176,7 +176,7 @@ test('sphere (options)', (t) => {
 
 test('sphere (zero radius)', (t) => {
   const obs = sphere({ radius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/torus.test.js

@@ -12,7 +12,7 @@ import { comparePoints } from '../../test/helpers/index.js'
 
 test('torus (defaults)', (t) => {
   const obs = torus()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 157.0282327749074)
@@ -26,7 +26,7 @@ test('torus (defaults)', (t) => {
 
 test('torus (simple options)', (t) => {
   const obs = torus({ innerRadius: 0.5, innerSegments: 4, outerRadius: 5, outerSegments: 8 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 83.36086132479792)
   t.is(measureVolume(obs), 14.14213562373095)
@@ -39,7 +39,7 @@ test('torus (simple options)', (t) => {
 
 test('torus (complex options)', (t) => {
   const obs = torus({ innerRadius: 1, outerRadius: 5, innerSegments: 32, outerSegments: 72, startAngle: TAU / 4, outerRotation: TAU / 4 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 55.472610544494)
   t.is(measureVolume(obs), 24.484668362201525)
@@ -52,7 +52,7 @@ test('torus (complex options)', (t) => {
 
 test('torus (startAngle)', (t) => {
   const obs = torus({ startAngle: 1, endAngle: 1 + TAU })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 157.0282327749074)
   t.is(measureVolume(obs), 77.94735870844195)

package/src/utils/flatten.js

@@ -5,4 +5,4 @@
  * @returns {Array} a flat list of arguments
  * @alias module:modeling/utils.flatten
  */
-export const flatten = (arr) => arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
+export const flatten = (arr) => arr.flat(Infinity)

package/src/utils/flatten.test.js

@@ -0,0 +1,94 @@
+import test from 'ava'
+
+import { flatten } from './index.js'
+
+test('flatten: test an empty array returns empty.', (t) => {
+  t.deepEqual(flatten([]), [])
+})
+
+test('flatten: test a flat array is unchanged.', (t) => {
+  t.deepEqual(flatten([1, 2, 3]), [1, 2, 3])
+})
+
+test('flatten: test single level nesting is flattened.', (t) => {
+  t.deepEqual(flatten([1, [2, 3], 4]), [1, 2, 3, 4])
+  t.deepEqual(flatten([[1, 2], [3, 4]]), [1, 2, 3, 4])
+  t.deepEqual(flatten([[1], [2], [3]]), [1, 2, 3])
+})
+
+test('flatten: test deep nesting is flattened.', (t) => {
+  t.deepEqual(flatten([1, [2, [3, [4]]]]), [1, 2, 3, 4])
+  t.deepEqual(flatten([[[[1]]]]), [1])
+  t.deepEqual(flatten([1, [2, [3, [4, [5]]]]]), [1, 2, 3, 4, 5])
+})
+
+test('flatten: test mixed nesting depths are flattened.', (t) => {
+  t.deepEqual(flatten([1, [2, 3], [[4, 5]], [[[6]]]]), [1, 2, 3, 4, 5, 6])
+})
+
+test('flatten: test empty nested arrays are removed.', (t) => {
+  t.deepEqual(flatten([[]]), [])
+  t.deepEqual(flatten([[], []]), [])
+  t.deepEqual(flatten([1, [], 2]), [1, 2])
+  t.deepEqual(flatten([[], [1], []]), [1])
+})
+
+test('flatten: test single element arrays are flattened.', (t) => {
+  t.deepEqual(flatten([1]), [1])
+  t.deepEqual(flatten([[1]]), [1])
+  t.deepEqual(flatten([[[1]]]), [1])
+})
+
+test('flatten: test element order is preserved.', (t) => {
+  t.deepEqual(flatten([1, [2, 3], 4, [5, 6]]), [1, 2, 3, 4, 5, 6])
+  t.deepEqual(flatten([[1, 2], 3, [4, [5, 6]]]), [1, 2, 3, 4, 5, 6])
+})
+
+test('flatten: test object references are preserved.', (t) => {
+  const obj1 = { id: 1 }
+  const obj2 = { id: 2 }
+  const obj3 = { id: 3 }
+  const result = flatten([obj1, [obj2, obj3]])
+  t.is(result[0], obj1)
+  t.is(result[1], obj2)
+  t.is(result[2], obj3)
+})
+
+test('flatten: test various types are preserved.', (t) => {
+  const obj = { a: 1 }
+  const fn = () => {}
+  t.deepEqual(flatten([1, 'string', null, undefined, true]), [1, 'string', null, undefined, true])
+
+  const result = flatten([obj, [fn]])
+  t.is(result[0], obj)
+  t.is(result[1], fn)
+})
+
+test('flatten: test large flat array is unchanged.', (t) => {
+  const large = []
+  for (let i = 0; i < 1000; i++) {
+    large.push(i)
+  }
+  const result = flatten(large)
+  t.is(result.length, 1000)
+  t.is(result[0], 0)
+  t.is(result[999], 999)
+})
+
+test('flatten: test large nested array is flattened.', (t) => {
+  const nested = []
+  for (let i = 0; i < 100; i++) {
+    nested.push([i * 10, i * 10 + 1, i * 10 + 2])
+  }
+  const result = flatten(nested)
+  t.is(result.length, 300)
+  t.is(result[0], 0)
+  t.is(result[3], 10)
+})
+
+test('flatten: test input array is not modified.', (t) => {
+  const input = [1, [2, 3], 4]
+  const inputCopy = JSON.stringify(input)
+  flatten(input)
+  t.is(JSON.stringify(input), inputCopy)
+})

package/src/geometries/geom2/fromCompactBinary.d.ts

@@ -1,3 +0,0 @@
-import type { Geom2 } from './type.d.ts'
-
-export function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Geom2

package/src/geometries/geom2/fromCompactBinary.js

@@ -1,40 +0,0 @@
-import * as mat4 from '../../maths/mat4/index.js'
-import * as vec2 from '../../maths/vec2/index.js'
-
-import { create } from './create.js'
-
-/**
- * Create a new 2D geometry from the given compact binary data.
- * @param {Array} data - compact binary data
- * @returns {Geom2} a new geometry
- * @alias module:modeling/geometries/geom2.fromCompactBinary
- */
-export const fromCompactBinary = (data) => {
-  if (data[0] !== 0) throw new Error('invalid compact binary data')
-
-  const created = create()
-
-  created.transforms = mat4.clone(data.slice(1, 17))
-
-  for (let i = 21; i < data.length;) {
-    const length = data[i++] // number of points for this polygon
-    if (length < 0 || i + length * 2 > data.length) {
-      throw new Error('invalid compact binary data')
-    }
-    const outline = []
-    for (let j = 0; j < length; j++) {
-      const x = data[i + j * 2]
-      const y = data[i + j * 2 + 1]
-      outline.push(vec2.fromValues(x, y))
-    }
-    created.outlines.push(outline)
-    i += length * 2
-  }
-
-  // transfer known properties, i.e. color
-  if (data[17] >= 0) {
-    created.color = [data[17], data[18], data[19], data[20]]
-  }
-  // TODO: how about custom properties or fields ?
-  return created
-}