docs(all): changes from lint

z3dev · z3dev · commit 2f9a52873786 · 2026-02-23T15:41:19.000+09:00
diff --git a/jsdoc.json b/jsdoc.json
@@ -28,6 +28,7 @@
       "packages/modeling/src/operations/offsets",
       "packages/modeling/src/operations/extrusions",
       "packages/modeling/src/operations/hulls",
+      "packages/modeling/src/operations/minkowski",
       "packages/modeling/src/operations/modifiers",
       "packages/modeling/src/operations/transforms",
       "packages/modeling/src/primitives",
diff --git a/packages/io/dxf-deserializer/src/index.js b/packages/io/dxf-deserializer/src/index.js
@@ -596,7 +596,7 @@ const deserialize = (options, src) => {
   }
   options = Object.assign({}, defaults, options)
 
-  src = ensureString(src);
+  src = ensureString(src)
   return options.output === 'script' ? translate(src, options) : instantiate(src, options)
 }
 
diff --git a/packages/io/dxf-deserializer/tests/test-2d-entities.js b/packages/io/dxf-deserializer/tests/test-2d-entities.js
@@ -110,11 +110,11 @@ test('ASCII DXF 2D Donuts from Autocad 2017 to Object Conversion', (t) => {
   t.is(objs.length, 23)
   // NOTE: the extra ojbects are from the page layout
   t.true(path2.isA(objs[20]))
-  t.is(path2.toPoints(objs[20]).length, 18) // line
+  t.is(path2.toPoints(objs[20]).length, 16) // line
   t.true(path2.isA(objs[21]))
-  t.is(path2.toPoints(objs[21]).length, 18) // line
+  t.is(path2.toPoints(objs[21]).length, 16) // line
   t.true(path2.isA(objs[22]))
-  t.is(path2.toPoints(objs[22]).length, 18) // arc
+  t.is(path2.toPoints(objs[22]).length, 16) // arc
 })
 
 test('ASCII DXF 2D Ellipses from Autocad 2017 to Object Conversion', (t) => {
diff --git a/packages/io/dxf-serializer/tests/path2ToDxf.test.js b/packages/io/dxf-serializer/tests/path2ToDxf.test.js
@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { arc, path2 } from '@jscad/modeling'
+import { arc, path2, TAU } from '@jscad/modeling'
 
 import { serialize } from '../src/index.js'
 import { dxfHeaders, dxfClasses, dxfTables, dxfBlocks, dxfObjects } from '../src/autocad_AC2017.js'
@@ -12,7 +12,7 @@ test('2D Path to DXF LWPOLYLINE', (t) => {
   const exp1 = [empty]
   t.deepEqual(obs1, exp1)
 
-  const p2 = arc({ center: [5, 5], endAngle: 45, segments: 16 })
+  const p2 = arc({ center: [5, 5], endAngle: TAU / 4, segments: 16 })
 
   const obs2 = serialize({}, p2)
   const exp2 = [lwpolyline0]
@@ -74,25 +74,29 @@ CAD00001
   100
 AcDbPolyline
   90
-4
+5
   70
 0
   10
 6
   20
 5
   10
-5.943009745777588
+5.923879532511287
   20
-5.33276511140516
+5.38268343236509
   10
-5.778534761263023
+5.707106781186548
   20
-5.627601486219662
+5.707106781186548
   10
-5.525321988817728
+5.38268343236509
   20
-5.850903524534119
+5.923879532511287
+  10
+5
+  20
+6
   0
 ENDSEC
 ${dxfObjects({})}
diff --git a/packages/io/io-utils/src/ensureString.js b/packages/io/io-utils/src/ensureString.js
@@ -5,8 +5,8 @@
  */
 export const ensureString = (stringOrArrayBuffer, defaultBinaryEncoding = 'utf-8') => {
   if (typeof (stringOrArrayBuffer) === 'string') {
-    return stringOrArrayBuffer;
+    return stringOrArrayBuffer
   }
 
-  return new TextDecoder(defaultBinaryEncoding).decode(new Uint8Array(stringOrArrayBuffer));
+  return new TextDecoder(defaultBinaryEncoding).decode(new Uint8Array(stringOrArrayBuffer))
 }
diff --git a/packages/io/json-deserializer/src/index.js b/packages/io/json-deserializer/src/index.js
@@ -39,7 +39,7 @@ const deserialize = (options, input) => {
   options = Object.assign({}, defaults, options)
 
   // convert the JSON notation into anonymous object(s)
-  input = ensureString(input);
+  input = ensureString(input)
   let objects = JSON.parse(input)
 
   // cleanup the objects
diff --git a/packages/io/json-serializer/tests/path2ToJson.test.js b/packages/io/json-serializer/tests/path2ToJson.test.js
@@ -19,22 +19,22 @@ test('2D Path to JSON', (t) => {
   const obs1 = serialize({}, path1)
   t.is(countOf('points', obs1[0]), 1)
   t.is(countOf('transforms', obs1[0]), 1)
-  t.is(countOf('[', obs1[0]), 7)
-  t.is(countOf(']', obs1[0]), 7)
-  t.is(countOf(',', obs1[0]), 24)
+  t.is(countOf('[', obs1[0]), 6)
+  t.is(countOf(']', obs1[0]), 6)
+  t.is(countOf(',', obs1[0]), 22)
 
   const path2 = arc({ segments: 72 })
   const obs2 = serialize({}, path2)
   t.is(countOf('points', obs2[0]), 1)
   t.is(countOf('transforms', obs2[0]), 1)
-  t.is(countOf('[', obs2[0]), 76)
-  t.is(countOf(']', obs2[0]), 76)
-  t.is(countOf(',', obs2[0]), 162)
+  t.is(countOf('[', obs2[0]), 75)
+  t.is(countOf(']', obs2[0]), 75)
+  t.is(countOf(',', obs2[0]), 160)
 
   const obs3 = serialize({}, [path1, path2])
   t.is(countOf('points', obs3[0]), 2)
   t.is(countOf('transforms', obs3[0]), 2)
-  t.is(countOf('[', obs3[0]), 82)
-  t.is(countOf(']', obs3[0]), 82)
-  t.is(countOf(',', obs3[0]), 187)
+  t.is(countOf('[', obs3[0]), 80)
+  t.is(countOf(']', obs3[0]), 80)
+  t.is(countOf(',', obs3[0]), 183)
 })
diff --git a/packages/io/svg-deserializer/tests/instantiate.test.js b/packages/io/svg-deserializer/tests/instantiate.test.js
@@ -246,21 +246,21 @@ test('deserialize : instantiate svg (path: arc) to objects', (t) => {
   t.is(observed.length, 2)
   let shape = observed[0]
   t.is(shape.outlines.length, 1)
-  t.is(shape.outlines[0].length, 27)
+  t.is(shape.outlines[0].length, 26)
 
   observed = deserialize({ output: 'geometry', target: 'path', addMetaData: false }, sourceSvg)
   t.is(observed.length, 2)
   shape = observed[0]
-  t.is(shape.points.length, 27)
+  t.is(shape.points.length, 26)
 
   observed = deserialize({ output: 'geometry', target: 'path', addMetaData: false, segments: 16 }, sourceSvg)
   t.is(observed.length, 2)
   shape = observed[0]
-  t.is(shape.points.length, 15) // segments double on a 3/4 circle
-  t.deepEqual(measureBoundingBox(shape), [[64.91110599999999, -77.611105, 0], [90.21850570104527, -52.30370029895471, 0]])
+  t.is(shape.points.length, 14) // segments double on a 3/4 circle
+  t.deepEqual(measureBoundingBox(shape), [[64.91110599999999, -77.611105, 0], [90.31110299999999, -52.211102999999994, 0]])
   shape = observed[1]
-  t.is(shape.points.length, 15) // segments double on a 3/4 circle
-  t.deepEqual(measureBoundingBox(shape), [[50.799996, -136.03302387090216, 0], [72.27222493929787, -110.6793647936299, 0]])
+  t.is(shape.points.length, 14) // segments double on a 3/4 circle
+  t.deepEqual(measureBoundingBox(shape), [[50.799996, -136.05619433226602, 0], [72.48025212106914, -110.65619433226604, 0]])
 })
 
 // ################################
@@ -443,15 +443,15 @@ test('deserialize : instantiate shape with a hole to objects', (t) => {
   t.is(observed.length, 1)
   let shape = observed[0]
   t.is(shape.outlines.length, 2)
-  t.is(shape.outlines[0].length, 38)
-  t.is(shape.outlines[1].length, 38)
+  t.is(shape.outlines[0].length, 30)
+  t.is(shape.outlines[1].length, 30)
 
   observed = deserialize({ output: 'geometry', target: 'path', addMetaData: false }, sourceSvg)
   t.is(observed.length, 2)
   shape = observed[0]
-  t.is(shape.points.length, 38)
+  t.is(shape.points.length, 30)
   shape = observed[1]
-  t.is(shape.points.length, 38)
+  t.is(shape.points.length, 30)
 })
 
 // ################################
@@ -467,12 +467,12 @@ test('deserialize : instantiate shape with a nested hole to objects', (t) => {
   t.is(observed.length, 1)
   let shape = observed[0]
   t.is(shape.outlines.length, 4)
-  t.is(shape.outlines[0].length, 38)
+  t.is(shape.outlines[0].length, 30)
 
   observed = deserialize({ output: 'geometry', target: 'path', addMetaData: false }, sourceSvg)
   t.is(observed.length, 4)
   shape = observed[0]
-  t.is(shape.points.length, 38)
+  t.is(shape.points.length, 30)
 })
 
 // ################################
diff --git a/packages/modeling/src/geometries/path2/appendArc.js b/packages/modeling/src/geometries/path2/appendArc.js
@@ -120,7 +120,7 @@ export const appendArc = (options, geometry) => {
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numSteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
+    let numSteps = Math.floor(segments * (Math.abs(deltatheta) / TAU))
     if (numSteps < 1) numSteps = 1
     for (let step = 1; step < numSteps; step++) {
       const theta = theta1 + step / numSteps * deltatheta
diff --git a/packages/modeling/src/geometries/path2/appendArc.test.js b/packages/modeling/src/geometries/path2/appendArc.test.js
@@ -23,47 +23,43 @@ test('appendArc: appending to a path produces a new path', (t) => {
   const p2 = fromPoints({}, [[27, -22], [27, -3]])
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20] }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 7)
+  t.is(pts.length, 5)
 
   // test segments
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], segments: 64 }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 19)
+  t.is(pts.length, 17)
 
   // test clockwise
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], clockwise: true }, p2)
   pts = toPoints(obs)
   let exp = [
     [27, -22],
     [27, -3],
-    [26.086451657912605, -8.941047736250177],
-    [23.87938869625451, -14.243872270248309],
-    [20.58174906029909, -18.420882475791835],
-    [16.49674848226545, -21.0880050920699],
-    [11.999999999999998, -22]
+    [24.7485593841743, -12.579008396887021],
+    [19.29019838402471, -19.492932330409836],
+    [12, -22]
   ]
-  t.is(pts.length, 7)
+  t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 
   // test large
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], large: true }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 16)
+  t.is(pts.length, 14)
 
   // test xaxisRotation
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisRotation: TAU / 4 }, p2)
   pts = toPoints(obs)
   exp = [
     [27, -22],
     [27, -3],
-    [21.830323320631795, -4.401628923214028],
-    [17.364704977487236, -6.805886946199115],
+    [19.486852090983938, -5.488140907400943],
     [13.940501387124588, -10.031143708098092],
-    [11.816394990371812, -13.833746263211978],
-    [11.15285201325494, -17.926425912558045],
-    [12, -22.000000000000004]
+    [11.296247566821858, -15.862906638006239],
+    [12, -22]
   ]
-  t.is(pts.length, 8)
+  t.is(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
   // test small arc between far points
diff --git a/packages/modeling/src/geometries/poly3/measureBoundingSphere.js b/packages/modeling/src/geometries/poly3/measureBoundingSphere.js
@@ -1,5 +1,3 @@
-import * as vec4 from '../../maths/vec4/index.js'
-
 const cache = new WeakMap()
 
 /**
diff --git a/packages/modeling/src/operations/booleans/trees/splitLineSegmentByPlane.js b/packages/modeling/src/operations/booleans/trees/splitLineSegmentByPlane.js
@@ -4,10 +4,7 @@ export const splitLineSegmentByPlane = (plane, p1, p2) => {
   const direction = vec3.subtract(vec3.create(), p2, p1)
   let lambda = (plane[3] - vec3.dot(plane, p1)) / vec3.dot(plane, direction)
 
-  Number.isNaN(lambda) ? lambda = 0
-    : lambda > 1 ? lambda = 1
-      : lambda < 0 ? lambda = 0
-        : lambda
+  Number.isNaN(lambda) ? lambda = 0 : lambda > 1 ? lambda = 1 : lambda < 0 ? lambda = 0 : lambda
 
   vec3.scale(direction, direction, lambda)
   vec3.add(direction, p1, direction)
diff --git a/packages/modeling/src/operations/extrusions/extrudeFromSlices.js b/packages/modeling/src/operations/extrusions/extrudeFromSlices.js
@@ -59,7 +59,7 @@ export const extrudeFromSlices = (options, base) => {
   let startSlice = null
   let endSlice = null
   let prevSlice = null
-  let polygons = []
+  const polygons = []
   for (let s = 0; s < numberOfSlices; s++) {
     // invoke the callback function to get the next slice
     // NOTE: callback can return null to skip the slice
diff --git a/packages/modeling/src/operations/extrusions/extrudeRotate.test.js b/packages/modeling/src/operations/extrusions/extrudeRotate.test.js
@@ -198,7 +198,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
 // This ensures the optimization of computing xRotationMatrix once doesn't break anything
 test('extrudeRotate: (mat4 reuse) rotation matrices produce correct geometry', (t) => {
   // Simple rectangle that will be rotated to form a tube-like shape
-  const geometry2 = geom2.create([[ [6, 1], [5, 1], [5, -1], [6, -1] ]])
+  const geometry2 = geom2.create([[[6, 1], [5, 1], [5, -1], [6, -1]]])
 
   // Full rotation with many segments to test matrix reuse across iterations
   const geometry3 = extrudeRotate({ segments: 32 }, geometry2)
@@ -218,11 +218,10 @@ test('extrudeRotate: (mat4 reuse) rotation matrices produce correct geometry', (
 
 // Test for mat4 reuse with partial rotation (tests both capped and matrix reuse)
 test('extrudeRotate: (mat4 reuse) partial rotation produces correct caps', (t) => {
-  const geometry2 = geom2.create([[ [6, 1], [5, 1], [5, -1], [6, -1] ]])
+  const geometry2 = geom2.create([[[6, 1], [5, 1], [5, -1], [6, -1]]])
 
   // Quarter rotation - should have start and end caps
   const obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry2)
-  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 53.232491234231944)
diff --git a/packages/modeling/src/operations/extrusions/extrudeWalls.test.js b/packages/modeling/src/operations/extrusions/extrudeWalls.test.js
@@ -73,7 +73,7 @@ test('extrudeWalls (repartitionEdges vec3 reuse)', (t) => {
     [-8.66, -5, 0],
     [0, -10, 0],
     [8.66, -5, 0],
-    [8.66, 5, 0],
+    [8.66, 5, 0]
   ]])
 
   // Triangle to hexagon requires repartitioning (3 -> 6 edges)
@@ -107,7 +107,7 @@ test('extrudeWalls (repartitionEdges with high multiple)', (t) => {
     [0, -5, 0],
     [3.54, -3.54, 0],
     [5, 0, 0],
-    [3.54, 3.54, 0],
+    [3.54, 3.54, 0]
   ]])
 
   // Square to octagon requires repartitioning (4 -> 8 edges)
diff --git a/packages/modeling/src/operations/minkowski/minkowskiSum.js b/packages/modeling/src/operations/minkowski/minkowskiSum.js
@@ -111,7 +111,9 @@ const decomposeIntoTetrahedra = (geometry) => {
     const vertices = polygon.vertices
 
     // Compute polygon center
-    let cx = 0, cy = 0, cz = 0
+    let cx = 0
+    let cy = 0
+    let cz = 0
     for (let k = 0; k < vertices.length; k++) {
       cx += vertices[k][0]
       cy += vertices[k][1]
@@ -123,7 +125,9 @@ const decomposeIntoTetrahedra = (geometry) => {
 
     // Get polygon plane (normal + offset)
     const plane = poly3.plane(polygon)
-    const nx = plane[0], ny = plane[1], nz = plane[2]
+    const nx = plane[0]
+    const ny = plane[1]
+    const nz = plane[2]
 
     // Offset inward along negative normal to create face-local apex
     // The normal points outward, so we go in the negative direction
@@ -153,17 +157,15 @@ const decomposeIntoTetrahedra = (geometry) => {
 
 /**
  * Create the 4 triangular faces of a tetrahedron.
+ *
+ * Tetrahedron has 4 faces, each a triangle
  */
-const createTetrahedronPolygons = (p0, p1, p2, p3) => {
-  // Tetrahedron has 4 faces, each a triangle
-  // We need to ensure consistent winding (outward-facing normals)
-  return [
-    poly3.create([p0, p2, p1]), // base seen from p3
-    poly3.create([p0, p1, p3]), // face opposite p2
-    poly3.create([p1, p2, p3]), // face opposite p0
-    poly3.create([p2, p0, p3])  // face opposite p1
-  ]
-}
+const createTetrahedronPolygons = (p0, p1, p2, p3) => [
+  poly3.create([p0, p2, p1]), // base seen from p3
+  poly3.create([p0, p1, p3]), // face opposite p2
+  poly3.create([p1, p2, p3]), // face opposite p0
+  poly3.create([p2, p0, p3]) // face opposite p1
+]
 
 /**
  * Compute Minkowski sum of two convex polyhedra.
diff --git a/packages/modeling/src/operations/modifiers/snap.test.js b/packages/modeling/src/operations/modifiers/snap.test.js
diff --git a/packages/modeling/src/primitives/arc.js b/packages/modeling/src/primitives/arc.js
diff --git a/packages/modeling/src/primitives/arc.test.js b/packages/modeling/src/primitives/arc.test.js

Original file line number	Diff line number	Diff line change
`@@ -596,7 +596,7 @@ const deserialize = (options, src) => {`
`596`	`596`	`}`
`597`	`597`	`options = Object.assign({}, defaults, options)`
`598`	`598`
`599`		`- src = ensureString(src);`
	`599`	`+ src = ensureString(src)`
`600`	`600`	`return options.output === 'script' ? translate(src, options) : instantiate(src, options)`
`601`	`601`	`}`
`602`	`602`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`import test from 'ava'`
`2`	`2`
`3`		`-import { arc, path2 } from '@jscad/modeling'`
	`3`	`+import { arc, path2, TAU } from '@jscad/modeling'`
`4`	`4`
`5`	`5`	`import { serialize } from '../src/index.js'`
`6`	`6`	`import { dxfHeaders, dxfClasses, dxfTables, dxfBlocks, dxfObjects } from '../src/autocad_AC2017.js'`
`@@ -12,7 +12,7 @@ test('2D Path to DXF LWPOLYLINE', (t) => {`
`12`	`12`	`const exp1 = [empty]`
`13`	`13`	`t.deepEqual(obs1, exp1)`
`14`	`14`
`15`		`- const p2 = arc({ center: [5, 5], endAngle: 45, segments: 16 })`
	`15`	`+ const p2 = arc({ center: [5, 5], endAngle: TAU / 4, segments: 16 })`
`16`	`16`
`17`	`17`	`const obs2 = serialize({}, p2)`
`18`	`18`	`const exp2 = [lwpolyline0]`
`@@ -74,25 +74,29 @@ CAD00001`
`74`	`74`	`100`
`75`	`75`	`AcDbPolyline`
`76`	`76`	`90`
`77`		`-4`
	`77`	`+5`
`78`	`78`	`70`
`79`	`79`	`0`
`80`	`80`	`10`
`81`	`81`	`6`
`82`	`82`	`20`
`83`	`83`	`5`
`84`	`84`	`10`
`85`		`-5.943009745777588`
	`85`	`+5.923879532511287`
`86`	`86`	`20`
`87`		`-5.33276511140516`
	`87`	`+5.38268343236509`
`88`	`88`	`10`
`89`		`-5.778534761263023`
	`89`	`+5.707106781186548`
`90`	`90`	`20`
`91`		`-5.627601486219662`
	`91`	`+5.707106781186548`
`92`	`92`	`10`
`93`		`-5.525321988817728`
	`93`	`+5.38268343236509`
`94`	`94`	`20`
`95`		`-5.850903524534119`
	`95`	`+5.923879532511287`
	`96`	`+ 10`
	`97`	`+5`
	`98`	`+ 20`
	`99`	`+6`
`96`	`100`	`0`
`97`	`101`	`ENDSEC`
`98`	`102`	`${dxfObjects({})}`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,8 @@`
`5`	`5`	`*/`
`6`	`6`	`export const ensureString = (stringOrArrayBuffer, defaultBinaryEncoding = 'utf-8') => {`
`7`	`7`	`if (typeof (stringOrArrayBuffer) === 'string') {`
`8`		`- return stringOrArrayBuffer;`
	`8`	`+ return stringOrArrayBuffer`
`9`	`9`	`}`
`10`	`10`
`11`		`- return new TextDecoder(defaultBinaryEncoding).decode(new Uint8Array(stringOrArrayBuffer));`
	`11`	`+ return new TextDecoder(defaultBinaryEncoding).decode(new Uint8Array(stringOrArrayBuffer))`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ export const appendArc = (options, geometry) => {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`// Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse`
`123`		`- let numSteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1`
	`123`	`+ let numSteps = Math.floor(segments * (Math.abs(deltatheta) / TAU))`
`124`	`124`	`if (numSteps < 1) numSteps = 1`
`125`	`125`	`for (let step = 1; step < numSteps; step++) {`
`126`	`126`	`const theta = theta1 + step / numSteps * deltatheta`