@jscad/modeling 2.12.4 → 2.12.6

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.12.6](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.12.5...@jscad/modeling@2.12.6) (2025-09-20)
+
+
+### Bug Fixes
+
+* **modeling:** corrected handling of pitch vs height in extrudeHelical ([074f05a](https://github.com/jscad/OpenJSCAD.org/commit/074f05aa5432fbdc8277088e9a45f003f2f978c7))
+
+
+
+
+
+## [2.12.5](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.12.4...@jscad/modeling@2.12.5) (2024-12-29)
+
+**Note:** Version bump only for package @jscad/modeling
+
+
+
+
+
 ## [2.12.4](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.12.3...@jscad/modeling@2.12.4) (2024-11-10)
 
 **Note:** Version bump only for package @jscad/modeling

package/LICENSE

@@ -1,7 +1,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2021 JSCAD Organization
+Copyright (c) 2017-2024 JSCAD Organization
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/jscad-modeling.min.js

@@ -923,7 +923,7 @@ const pointInTriangle=(n,a,e,r,i,o,t,x)=>(i-t)*(a-x)-(n-t)*(o-x)>=0&&(n-t)*(r-x)
 const mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),repairSlice=require("./slice/repair"),extrudeWalls=require("./extrudeWalls"),defaultCallback=(e,r,l)=>{let t=null;return geom2.isA(l)&&(t=slice.fromSides(geom2.toSides(l))),poly3.isA(l)&&(t=slice.fromPoints(poly3.toPoints(l))),0===e||1===e?slice.transform(mat4.fromTranslation(mat4.create(),[0,0,e]),t):null},extrudeFromSlices=(e,r)=>{const l={numberOfSlices:2,capStart:!0,capEnd:!0,close:!1,repair:!0,callback:defaultCallback},{numberOfSlices:t,capStart:o,capEnd:c,close:s,repair:i,callback:a}=Object.assign({},l,e);if(t<2)throw new Error("numberOfSlices must be 2 or more");i&&(r=repairSlice(r));const n=t-1;let u=null,m=null,f=null,g=[];for(let e=0;e<t;e++){const l=a(e/n,e,r);if(l){if(!slice.isA(l))throw new Error("the callback function must return slice objects");if(0===slice.toEdges(l).length)throw new Error("the callback function must return slices with one or more edges");f&&(g=g.concat(extrudeWalls(f,l))),0===e&&(u=l),e===t-1&&(m=l),f=l}}if(c){const e=slice.toPolygons(m);g=g.concat(e)}if(o){const e=slice.toPolygons(u).map(poly3.invert);g=g.concat(e)}return o||c||s&&!slice.equals(m,u)&&(g=g.concat(extrudeWalls(m,u))),geom3.create(g)};module.exports=extrudeFromSlices;
 
 },{"../../geometries/geom2":25,"../../geometries/geom3":41,"../../geometries/poly3":79,"../../maths/mat4":143,"./extrudeWalls":317,"./slice":326,"./slice/repair":328}],309:[function(require,module,exports){
-const{TAU:TAU}=require("../../maths/constants"),slice=require("./slice"),mat4=require("../../maths/mat4"),extrudeFromSlices=require("./extrudeFromSlices"),geom2=require("../../geometries/geom2"),extrudeHelical=(e,t)=>{const r={angle:TAU,startAngle:0,pitch:10,endOffset:0,segmentsPerRotation:32},{angle:a,endOffset:s,segmentsPerRotation:o,startAngle:i}=Object.assign({},r,e);let n;n=!e.pitch&&e.height?e.height/(a/TAU):e.pitch?e.pitch:r.pitch;if(o<3)throw new Error("The number of segments per rotation needs to be at least 3.");const m=geom2.toSides(t);if(0===m.length)throw new Error("the given geometry cannot be empty");const c=m.filter(e=>e[0][0]>=0);let l=slice.fromSides(m);0===c.length&&(l=slice.reverse(l));const h=Math.round(o/TAU*Math.abs(a)),g=h>=2?h:2,u=mat4.create();let f;return extrudeFromSlices({numberOfSlices:g+1,callback:(e,t,r)=>{const o=i+a/g*t,m=s/g*t,c=(o-i)/TAU*n;return mat4.multiply(u,mat4.fromTranslation(mat4.create(),[m,0,c*Math.sign(a)]),mat4.fromXRotation(mat4.create(),-TAU/4*Math.sign(a))),f=mat4.create(),mat4.multiply(f,mat4.fromZRotation(mat4.create(),o),u),slice.transform(f,r)}},l)};module.exports=extrudeHelical;
+const{TAU:TAU}=require("../../maths/constants"),mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),extrudeFromSlices=require("./extrudeFromSlices"),slice=require("./slice"),extrudeHelical=(e,t)=>{const r={angle:TAU,startAngle:0,pitch:10,height:0,endOffset:0,segmentsPerRotation:32};let{angle:a,startAngle:s,pitch:o,height:n,endOffset:i,segmentsPerRotation:m}=Object.assign({},r,e);0!=n&&(o=n/(a/TAU));if(m<3)throw new Error("The number of segments per rotation needs to be at least 3.");const l=geom2.toSides(t);if(0===l.length)throw new Error("The given geometry cannot be empty");const c=l.filter(e=>e[0][0]>=0);let g=slice.fromSides(l);0===c.length&&(g=slice.reverse(g));const h=Math.round(m/TAU*Math.abs(a)),u=h>=2?h:2,f=mat4.create(),d=mat4.create();return extrudeFromSlices({numberOfSlices:u+1,callback:(e,t,r)=>{const n=s+a/u*t,m=i/u*t,l=(n-s)/TAU*o;return mat4.multiply(f,mat4.fromTranslation(mat4.create(),[m,0,l*Math.sign(a)]),mat4.fromXRotation(mat4.create(),-TAU/4*Math.sign(a))),mat4.multiply(d,mat4.fromZRotation(mat4.create(),n),f),slice.transform(d,r)}},g)};module.exports=extrudeHelical;
 
 },{"../../geometries/geom2":25,"../../maths/constants":94,"../../maths/mat4":143,"./extrudeFromSlices":308,"./slice":326}],310:[function(require,module,exports){
 const flatten=require("../../utils/flatten"),geom2=require("../../geometries/geom2"),path2=require("../../geometries/path2"),extrudeLinearGeom2=require("./extrudeLinearGeom2"),extrudeLinearPath2=require("./extrudeLinearPath2"),extrudeLinear=(e,...t)=>{const{height:r,twistAngle:i,twistSteps:n,repair:a}=Object.assign({},{height:1,twistAngle:0,twistSteps:1,repair:!0},e);if(0===(t=flatten(t)).length)throw new Error("wrong number of arguments");e={offset:[0,0,r],twistAngle:i,twistSteps:n,repair:a};const s=t.map(t=>path2.isA(t)?extrudeLinearPath2(e,t):geom2.isA(t)?extrudeLinearGeom2(e,t):t);return 1===s.length?s[0]:s};module.exports=extrudeLinear;
@@ -1163,7 +1163,7 @@ const rectangle=require("./rectangle"),{isGTE:isGTE}=require("./commonChecks"),s
 const{TAU:TAU}=require("../maths/constants"),vec2=require("../maths/vec2"),geom2=require("../geometries/geom2"),{isGT:isGT,isGTE:isGTE,isNumberArray:isNumberArray}=require("./commonChecks"),getRadiusRatio=(e,r)=>e>0&&r>1&&r<e/2?Math.cos(Math.PI*r/e)/Math.cos(Math.PI*(r-1)/e):0,getPoints=(e,r,t,s)=>{const o=TAU/e,i=[];for(let a=0;a<e;a++){const e=vec2.fromAngleRadians(vec2.create(),o*a+t);vec2.scale(e,e,r),vec2.add(e,s,e),i.push(e)}return i},star=e=>{let{center:r,vertices:t,outerRadius:s,innerRadius:o,density:i,startAngle:a}=Object.assign({},{center:[0,0],vertices:5,outerRadius:1,innerRadius:0,density:2,startAngle:0},e);if(!isNumberArray(r,2))throw new Error("center must be an array of X and Y values");if(!isGTE(t,2))throw new Error("vertices must be two or more");if(!isGT(s,0))throw new Error("outerRadius must be greater than zero");if(!isGTE(o,0))throw new Error("innerRadius must be greater than zero");if(!isGTE(a,0))throw new Error("startAngle must be greater than zero");if(t=Math.floor(t),i=Math.floor(i),a%=TAU,0===o){if(!isGTE(i,2))throw new Error("density must be two or more");o=s*getRadiusRatio(t,i)}const n=vec2.clone(r),u=getPoints(t,s,a,n),c=getPoints(t,o,a+Math.PI/t,n),h=[];for(let e=0;e<t;e++)h.push(u[e]),h.push(c[e]);return geom2.fromPoints(h)};module.exports=star;
 
 },{"../geometries/geom2":25,"../maths/constants":94,"../maths/vec2":191,"./commonChecks":370}],389:[function(require,module,exports){
-const{TAU:TAU}=require("../maths/constants"),extrudeRotate=require("../operations/extrusions/extrudeRotate"),{rotate:rotate}=require("../operations/transforms/rotate"),{translate:translate}=require("../operations/transforms/translate"),circle=require("./circle"),{isGT:isGT,isGTE:isGTE}=require("./commonChecks"),torus=e=>{const r={innerRadius:1,innerSegments:32,outerRadius:4,outerSegments:32,innerRotation:0,startAngle:0,outerRotation:TAU},{innerRadius:t,innerSegments:o,outerRadius:n,outerSegments:s,innerRotation:i,startAngle:a,outerRotation:u}=Object.assign({},r,e);if(!isGT(t,0))throw new Error("innerRadius must be greater than zero");if(!isGTE(o,3))throw new Error("innerSegments must be three or more");if(!isGT(n,0))throw new Error("outerRadius must be greater than zero");if(!isGTE(s,3))throw new Error("outerSegments must be three or more");if(!isGTE(a,0))throw new Error("startAngle must be positive");if(!isGT(u,0))throw new Error("outerRotation must be greater than zero");if(t>=n)throw new Error("inner circle is two large to rotate about the outer circle");let m=circle({radius:t,segments:o});return 0!==i&&(m=rotate([0,0,i],m)),m=translate([n,0],m),extrudeRotate({startAngle:a,angle:u,segments:s},m)};module.exports=torus;
+const{TAU:TAU}=require("../maths/constants"),extrudeRotate=require("../operations/extrusions/extrudeRotate"),{rotate:rotate}=require("../operations/transforms/rotate"),{translate:translate}=require("../operations/transforms/translate"),circle=require("./circle"),{isGT:isGT,isGTE:isGTE}=require("./commonChecks"),torus=e=>{const r={innerRadius:1,innerSegments:32,outerRadius:4,outerSegments:32,innerRotation:0,startAngle:0,outerRotation:TAU},{innerRadius:t,innerSegments:o,outerRadius:n,outerSegments:s,innerRotation:i,startAngle:a,outerRotation:u}=Object.assign({},r,e);if(!isGT(t,0))throw new Error("innerRadius must be greater than zero");if(!isGTE(o,3))throw new Error("innerSegments must be three or more");if(!isGT(n,0))throw new Error("outerRadius must be greater than zero");if(!isGTE(s,3))throw new Error("outerSegments must be three or more");if(!isGTE(a,0))throw new Error("startAngle must be positive");if(!isGT(u,0))throw new Error("outerRotation must be greater than zero");if(t>=n)throw new Error("inner circle is too large to rotate about the outer circle");let m=circle({radius:t,segments:o});return 0!==i&&(m=rotate([0,0,i],m)),m=translate([n,0],m),extrudeRotate({startAngle:a,angle:u,segments:s},m)};module.exports=torus;
 
 },{"../maths/constants":94,"../operations/extrusions/extrudeRotate":316,"../operations/transforms/rotate":364,"../operations/transforms/translate":367,"./circle":369,"./commonChecks":370}],390:[function(require,module,exports){
 const{NEPS:NEPS}=require("../maths/constants"),vec2=require("../maths/vec2"),geom2=require("../geometries/geom2"),{isNumberArray:isNumberArray}=require("./commonChecks"),solveAngleFromSSS=(e,r,t)=>Math.acos((e*e+r*r-t*t)/(2*e*r)),solveSideFromSAS=(e,r,t)=>r>NEPS?Math.sqrt(e*e+t*t-2*e*t*Math.cos(r)):Math.sqrt((e-t)*(e-t)+e*t*r*r*(1-r*r/12)),solveAAA=e=>{if(Math.abs(e[0]+e[1]+e[2]-Math.PI)>NEPS)throw new Error("AAA triangles require angles that sum to PI");const r=e[0],t=e[1],s=Math.PI-r-t,a=1/Math.sin(s)*Math.sin(r),n=1/Math.sin(s)*Math.sin(t);return createTriangle(r,t,s,a,n,1)},solveAAS=e=>{const r=e[0],t=e[1],s=Math.PI+NEPS-r-t;if(s<NEPS)throw new Error("AAS triangles require angles that sum to PI");const a=e[2],n=a/Math.sin(r)*Math.sin(t),o=a/Math.sin(r)*Math.sin(s);return createTriangle(r,t,s,a,n,o)},solveASA=e=>{const r=e[0],t=e[2],s=Math.PI+NEPS-r-t;if(s<NEPS)throw new Error("ASA triangles require angles that sum to PI");const a=e[1],n=a/Math.sin(s)*Math.sin(r),o=a/Math.sin(s)*Math.sin(t);return createTriangle(r,t,s,n,o,a)},solveSAS=e=>{const r=e[0],t=e[1],s=e[2],a=solveSideFromSAS(r,t,s),n=solveAngleFromSSS(a,r,s),o=Math.PI-n-t;return createTriangle(n,t,o,s,a,r)},solveSSA=e=>{const r=e[0],t=e[1],s=e[2],a=Math.asin(t*Math.sin(s)/r),n=Math.PI-a-s,o=r/Math.sin(s)*Math.sin(n);return createTriangle(a,n,s,t,o,r)},solveSSS=e=>{const r=e[1],t=e[2],s=e[0];if(r+t<=s||t+s<=r||s+r<=t)throw new Error("SSS triangle is incorrect, as the longest side is longer than the sum of the other sides");const a=solveAngleFromSSS(t,s,r),n=solveAngleFromSSS(s,r,t),o=Math.PI-a-n;return createTriangle(a,n,o,r,t,s)},createTriangle=(e,r,t,s,a,n)=>{const o=vec2.fromValues(0,0),i=vec2.fromValues(n,0),S=vec2.fromValues(s,0);return vec2.add(S,vec2.rotate(S,S,[0,0],Math.PI-r),i),geom2.fromPoints([o,i,S])},triangle=e=>{let{type:r,values:t}=Object.assign({},{type:"SSS",values:[1,1,1]},e);if("string"!=typeof r)throw new Error("triangle type must be a string");if("A"!==(r=r.toUpperCase())[0]&&"S"!==r[0]||"A"!==r[1]&&"S"!==r[1]||"A"!==r[2]&&"S"!==r[2])throw new Error("triangle type must contain three letters; A or S");if(!isNumberArray(t,3))throw new Error("triangle values must contain three values");if(!t.every(e=>e>0))throw new Error("triangle values must be greater than zero");switch(r){case"AAA":return solveAAA(t);case"AAS":return solveAAS(t);case"ASA":return solveASA(t);case"SAS":return solveSAS(t);case"SSA":return solveSSA(t);case"SSS":return solveSSS(t);default:throw new Error("invalid triangle type, try again")}};module.exports=triangle;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.12.4",
+  "version": "2.12.6",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "ce4978ee40c30803cba05d1c96ba8b6aaf3abc61"
+  "gitHead": "11a9a2d9235d804360116f776076c9f3237a3eb0"
 }

package/src/curves/index.js

@@ -3,7 +3,6 @@
  * @module modeling/curves
  * @example
  * const { bezier } = require('@jscad/modeling').curves
-
  */
 module.exports = {
   bezier: require('./bezier')

package/src/maths/index.js

@@ -4,8 +4,7 @@
  * @see Most computations are based upon the glMatrix library (glmatrix.net)
  * @module modeling/maths
  * @example
- * const { constants, line2, mat4, vec2, vec3 } = require('@jscad/modeling').maths
-
+ * const { constants, line2, line3, mat4, plane, utils, vec2, vec3, vec4 } = require('@jscad/modeling').maths
  */
 module.exports = {
   constants: require('./constants'),

package/src/operations/booleans/intersect.js

@@ -17,7 +17,7 @@ const intersectGeom3 = require('./intersectGeom3')
  * @alias module:modeling/booleans.intersect
  *
  * @example
- * let myshape = intersect(cube({size: [5,5,5]}), cube({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = intersect(cube({size: 5}), cube({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+

package/src/operations/booleans/scission.js

@@ -9,6 +9,8 @@ const scissionGeom3 = require('./scissionGeom3')
 /**
  * Scission (divide) the given geometry into the component pieces.
  *
+ * NOTE: Currently only 3D geometries are supported.
+ *
  * @param {...Object} objects - list of geometries
  * @returns {Array} list of pieces from each geometry
  * @alias module:modeling/booleans.scission

package/src/operations/booleans/subtract.js

@@ -17,7 +17,7 @@ const subtractGeom3 = require('./subtractGeom3')
  * @alias module:modeling/booleans.subtract
  *
  * @example
- * let myshape = subtract(cuboid({size: [5,5,5]}), cuboid({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = subtract(cuboid({size: 5}), cuboid({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+            +-------+

package/src/operations/booleans/union.js

@@ -16,7 +16,7 @@ const unionGeom3 = require('./unionGeom3')
  * @alias module:modeling/booleans.union
  *
  * @example
- * let myshape = union(cube({size: [5,5,5]}), cube({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = union(cube({size: 5}), cube({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+            +-------+

package/src/operations/expansions/expand.js

@@ -24,7 +24,7 @@ const expandPath2 = require('./expandPath2')
  * @example
  * let newarc = expand({delta: 5, corners: 'edge'}, arc({}))
  * let newsquare = expand({delta: 5, corners: 'chamfer'}, square({size: 30}))
- * let newsphere = expand({delta: 2, corners: 'round'}, cuboid({size: [20, 25, 5]}))
+ * let newcuboid = expand({delta: 2, corners: 'round'}, cuboid({size: [20, 25, 5]}))
  */
 const expand = (options, ...objects) => {
   objects = flatten(objects)

package/src/operations/extrusions/extrudeHelical.js

@@ -1,16 +1,18 @@
 const { TAU } = require('../../maths/constants')
-const slice = require('./slice')
 const mat4 = require('../../maths/mat4')
-const extrudeFromSlices = require('./extrudeFromSlices')
+
 const geom2 = require('../../geometries/geom2')
 
+const extrudeFromSlices = require('./extrudeFromSlices')
+const slice = require('./slice')
+
 /**
  * Perform a helical extrude of the geometry, using the given options.
  *
  * @param {Object} options - options for extrusion
- * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS) positive for right-hand rotation, negative for left-hand
+ * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS); positive for right-hand rotation, negative for left-hand
  * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
- * @param {Number} [options.pitch=10] - elevation gain for each turn
+ * @param {Number} [options.pitch=10] - elevation gain for each full rotation
  * @param {Number} [options.height] - total height of the helix path. Ignored if pitch is set.
  * @param {Number} [options.endOffset=0] - offset the final radius of the extrusion, allowing for tapered helix, and or spiral
  * @param {Number} [options.segmentsPerRotation=32] - number of segments per full rotation of the extrusion
@@ -19,31 +21,24 @@ const geom2 = require('../../geometries/geom2')
  * @alias module:modeling/extrusions.extrudeHelical
  *
  * @example
- * const myshape = extrudeHelical(
- *  {
- *      angle: Math.PI * 4,
- *      pitch: 10,
- *      segmentsPerRotation: 64
- *  },
- *  circle({size: 3, center: [10, 0]})
- * )
+ * const myshape = circle({size: 3, center: [10, 0]}) // position for extrusion about Z
+ * const mycoil = extrudeHelical({angle: TAU * 2, pitch: 10, segmentsPerRotation: 64}, myshape))
  */
 const extrudeHelical = (options, geometry) => {
   const defaults = {
     angle: TAU,
     startAngle: 0,
     pitch: 10,
+    height: 0,
     endOffset: 0,
     segmentsPerRotation: 32
   }
-  const { angle, endOffset, segmentsPerRotation, startAngle } = Object.assign({}, defaults, options)
-
-  let pitch
-  // ignore height if pitch is set
-  if (!options.pitch && options.height) {
-    pitch = options.height / (angle / TAU)
-  } else {
-    pitch = options.pitch ? options.pitch : defaults.pitch
+  let { angle, startAngle, pitch, height, endOffset, segmentsPerRotation } = Object.assign({}, defaults, options)
+
+  // calculate pitch from height if available
+  if (height != 0) {
+    // height / number of full rotations
+    pitch = height / (angle / TAU)
   }
 
   // needs at least 3 segments for each revolution
@@ -52,7 +47,7 @@ const extrudeHelical = (options, geometry) => {
   if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
   const shapeSides = geom2.toSides(geometry)
-  if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
+  if (shapeSides.length === 0) throw new Error('The given geometry cannot be empty')
 
   // const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
   const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
@@ -66,9 +61,11 @@ const extrudeHelical = (options, geometry) => {
 
   const calculatedSegments = Math.round(segmentsPerRotation / TAU * Math.abs(angle))
   const segments = calculatedSegments >= 2 ? calculatedSegments : 2
+
   // define transform matrix variables for performance increase
   const step1 = mat4.create()
-  let matrix
+  const step2 = mat4.create()
+
   const sliceCallback = (progress, index, base) => {
     const zRotation = startAngle + angle / segments * index
     const xOffset = endOffset / segments * index
@@ -90,14 +87,13 @@ const extrudeHelical = (options, geometry) => {
       mat4.fromXRotation(mat4.create(), -TAU / 4 * Math.sign(angle)) // rotate the slice correctly to not create inside-out polygon
     )
 
-    matrix = mat4.create()
     mat4.multiply(
-      matrix,
+      step2,
       // finally rotate around Z axis
       mat4.fromZRotation(mat4.create(), zRotation),
       step1
     )
-    return slice.transform(matrix, base)
+    return slice.transform(step2, base)
   }
 
   return extrudeFromSlices(

package/src/operations/extrusions/extrudeHelical.test.js

@@ -34,7 +34,17 @@ test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3',
   const geometry2 = circle({ size: 3, center: [10, 0] })
   for (const index of [...Array(20).keys()]) {
     // also test negative pitches
-    const geometry3 = extrudeHelical({ pitch: startPitch + index }, geometry2)
+    const geometry3 = extrudeHelical({ pitch: startPitch + index, startAngle: TAU * index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})
+
+test('extrudeHelical: (height) extruding of a circle produces an expected geom3', (t) => {
+  const startHeight = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative heights
+    const geometry3 = extrudeHelical({ height: startHeight + index, angle: TAU * (index + 1) }, geometry2)
     t.notThrows(() => geom3.validate(geometry3))
   }
 })
@@ -49,12 +59,12 @@ test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expect
   }
 })
 
-test('extrudeHelical: (segments) extruding of a circle produces an expected geom3', (t) => {
+test('extrudeHelical: (segmentsPerRotation) extruding of a circle produces an expected geom3', (t) => {
   const startSegments = 3
   const geometry2 = circle({ size: 3, center: [10, 0] })
   for (const index of [...Array(30).keys()]) {
     // also test negative pitches
-    const geometry3 = extrudeHelical({ segments: startSegments + index }, geometry2)
+    const geometry3 = extrudeHelical({ segmentsPerRotation: startSegments + index }, geometry2)
     t.notThrows(() => geom3.validate(geometry3))
   }
 })

package/src/operations/extrusions/index.js

@@ -3,7 +3,7 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/extrusions
  * @example
- * const { extrudeLinear, extrudeRectangular, extrudeRotate } = require('@jscad/modeling').extrusions
+ * const { extrudeHelical, extrudeLinear, extrudeRectangular, extrudeRotate, project, slice } = require('@jscad/modeling').extrusions
  */
 module.exports = {
   extrudeFromSlices: require('./extrudeFromSlices'),

package/src/operations/hulls/index.js

@@ -4,7 +4,7 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/hulls
  * @example
- * const { hull, hullChain } = require('@jscad/modeling').hulls
+ * const { hull, hullChain, hullPoints2, hullPoints3 } = require('@jscad/modeling').hulls
  */
 module.exports = {
   hull: require('./hull'),

package/src/operations/modifiers/index.js

@@ -3,7 +3,7 @@
  * In all cases, these functions returns the results, and never changes the original geometry.
  * @module modeling/modifiers
  * @example
- * const { snap } = require('@jscad/modeling').modifiers
+ * const { generalize, snap, retessellate } = require('@jscad/modeling').modifiers
  */
 module.exports = {
   generalize: require('./generalize'),

package/src/operations/modifiers/snap.js

@@ -35,7 +35,7 @@ const snapGeom3 = (geometry) => {
 }
 
 /**
- * Snap the given geometries to the overall precision (epsilon) of the geometry.
+ * Snap the given geometries to the precision (calculated epsilon) of the geometry.
  * @see measurements.measureEpsilon()
  * @param {...Object} geometries - the geometries to snap
  * @return {Object|Array} the snapped geometry, or a list of snapped geometries

package/src/primitives/arc.js

@@ -17,6 +17,8 @@ const { isGT, isGTE, isNumberArray } = require('./commonChecks')
  * @param {Boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
  * @returns {path2} new 2D path
  * @alias module:modeling/primitives.arc
+ * @example
+ * let myshape = arc({ center: [-1, -1], radius: 2, endAngle: (TAU / 4)})
  */
 const arc = (options) => {
   const defaults = {

package/src/primitives/polyhedron.js

@@ -5,6 +5,7 @@ const { isNumberArray } = require('./commonChecks')
 
 /**
  * Construct a polyhedron in three dimensional space from the given set of 3D points and faces.
+ *
  * The faces can define outward or inward facing polygons (orientation).
  * However, each face must define a counter clockwise rotation of points which follows the right hand rule.
  * @param {Object} options - options for construction
@@ -18,7 +19,7 @@ const { isNumberArray } = require('./commonChecks')
  * @example
  * let mypoints = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ]
  * let myfaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
- * let myshape = polyhedron({points: mypoint, faces: myfaces, orientation: 'inward'})
+ * let myshape = polyhedron({points: mypoints, faces: myfaces, orientation: 'inward'})
  */
 const polyhedron = (options) => {
   const defaults = {

package/src/primitives/torus.js

@@ -43,7 +43,7 @@ const torus = (options) => {
   if (!isGTE(startAngle, 0)) throw new Error('startAngle must be positive')
   if (!isGT(outerRotation, 0)) throw new Error('outerRotation must be greater than zero')
 
-  if (innerRadius >= outerRadius) throw new Error('inner circle is two large to rotate about the outer circle')
+  if (innerRadius >= outerRadius) throw new Error('inner circle is too large to rotate about the outer circle')
 
   let innerCircle = circle({ radius: innerRadius, segments: innerSegments })
 

package/src/text/vectorChar.js

@@ -22,11 +22,8 @@ const vectorParams = require('./vectorParams')
 *
 * @example
 * let vectorCharObject = vectorChar()
-* or
 * let vectorCharObject = vectorChar('A')
-* or
 * let vectorCharObject = vectorChar({ xOffset: 57 }, 'C')
-* or
 * let vectorCharObject = vectorChar({ xOffset: 78, input: '!' })
 */
 const vectorChar = (options, char) => {

package/src/text/vectorText.js

@@ -35,11 +35,8 @@ const translateLine = (options, line) => {
  *
  * @example
  * let textSegments = vectorText()
- * or
  * let textSegments = vectorText('OpenJSCAD')
- * or
  * let textSegments = vectorText({ yOffset: -50 }, 'OpenJSCAD')
- * or
  * let textSegments = vectorText({ yOffset: -80, input: 'OpenJSCAD' })
  */
 const vectorText = (options, text) => {

package/src/utils/index.js

@@ -1,8 +1,8 @@
 /**
- * Utility functions of various sorts.
+ * Utility functions of various sorts, including conversions from different angular measures.
  * @module modeling/utils
  * @example
- * const { flatten, insertSorted } = require('@jscad/modeling').utils
+ * const { areAllShapesTheSameType, degToRad, radiusToSegments, radToDeg } = require('@jscad/modeling').utils
  */
 module.exports = {
   areAllShapesTheSameType: require('./areAllShapesTheSameType'),