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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "3.0.4-alpha.0",
+  "version": "3.0.6-alpha.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -11,10 +11,10 @@
   "module": "dist/jscad-modeling.es.js",
   "scripts": {
     "build": "rollup --config",
-    "coverage": "c8 --all --reporter=html --reporter=text pnpm test",
+    "coverage": "c8 --all --reporter=html --reporter=text npm test",
     "test": "ava 'src/**/*.test.js' --verbose --timeout 2m",
     "test:tsd": "tsd",
-    "version": "pnpm run build && git add dist"
+    "version": "npm run build && git add dist"
   },
   "contributors": [
     {
@@ -63,5 +63,5 @@
     "c8": "^10.1.0",
     "rollup": "^4.52.0"
   },
-  "gitHead": "1de52a2b7b6bd31134fd0b72a2842f31ecf8f237"
+  "gitHead": "201d3987b309fd1f383b10b5555dd0a2765cad43"
 }

package/rollup.config.js

@@ -2,7 +2,7 @@ import * as fs from 'fs'
 
 import terser from '@rollup/plugin-terser'
 
-const {name, version, license} = JSON.parse(fs.readFileSync('package.json'))
+const { name, version, license } = JSON.parse(fs.readFileSync('package.json'))
 
 export default {
   input: 'src/index.js',

package/src/colors/colorize.js

@@ -1,6 +1,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'
 import * as poly3 from '../geometries/poly3/index.js'
 
 const colorGeom2 = (color, object) => {
@@ -21,6 +23,18 @@ const colorPath2 = (color, object) => {
   return newPath2
 }
 
+const colorPath3 = (color, object) => {
+  const newPath3 = path3.clone(object)
+  newPath3.color = color
+  return newPath3
+}
+
+const colorSlice = (color, object) => {
+  const newSlice = slice.clone(object)
+  newSlice.color = color
+  return newSlice
+}
+
 const colorPoly3 = (color, object) => {
   const newPoly = poly3.clone(object)
   newPoly.color = color
@@ -46,9 +60,11 @@ export const colorize = (color, ...objects) => {
   if (color.length === 3) color = [color[0], color[1], color[2], 1.0] // add alpha
 
   const results = objects.map((object) => {
-    if (geom2.isA(object)) return colorGeom2(color, object)
     if (geom3.isA(object)) return colorGeom3(color, object)
+    if (geom2.isA(object)) return colorGeom2(color, object)
     if (path2.isA(object)) return colorPath2(color, object)
+    if (path3.isA(object)) return colorPath3(color, object)
+    if (slice.isA(object)) return colorSlice(color, object)
     if (poly3.isA(object)) return colorPoly3(color, object)
     if (Array.isArray(object)) return colorize(color, ...object)
 

package/src/colors/hsvToRgb.js

@@ -56,6 +56,7 @@ export const hsvToRgb = (...values) => {
       b = v
       break
     case 5:
+    default:
       r = v
       g = p
       b = q

package/src/colors/rgbToHsl.js

@@ -24,7 +24,8 @@ export const rgbToHsl = (...values) => {
   const l = (max + min) / 2
 
   if (max === min) {
-    h = s = 0 // achromatic
+    h = 0
+    s = 0 // achromatic
   } else {
     const d = max - min
     s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
@@ -36,6 +37,7 @@ export const rgbToHsl = (...values) => {
         h = (b - r) / d + 2
         break
       case b:
+      default:
         h = (r - g) / d + 4
         break
     }

package/src/colors/rgbToHsv.js

@@ -35,6 +35,7 @@ export const rgbToHsv = (...values) => {
         h = (b - r) / d + 2
         break
       case b:
+      default:
         h = (r - g) / d + 4
         break
     }

package/src/curves/bezier/create.js

@@ -51,7 +51,7 @@ const getPointType = function (points) {
       })
       pType = 'float_' + point.length
     } else throw new Error('Bezier points must all be numbers or arrays of number.')
-    if (firstPointType == null) {
+    if (firstPointType === null) {
       firstPointType = pType
     } else {
       if (firstPointType !== pType) {

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

@@ -0,0 +1,4 @@
+import type { Geom2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+
+declare function fromPoints(points: Array<Vec2>): Geom2

package/src/geometries/geom2/fromPoints.js

@@ -0,0 +1,28 @@
+import * as vec2 from '../../maths/vec2/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Create a new 2D geometry from the given points.
+ *
+ * The direction (rotation) of the points is not relevant,
+ * as the points can define a convex or a concave polygon.
+ *
+ * The geometry must not self intersect, i.e. the sides cannot cross.
+ * @param {Array} points - list of points in 2D space
+ * @returns {geom2} a new geometry
+ * @alias module:modeling/geom2.fromPoints
+ */
+export const fromPoints = (points) => {
+  if (!Array.isArray(points)) {
+    throw new Error('the given points must be an array')
+  }
+  const length = points.length
+  if (length < 3) {
+    throw new Error('the given points must define a closed geometry with three or more points')
+  }
+  // adjust length if the given points are closed by the same point
+  if (vec2.equals(points[0], points[length - 1])) points = points.slice(0, -1)
+
+  return create([points])
+}

package/src/geometries/geom2/fromPoints.test.js

@@ -0,0 +1,22 @@
+import test from 'ava'
+
+import { fromPoints } from './index.js'
+
+test('fromPoints: creates populated geom2', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const expected = {
+    outlines: [[[0, 0], [1, 0], [0, 1]]],
+    transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  t.deepEqual(fromPoints(points), expected)
+
+  const points2 = [[0, 0], [1, 0], [0, 1], [0, 0]]
+  t.deepEqual(fromPoints(points2), expected)
+})
+
+test('fromPoints: throws for improper points', (t) => {
+  t.throws(() => fromPoints(), { instanceOf: Error })
+  t.throws(() => fromPoints(0, 0), { instanceOf: Error })
+  t.throws(() => fromPoints([]), { instanceOf: Error })
+  t.throws(() => fromPoints([[0, 0]]), { instanceOf: Error })
+})

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

@@ -1,5 +1,6 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
+export { fromPoints } from './fromPoints.js'
 export { fromSides } from './fromSides.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/geom2/index.js

@@ -26,6 +26,7 @@
  */
 export { clone } from './clone.js'
 export { create } from './create.js'
+export { fromPoints } from './fromPoints.js'
 export { fromSides } from './fromSides.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/geom2/transform.js

@@ -18,6 +18,7 @@ import { reverse } from './reverse.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   const transformed = Object.assign({}, geometry, { transforms })
   // determine if the transform is mirroring in 2D
   if (matrix[0] * matrix[5] - matrix[4] * matrix[1] < 0) {

package/src/geometries/geom3/transform.js

@@ -17,5 +17,6 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   return Object.assign({}, geometry, { transforms })
 }

package/src/geometries/geom3/validate.js

@@ -22,7 +22,17 @@ export const validate = (object) => {
   }
 
   // check polygons
-  object.polygons.forEach(poly3.validate)
+  object.polygons.forEach((p, i) => {
+    if (p.vertices.length < 3) {
+      throw new Error(`invalid polygon ${i}: only ${p.vertices.length} vertices`)
+    }
+
+    try {
+      poly3.validate(p)
+    } catch (e) {
+      throw new Error(`invalid polygon ${i}: ${e}`)
+    }
+  })
   validateManifold(object)
 
   // check transforms

package/src/geometries/path2/appendArc.js

@@ -1,7 +1,7 @@
 import { TAU } from '../../maths/constants.js'
 import * as vec2 from '../../maths/vec2/index.js'
 
-import { fromPoints } from './fromPoints.js'
+import { appendPoints } from './appendPoints.js'
 import { toPoints } from './toPoints.js'
 
 /**
@@ -27,19 +27,19 @@ import { toPoints } from './toPoints.js'
  * myShape = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
  */
 export const appendArc = (options, geometry) => {
-  const defaults = {
-    radius: [0, 0], // X and Y radius
-    xaxisRotation: 0,
-    clockwise: false,
-    large: false,
-    segments: 16
-  }
-  let { endpoint, radius, xaxisRotation, clockwise, large, segments } = Object.assign({}, defaults, options)
+  const {
+    endpoint = null,
+    radius = [0, 0], // X and Y radius
+    xaxisRotation = 0,
+    clockwise = false,
+    large = false,
+    segments = 16
+  } = options
 
   // validate the given options
   if (!Array.isArray(endpoint)) throw new Error('endpoint must be an array of X and Y values')
-  if (endpoint.length < 2) throw new Error('endpoint must contain X and Y values')
-  endpoint = vec2.clone(endpoint)
+  if (endpoint.length !== 2) throw new Error('endpoint must contain X and Y values')
+  let xendPoint = vec2.clone(endpoint)
 
   if (!Array.isArray(radius)) throw new Error('radius must be an array of X and Y values')
   if (radius.length < 2) throw new Error('radius must contain X and Y values')
@@ -48,11 +48,6 @@ export const appendArc = (options, geometry) => {
 
   const decimals = 100000
 
-  // validate the given geometry
-  if (geometry.isClosed) {
-    throw new Error('the given path cannot be closed')
-  }
-
   const points = toPoints(geometry)
   if (points.length < 1) {
     throw new Error('the given path must contain one or more points (as the starting point for the arc)')
@@ -65,14 +60,14 @@ export const appendArc = (options, geometry) => {
   // round to precision in order to have determinate calculations
   xRadius = Math.round(xRadius * decimals) / decimals
   yRadius = Math.round(yRadius * decimals) / decimals
-  endpoint = vec2.fromValues(Math.round(endpoint[0] * decimals) / decimals, Math.round(endpoint[1] * decimals) / decimals)
+  xendPoint = vec2.fromValues(Math.round(xendPoint[0] * decimals) / decimals, Math.round(xendPoint[1] * decimals) / decimals)
 
   const sweepFlag = !clockwise
-  let newPoints = []
+  const newPoints = []
   if ((xRadius === 0) || (yRadius === 0)) {
     // http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes:
     // If rx = 0 or ry = 0, then treat this as a straight line from (x1, y1) to (x2, y2) and stop
-    newPoints.push(endpoint)
+    newPoints.push(xendPoint)
   } else {
     xRadius = Math.abs(xRadius)
     yRadius = Math.abs(yRadius)
@@ -81,7 +76,7 @@ export const appendArc = (options, geometry) => {
     const phi = xaxisRotation
     const cosPhi = Math.cos(phi)
     const sinPhi = Math.sin(phi)
-    const minusHalfDistance = vec2.subtract(vec2.create(), startpoint, endpoint)
+    const minusHalfDistance = vec2.subtract(vec2.create(), startpoint, xendPoint)
     vec2.scale(minusHalfDistance, minusHalfDistance, 0.5)
     // F.6.5.1:
     // round to precision in order to have determinate calculations
@@ -106,7 +101,7 @@ export const appendArc = (options, geometry) => {
     vec2.scale(centerTranslated, centerTranslated, multiplier1)
     // F.6.5.3:
     let center = vec2.fromValues(cosPhi * centerTranslated[0] - sinPhi * centerTranslated[1], sinPhi * centerTranslated[0] + cosPhi * centerTranslated[1])
-    center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, endpoint), 0.5))
+    center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, xendPoint), 0.5))
 
     // F.6.5.5:
     const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xRadius, (startTranslated[1] - centerTranslated[1]) / yRadius)
@@ -134,9 +129,8 @@ export const appendArc = (options, geometry) => {
       newPoints.push(point)
     }
     // ensure end point is precisely what user gave as parameter
-    if (numSteps) newPoints.push(options.endpoint)
+    if (numSteps) newPoints.push(endpoint)
   }
-  newPoints = points.concat(newPoints)
-  const result = fromPoints({}, newPoints)
-  return result
+
+  return appendPoints(newPoints, geometry)
 }

package/src/geometries/path2/appendBezier.js

@@ -1,6 +1,6 @@
 import { TAU } from '../../maths/constants.js'
 import * as vec2 from '../../maths/vec2/index.js'
-import * as vec3 from '../../maths/vec3/index.js' // FIXME why vec3?
+import * as vec3 from '../../maths/vec3/index.js' // required due to vec2.cross()
 
 import { appendPoints } from './appendPoints.js'
 import { toPoints } from './toPoints.js'
@@ -27,10 +27,10 @@ import { toPoints } from './toPoints.js'
  * myShape = path2.appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, myShape)
  */
 export const appendBezier = (options, geometry) => {
-  const defaults = {
-    segments: 16
-  }
-  let { controlPoints, segments } = Object.assign({}, defaults, options)
+  let {
+    controlPoints = null,
+    segments = 16
+  } = options
 
   // validate the given options
   if (!Array.isArray(controlPoints)) throw new Error('controlPoints must be an array of one or more points')
@@ -39,10 +39,6 @@ export const appendBezier = (options, geometry) => {
   if (segments < 4) throw new Error('segments must be four or more')
 
   // validate the given geometry
-  if (geometry.isClosed) {
-    throw new Error('the given geometry cannot be closed')
-  }
-
   const points = toPoints(geometry)
   if (points.length < 1) {
     throw new Error('the given path must contain one or more points (as the starting point for the bezier curve)')
@@ -148,9 +144,10 @@ export const appendBezier = (options, geometry) => {
   }
 
   // append to the new points to the given path
-  // but skip the first new point because it is identical to the last point in the given path
-  newPoints.shift()
   const result = appendPoints(newPoints, geometry)
+
+  // add a hint for the next bezier
   result.lastBezierControlPoint = controlPoints[controlPoints.length - 2]
+
   return result
 }

package/src/geometries/path2/appendPoints.js

@@ -1,5 +1,7 @@
-import { concat } from './concat.js'
-import { create } from './create.js'
+import { equals } from '../../maths/vec2/equals.js'
+
+import { fromPoints } from './fromPoints.js'
+import { toPoints } from './toPoints.js'
 
 /**
  * Append the given list of points to the end of the given geometry.
@@ -12,4 +14,20 @@ import { create } from './create.js'
  * @example
  * let newPath = path2.appendPoints([[3, 4], [4, 5]], oldPath)
  */
-export const appendPoints = (points, geometry) => concat(geometry, create(points))
+export const appendPoints = (points, geometry) => {
+  let originalPoints = toPoints(geometry)
+
+  if (geometry.isClosed && originalPoints.length > 1) {
+    // add the closing point to the originalPoints
+    originalPoints = originalPoints.slice()
+    originalPoints.push(originalPoints[0])
+  }
+
+  if (originalPoints.length > 0) {
+    // remove redundant points
+    const lastPoint = originalPoints[originalPoints.length - 1]
+    while (points.length > 0 && equals(points[0], lastPoint)) points.shift()
+  }
+
+  return fromPoints({}, originalPoints.concat(points))
+}

package/src/geometries/path2/appendPoints.test.js

@@ -12,10 +12,16 @@ test('appendPoints: appending to an empty path produces a new path with expected
 
 test('appendPoints: appending to a path produces a new path with expected points', (t) => {
   const p1 = fromPoints({}, [[1, 1], [2, 2]])
-  const obs = appendPoints([[3, 3], [4, 4]], p1)
-  const pts = toPoints(obs)
+  let obs = appendPoints([[3, 3], [4, 4]], p1)
+  let pts = toPoints(obs)
   t.not(p1, obs)
   t.is(pts.length, 4)
+
+  const p2 = fromPoints({ closed: true }, [[0, 0], [1, 0], [0, 1]])
+  obs = appendPoints([[0, -1], [0, -2]], p2)
+  pts = toPoints(obs)
+  t.not(p2, obs)
+  t.is(pts.length, 6)
 })
 
 test('appendPoints: appending empty points to a path produces a new path with expected points', (t) => {
@@ -28,8 +34,14 @@ test('appendPoints: appending empty points to a path produces a new path with ex
 
 test('appendPoints: appending same points to a path produces a new path with expected points', (t) => {
   const p1 = fromPoints({}, [[1, 1], [2, 2]])
-  const obs = appendPoints([[2, 2], [3, 3]], p1)
-  const pts = toPoints(obs)
+  let obs = appendPoints([[2, 2], [3, 3]], p1)
+  let pts = toPoints(obs)
   t.not(p1, obs)
   t.is(pts.length, 3)
+
+  const p2 = fromPoints({ closed: true }, [[0, 0], [1, 0], [0, 1]])
+  obs = appendPoints([[0, 0], [0, 0], [0, -1]], p2)
+  pts = toPoints(obs)
+  t.not(p2, obs)
+  t.is(pts.length, 5)
 })

package/src/geometries/path2/close.js

@@ -1,8 +1,6 @@
 import { EPS } from '../../maths/constants.js'
 
-import * as vec2 from '../../maths/vec2/index.js'
-
-import { clone } from './clone.js'
+import { distance } from '../../maths/vec2/distance.js'
 
 /**
  * Close the given geometry.
@@ -17,19 +15,18 @@ import { clone } from './clone.js'
 export const close = (geometry) => {
   if (geometry.isClosed) return geometry
 
-  const cloned = clone(geometry)
-  cloned.isClosed = true
-
-  if (cloned.points.length > 1) {
+  const isClosed = true
+  const points = geometry.points.slice()
+  if (points.length > 1) {
     // make sure the paths are formed properly
-    const points = cloned.points
     const p0 = points[0]
     let pn = points[points.length - 1]
-    while (vec2.distance(p0, pn) < (EPS * EPS)) {
+    while (distance(p0, pn) < EPS) {
       points.pop()
       if (points.length === 1) break
       pn = points[points.length - 1]
     }
   }
-  return cloned
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, geometry, { isClosed, points })
 }

package/src/geometries/path2/concat.js

@@ -1,4 +1,4 @@
-import { equals } from '../../maths/vec2/index.js'
+import { equals } from '../../maths/vec2/equals.js'
 
 import { fromPoints } from './fromPoints.js'
 import { toPoints } from './toPoints.js'
@@ -6,7 +6,7 @@ import { toPoints } from './toPoints.js'
 /**
  * Concatenate the given paths.
  *
- * If both contain the same point at the junction, merge it into one.
+ * If paths contain the same junction point, merge it into one.
  * A concatenation of zero paths is an empty, open path.
  * A concatenation of one closed path to a series of open paths produces a closed path.
  * A concatenation of a path to a closed path is an error.

package/src/geometries/path2/fromPoints.js

@@ -1,6 +1,6 @@
 import { EPS } from '../../maths/constants.js'
 
-import * as vec2 from '../../maths/vec2/index.js'
+import { distance } from '../../maths/vec2/distance.js'
 
 import { close } from './close.js'
 import { create } from './create.js'
@@ -18,20 +18,20 @@ import { create } from './create.js'
  * @alias module:modeling/path2.fromPoints
  *
  * @example
- * my newPath = path2.fromPoints({closed: true}, [[10, 10], [-10, 10]])
+ * let newPath = path2.fromPoints({closed: true}, [[10, 10], [-10, 10]])
  */
 export const fromPoints = (options, points) => {
-  const defaults = { closed: false }
-  let { closed } = Object.assign({}, defaults, options)
+  let {
+    closed = false
+  } = options
 
-  let created = create()
-  created.points = points.map((point) => vec2.clone(point))
+  let created = create(points.slice())
 
   // check if first and last points are equal
   if (created.points.length > 1) {
     const p0 = created.points[0]
     const pn = created.points[created.points.length - 1]
-    if (vec2.distance(p0, pn) < (EPS * EPS)) {
+    if (distance(p0, pn) < EPS) {
       // and close automatically
       closed = true
     }

package/src/geometries/path2/reverse.js

@@ -14,7 +14,7 @@ import { clone } from './clone.js'
  */
 export const reverse = (geometry) => {
   // NOTE: this only updates the order of the points
-  const cloned = clone(geometry)
-  cloned.points = geometry.points.slice().reverse()
-  return cloned
+  const points = geometry.points.slice().reverse()
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, geometry, { points })
 }

package/src/geometries/path2/transform.js

@@ -16,5 +16,6 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   return Object.assign({}, geometry, { transforms })
 }

package/src/geometries/path2/validate.js

@@ -1,4 +1,4 @@
-import * as vec2 from '../../maths/vec2/index.js'
+import { equals } from '../../maths/vec2/equals.js'
 
 import { isA } from './isA.js'
 
@@ -24,7 +24,7 @@ export const validate = (object) => {
   // check for duplicate points
   if (object.points.length > 1) {
     for (let i = 0; i < object.points.length; i++) {
-      if (vec2.equals(object.points[i], object.points[(i + 1) % object.points.length])) {
+      if (equals(object.points[i], object.points[(i + 1) % object.points.length])) {
         throw new Error(`path2 has duplicate point ${object.points[i]}`)
       }
     }

package/src/geometries/path3/clone.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function clone(geometry: Path3): Path3

package/src/geometries/path3/clone.js

@@ -0,0 +1,11 @@
+/**
+ * Performs a shallow clone of the give geometry.
+ *
+ * @param {Path3} geometry - the geometry to clone
+ * @returns {Path3} a new path
+ * @alias module:modeling/path3.clone
+ *
+ * @example
+ * let newPath = path3.clone(oldPath)
+ */
+export const clone = (geometry) => Object.assign({}, geometry)

package/src/geometries/path3/close.js

@@ -1,6 +1,6 @@
 import { EPS } from '../../maths/constants.js'
 
-import * as vec3 from '../../maths/vec3/index.js'
+import { distance } from '../../maths/vec3/distance.js'
 
 /**
  * Close the given geometry.
@@ -15,19 +15,18 @@ import * as vec3 from '../../maths/vec3/index.js'
 export const close = (geometry) => {
   if (geometry.isClosed) return geometry
 
-  const cloned = Object.assign({}, geometry)
-  cloned.isClosed = true
-
-  if (cloned.vertices.length > 1) {
+  const isClosed = true
+  const vertices = geometry.vertices.slice()
+  if (vertices.length > 1) {
     // make sure the paths are formed properly
-    const vertices = cloned.vertices
     const p0 = vertices[0]
     let pn = vertices[vertices.length - 1]
-    while (vec3.distance(p0, pn) < (EPS * EPS)) {
+    while (distance(p0, pn) < EPS) {
       vertices.pop()
       if (vertices.length === 1) break
       pn = vertices[vertices.length - 1]
     }
   }
-  return cloned
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, geometry, { isClosed, vertices })
 }

package/src/geometries/path3/index.d.ts

@@ -1,3 +1,4 @@
+export { clone } from './clone.js'
 export { close } from './close.js'
 export { concat } from './concat.js'
 export { create } from './create.js'

package/src/geometries/path3/index.js

@@ -24,6 +24,7 @@
  * }
  */
 
+export { clone } from './clone.js'
 export { close } from './close.js'
 export { concat } from './concat.js'
 export { create } from './create.js'

package/src/geometries/path3/transform.js

@@ -16,5 +16,6 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   return Object.assign({}, geometry, { transforms })
 }