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

package/src/primitives/ellipse.js

@@ -10,6 +10,7 @@ import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipse in two dimensional space.
+ *
  * @see https://en.wikipedia.org/wiki/Ellipse
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of ellipse
@@ -19,18 +20,18 @@ import { isGTE, isNumberArray } from './commonChecks.js'
  * @param {number} [options.segments=32] - number of segments to create per full rotation
  * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.ellipse
+ *
  * @example
  * let myshape = ellipse({radius: [5,10]})
  */
-export const ellipse = (options) => {
-  const defaults = {
-    center: [0, 0],
-    radius: [1, 1],
-    startAngle: 0,
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+export const ellipse = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = [1, 1],
+    startAngle = 0,
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(radius, 2)) throw new Error('radius must be an array of X and Y values')

package/src/primitives/ellipsoid.js

@@ -9,6 +9,7 @@ import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipsoid in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of ellipsoid
  * @param {Array} [options.radius=[1,1,1]] - radius of ellipsoid, along X, Y and Z
@@ -20,14 +21,13 @@ import { isGTE, isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = ellipsoid({radius: [5, 10, 20]})
 */
-export const ellipsoid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    radius: [1, 1, 1],
-    segments: 32,
-    axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
-  }
-  const { center, radius, segments, axes } = Object.assign({}, defaults, options)
+export const ellipsoid = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    radius = [1, 1, 1],
+    segments = 32,
+    axes = [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(radius, 3)) throw new Error('radius must be an array of X, Y and Z values')

package/src/primitives/geodesicSphere.js

@@ -8,6 +8,7 @@ import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a geodesic sphere based on icosahedron symmetry.
+ *
  * @param {object} [options] - options for construction
  * @param {number} [options.radius=1] - target radius of sphere
  * @param {number} [options.frequency=6] - subdivision frequency per face, multiples of 6
@@ -17,12 +18,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = geodesicSphere({radius: 15, frequency: 18})
  */
-export const geodesicSphere = (options) => {
-  const defaults = {
-    radius: 1,
-    frequency: 6
-  }
-  let { radius, frequency } = Object.assign({}, defaults, options)
+export const geodesicSphere = (options = {}) => {
+  let {
+    radius = 1,
+    frequency = 6
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(frequency, 6)) throw new Error('frequency must be six or more')

package/src/primitives/line.js

@@ -2,7 +2,9 @@ import * as path2 from '../geometries/path2/index.js'
 
 /**
  * Construct a new line in two dimensional space from the given points.
+ *
  * The points must be provided as an array, where each element is a 2D point.
+ *
  * @param {Array} points - array of points from which to create the path
  * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.line

package/src/primitives/polygon.js

@@ -24,13 +24,12 @@ import * as geom2 from '../geometries/geom2/index.js'
  * or
  * let poly = polygon({ points: [roof, wall], paths: [[0, 1, 2], [3, 4, 5, 6]] })
  */
-export const polygon = (options) => {
-  const defaults = {
-    points: [],
-    paths: [],
-    orientation: 'counterclockwise'
-  }
-  const { points, paths, orientation } = Object.assign({}, defaults, options)
+export const polygon = (options = {}) => {
+  const {
+    points = [],
+    paths = [],
+    orientation = 'counterclockwise'
+  } = options
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 

package/src/primitives/polyhedron.js

@@ -21,14 +21,13 @@ import { isNumberArray } from './commonChecks.js'
  * let myFaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
  * let myShape = polyhedron({points: myPoints, faces: myFaces, orientation: 'inward'})
  */
-export const polyhedron = (options) => {
-  const defaults = {
-    points: [],
-    faces: [],
-    colors: undefined,
-    orientation: 'outward'
-  }
-  const { points, faces, colors, orientation } = Object.assign({}, defaults, options)
+export const polyhedron = (options = {}) => {
+  const {
+    points = [],
+    faces = [],
+    colors = undefined,
+    orientation = 'outward'
+  } = options
 
   if (!(Array.isArray(points) && Array.isArray(faces))) {
     throw new Error('points and faces must be arrays')

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/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/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)
-}