@jscad/modeling 3.0.3-alpha.0 → 3.0.5-alpha.0

package/src/primitives/rectangle.js

@@ -6,6 +6,7 @@ import { isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with four sides at right angles.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rectangle, width and length
@@ -15,12 +16,11 @@ import { isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = rectangle({size: [10, 20]})
  */
-export const rectangle = (options) => {
-  const defaults = {
-    center: [0, 0],
-    size: [2, 2]
-  }
-  const { center, size } = Object.assign({}, defaults, options)
+export const rectangle = (options = {}) => {
+  const {
+    center = [0, 0],
+    size = [2, 2]
+  } = 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')

package/src/primitives/roundedCuboid.js

@@ -115,6 +115,7 @@ const stitchSides = (bottomCorners, topCorners) => {
 
 /**
  * Construct an axis-aligned solid cuboid in three dimensional space with rounded corners.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of rounded cube
  * @param {Array} [options.size=[2,2,2]] - dimension of rounded cube; width, depth, height
@@ -126,14 +127,13 @@ const stitchSides = (bottomCorners, topCorners) => {
  * @example
  * let myCube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
  */
-export const roundedCuboid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    size: [2, 2, 2],
-    roundRadius: 0.2,
-    segments: 32
-  }
-  let { center, size, roundRadius, segments } = Object.assign({}, defaults, options)
+export const roundedCuboid = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    size = [2, 2, 2],
+    roundRadius = 0.2,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of X, Y and Z values')

package/src/primitives/roundedCylinder.js

@@ -12,6 +12,7 @@ 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 {Array} [options.center=[0,0,0]] - center of cylinder
  * @param {number} [options.height=2] - height of cylinder
@@ -24,15 +25,14 @@ import { cylinder } from './cylinder.js'
  * @example
  * let myshape = roundedCylinder({ height: 10, radius: 2, roundRadius: 0.5 })
  */
-export const roundedCylinder = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    height: 2,
-    radius: 1,
-    roundRadius: 0.2,
-    segments: 32
-  }
-  const { center, height, radius, roundRadius, segments } = Object.assign({}, defaults, options)
+export const roundedCylinder = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    height = 2,
+    radius = 1,
+    roundRadius = 0.2,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isGTE(height, 0)) throw new Error('height must be positive')

package/src/primitives/roundedRectangle.js

@@ -10,6 +10,7 @@ import { rectangle } from './rectangle.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with rounded corners.
+ *
  * @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
@@ -21,14 +22,13 @@ import { rectangle } from './rectangle.js'
  * @example
  * let myshape = roundedRectangle({size: [10, 20], roundRadius: 2})
  */
-export const roundedRectangle = (options) => {
-  const defaults = {
-    center: [0, 0],
-    size: [2, 2],
-    roundRadius: 0.2,
-    segments: 32
-  }
-  let { center, size, roundRadius, segments } = Object.assign({}, defaults, options)
+export const roundedRectangle = (options = {}) => {
+  let {
+    center = [0, 0],
+    size = [2, 2],
+    roundRadius = 0.2,
+    segments = 32
+  } = 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')

package/src/primitives/sphere.js

@@ -15,14 +15,13 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = sphere({radius: 5})
  */
-export const sphere = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    radius: 1,
-    segments: 32,
-    axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
-  }
-  let { center, radius, segments, axes } = Object.assign({}, defaults, options)
+export const sphere = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    radius = 1,
+    segments = 32,
+    axes = [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 

package/src/primitives/square.js

@@ -3,6 +3,7 @@ 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 {Array} [options.center=[0,0]] - center of square
@@ -13,12 +14,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = square({size: 10})
  */
-export const square = (options) => {
-  const defaults = {
-    center: [0, 0],
-    size: 2
-  }
-  let { center, size } = Object.assign({}, defaults, options)
+export const square = (options = {}) => {
+  let {
+    center = [0, 0],
+    size = 2
+  } = options
 
   if (!isGTE(size, 0)) throw new Error('size must be positive')
 

package/src/primitives/star.js

@@ -28,6 +28,7 @@ const getPoints = (vertices, radius, startAngle, center) => {
 
 /**
  * Construct a star in two dimensional space.
+ *
  * @see https://en.wikipedia.org/wiki/Star_polygon
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of star
@@ -43,16 +44,15 @@ const getPoints = (vertices, radius, startAngle, center) => {
  * let star1 = star({vertices: 8, outerRadius: 10}) // star with 8/2 density
  * let star2 = star({vertices: 12, outerRadius: 40, innerRadius: 20}) // star with given radius
  */
-export const star = (options) => {
-  const defaults = {
-    center: [0, 0],
-    vertices: 5,
-    outerRadius: 1,
-    innerRadius: 0,
-    density: 2,
-    startAngle: 0
-  }
-  let { center, vertices, outerRadius, innerRadius, density, startAngle } = Object.assign({}, defaults, options)
+export const star = (options = {}) => {
+  let {
+    center = [0, 0],
+    vertices = 5,
+    outerRadius = 1,
+    innerRadius = 0,
+    density = 2,
+    startAngle = 0
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isGTE(vertices, 2)) throw new Error('vertices must be two or more')

package/src/primitives/torus.js

@@ -10,6 +10,7 @@ import { isGT, isGTE } from './commonChecks.js'
 
 /**
  * Construct a torus by revolving a small circle (inner) about the circumference of a large (outer) circle.
+ *
  * @param {object} [options] - options for construction
  * @param {number} [options.innerRadius=1] - radius of small (inner) circle
  * @param {number} [options.outerRadius=4] - radius of large (outer) circle
@@ -24,17 +25,16 @@ import { isGT, isGTE } from './commonChecks.js'
  * @example
  * let myshape = torus({ innerRadius: 10, outerRadius: 100 })
  */
-export const torus = (options) => {
-  const defaults = {
-    innerRadius: 1,
-    innerSegments: 32,
-    outerRadius: 4,
-    outerSegments: 32,
-    innerRotation: 0,
-    startAngle: 0,
-    outerRotation: TAU
-  }
-  const { innerRadius, innerSegments, outerRadius, outerSegments, innerRotation, startAngle, outerRotation } = Object.assign({}, defaults, options)
+export const torus = (options = {}) => {
+  const {
+    innerRadius = 1,
+    innerSegments = 32,
+    outerRadius = 4,
+    outerSegments = 32,
+    innerRotation = 0,
+    startAngle = 0,
+    outerRotation = TAU
+  } = options
 
   if (!isGT(innerRadius, 0)) throw new Error('innerRadius must be greater than zero')
   if (!isGTE(innerSegments, 3)) throw new Error('innerSegments must be three or more')

package/src/primitives/triangle.js

@@ -115,7 +115,9 @@ const createTriangle = (A, B, C, a, b, c) => {
 
 /**
  * Construct a triangle in two dimensional space from the given options.
+ *
  * The triangle is always constructed CCW from the origin, [0, 0, 0].
+ *
  * @see https://www.mathsisfun.com/algebra/trig-solving-triangles.html
  * @param {object} [options] - options for construction
  * @param {string} [options.type='SSS'] - type of triangle to construct; A ~ angle, S ~ side
@@ -126,12 +128,11 @@ const createTriangle = (A, B, C, a, b, c) => {
  * @example
  * let myshape = triangle({type: 'AAS', values: [degToRad(62), degToRad(35), 7]})
  */
-export const triangle = (options) => {
-  const defaults = {
-    type: 'SSS',
-    values: [1, 1, 1]
-  }
-  let { type, values } = Object.assign({}, defaults, options)
+export const triangle = (options = {}) => {
+  let {
+    type = 'SSS',
+    values = [1, 1, 1]
+  } = options
 
   if (typeof (type) !== 'string') throw new Error('triangle type must be a string')
   type = type.toUpperCase()

package/src/utils/areAllShapesTheSameType.js

@@ -2,6 +2,8 @@
 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 * as path3 from '../geometries/path3/index.js'
+import * as slice from '../geometries/slice/index.js'
 
 /**
  * @param {Array} shapes - list of shapes to compare
@@ -15,6 +17,8 @@ export const areAllShapesTheSameType = (shapes) => {
     if (geom2.isA(shape)) currentType = 1
     if (geom3.isA(shape)) currentType = 2
     if (path2.isA(shape)) currentType = 3
+    if (path3.isA(shape)) currentType = 4
+    if (slice.isA(shape)) currentType = 5
 
     if (previousType && currentType !== previousType) return false
     previousType = currentType

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/slice/fromGeom2.d.ts

@@ -1,5 +0,0 @@
-import type { Geom2 } from '../geom2/type.d.ts'
-
-import type { Slice } from './type.d.ts'
-
-export function fromGeom2(geometry: Geom2): Slice

package/src/geometries/slice/fromGeom2.js

@@ -1,17 +0,0 @@
-import * as vec3 from '../../maths/vec3/index.js'
-import { toOutlines } from '../geom2/index.js'
-
-import { create } from './create.js'
-
-/**
- * Create a slice from a geom2.
- *
- * @param {object} geometry - the 2D geometry to create a slice from
- * @returns {Slice} a new slice
- * @alias module:modeling/geometries/slice.fromGeom2
- */
-export const fromGeom2 = (geometry) => {
-  // Convert from 2D points to 3D vertices
-  const contours = toOutlines(geometry).map((outline) => outline.map((point) => vec3.fromVec2(vec3.create(), point)))
-  return create(contours)
-}