jscad-electronics 0.0.185 → 0.0.186

package/dist/vanilla.d.ts

@@ -1,7 +1,7 @@
 import { BufferGeometry } from 'three';
 import * as jscadModeling from '@jscad/modeling';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { NemaMotorModelPropsInput, HexSocketBoltModelPropsInput, SheetMetalModelPropsInput, SpurGearModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
+import { NemaMotorModelPropsInput, HexSocketBoltModelPropsInput, SheetMetalModelPropsInput, SpurGearModelPropsInput, HelicalGearModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
 import * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
 
 type VNode = {
@@ -93,6 +93,20 @@ interface SpurGearMesh {
  */
 declare function createSpurGearMesh(input: SpurGearModelPropsInput): SpurGearMesh;
 
+type HelicalGearMesh = SpurGearMesh;
+/**
+ * Twisted transverse involute teeth from Z=0 to faceWidth, with a stationary
+ * round bore and optional hub. Zero helix angle reproduces the spur mesh.
+ */
+declare function createHelicalGearMesh(input: HelicalGearModelPropsInput): HelicalGearMesh;
+
+type HelicalGearProps = HelicalGearModelPropsInput & {
+    color?: string;
+};
+/** Axis +Z, lower face Z=0; optional hub extends above the gear face. */
+declare function createHelicalGearGeom(input: HelicalGearModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function HelicalGear({ color, ...props }: HelicalGearProps): react_jsx_runtime.JSX.Element;
+
 type SpurGearProps = SpurGearModelPropsInput & {
     color?: string;
 };
@@ -128,4 +142,4 @@ declare function createJSCADRenderer(jscad: typeof jscadModeling): {
     };
 };
 
-export { type ColoredGeom, Fragment, HexSocketBolt, type HexSocketBoltMesh, type HexSocketBoltProps, NEMA17, NEMA23, NEMA8, type NemaFrameMotorProps, NemaMotor, type NemaMotorProps, type RenderResult, SheetMetal, type SheetMetalMesh, type SheetMetalProps, SpurGear, type SpurGearMesh, type SpurGearProps, type VNode, WormGear, type WormGearMesh, type WormGearProps, convertCSGToThreeGeom, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };
+export { type ColoredGeom, Fragment, HelicalGear, type HelicalGearMesh, type HelicalGearProps, HexSocketBolt, type HexSocketBoltMesh, type HexSocketBoltProps, NEMA17, NEMA23, NEMA8, type NemaFrameMotorProps, NemaMotor, type NemaMotorProps, type RenderResult, SheetMetal, type SheetMetalMesh, type SheetMetalProps, SpurGear, type SpurGearMesh, type SpurGearProps, type VNode, WormGear, type WormGearMesh, type WormGearProps, convertCSGToThreeGeom, createHelicalGearGeom, createHelicalGearMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -172,9 +172,14 @@ var ExtrudedPads = ({
   circuitJson,
   footprint
 }) => {
-  if (!circuitJson && footprint && ["nema", "hexsocketbolt", "sheetmetal", "spurgear", "wormgear"].includes(
-    mp.string(footprint.split("_", 1)[0]).params().fn
-  )) {
+  if (!circuitJson && footprint && [
+    "nema",
+    "hexsocketbolt",
+    "sheetmetal",
+    "spurgear",
+    "wormgear",
+    "helicalgear"
+  ].includes(mp.string(footprint.split("_", 1)[0]).params().fn)) {
     mp.string(footprint).json();
     return null;
   }
@@ -201,6 +206,220 @@ var ExtrudedPads = ({
   ] });
 };
 
+// lib/mechanical/indexedMeshToGeom3.ts
+import jscad from "@jscad/modeling";
+function indexedMeshToGeom3(mesh) {
+  const polygons = [];
+  for (let i = 0; i < mesh.indices.length; i += 3)
+    polygons.push(
+      mesh.indices.slice(i, i + 3).map((index) => [
+        mesh.positions[index * 3],
+        mesh.positions[index * 3 + 1],
+        mesh.positions[index * 3 + 2]
+      ])
+    );
+  return jscad.geometries.geom3.fromPoints(polygons);
+}
+
+// lib/mechanical/helical-gear-mesh.ts
+import {
+  getHelicalGearDimensions,
+  helicalGearModelPropsSchema
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/spur-gear-mesh.ts
+import {
+  getSpurGearDimensions,
+  spurGearModelPropsSchema
+} from "@tscircuit/modelprinter";
+import earcut from "earcut";
+function createSpurGearMesh(input) {
+  return createTwistedSpurGearMesh(input);
+}
+function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
+  const props = spurGearModelPropsSchema.parse(input);
+  const dimensions = getSpurGearDimensions(props);
+  const pitchRadius = dimensions.pitchDiameter / 2;
+  const baseRadius = dimensions.baseDiameter / 2;
+  const outsideRadius = dimensions.outsideDiameter / 2;
+  const rootRadius = dimensions.rootDiameter / 2;
+  const pressureAngle = props.pressureAngle * Math.PI / 180;
+  const toothAngle = Math.PI * 2 / props.toothCount;
+  const phase = (props.phase % 360 + 360) % 360 * (Math.PI / 180);
+  const baseHalfAngle = dimensions.toothThickness / (2 * pitchRadius) + Math.tan(pressureAngle) - pressureAngle;
+  const startRadius = Math.max(baseRadius, rootRadius);
+  const startT = Math.sqrt(Math.max(0, (startRadius / baseRadius) ** 2 - 1));
+  const outsideT = Math.sqrt((outsideRadius / baseRadius) ** 2 - 1);
+  const halfAngle = (t) => baseHalfAngle - (t - Math.atan(t));
+  const rootHalfAngle = halfAngle(startT);
+  const tipHalfAngle = halfAngle(outsideT);
+  const flankSteps = Math.max(2, Math.ceil(props.segmentsPerTooth / 2));
+  const arcSteps = Math.max(1, Math.ceil(props.segmentsPerTooth / 4));
+  const rootValleyAngle = toothAngle - 2 * rootHalfAngle;
+  const innerRadius = Math.max(props.boreDiameter, props.hubDiameter) / 2;
+  const safeRootStep = innerRadius > 0 ? (twist === 0 ? 1.8 : 0.8) * Math.acos(innerRadius / rootRadius) : Math.PI;
+  const rootArcSteps = Math.max(
+    arcSteps,
+    Math.ceil(rootValleyAngle / safeRootStep)
+  );
+  const twistStep = Math.min(
+    toothAngle / 16,
+    2 * Math.PI / segmentsPerTurn,
+    safeRootStep
+  );
+  const layers = Math.max(1, Math.ceil(Math.abs(twist) / twistStep));
+  const pointsPerTooth = 2 * flankSteps + arcSteps + rootArcSteps + (rootRadius < baseRadius ? 2 : 0);
+  if (!Number.isFinite(rootArcSteps) || !Number.isFinite(layers) || (layers + 1) * props.toothCount * pointsPerTooth + 1024 > 1e6)
+    throw new Error(
+      "Involute gear exceeds mesh resolution limit (1 million vertices); reduce twist or resolution, or increase bore/hub wall thickness"
+    );
+  const outline = [];
+  const polar = (radius, angle) => {
+    outline.push([radius * Math.cos(angle), radius * Math.sin(angle)]);
+  };
+  for (let tooth = 0; tooth < props.toothCount; tooth++) {
+    const center = phase + tooth * toothAngle;
+    polar(rootRadius, center - rootHalfAngle);
+    if (rootRadius < baseRadius) polar(baseRadius, center - baseHalfAngle);
+    for (let step = 1; step <= flankSteps; step++) {
+      const t = startT + (outsideT - startT) * step / flankSteps;
+      polar(baseRadius * Math.sqrt(1 + t * t), center - halfAngle(t));
+    }
+    for (let step = 1; step <= arcSteps; step++)
+      polar(
+        outsideRadius,
+        center - tipHalfAngle + 2 * tipHalfAngle * step / arcSteps
+      );
+    for (let step = flankSteps - 1; step >= 0; step--) {
+      const t = startT + (outsideT - startT) * step / flankSteps;
+      polar(baseRadius * Math.sqrt(1 + t * t), center + halfAngle(t));
+    }
+    if (rootRadius < baseRadius) polar(rootRadius, center + baseHalfAngle);
+    for (let step = 1; step < rootArcSteps; step++)
+      polar(
+        rootRadius,
+        center + rootHalfAngle + rootValleyAngle * step / rootArcSteps
+      );
+  }
+  const positions = [];
+  const indices = [];
+  const ring = (points, z) => {
+    const start = positions.length / 3;
+    for (const [x, y] of points) positions.push(x, y, z);
+    return start;
+  };
+  const circleSegments = Math.max(48, Math.min(256, props.toothCount * 4));
+  const circle2 = (radius) => Array.from({ length: circleSegments }, (_, segment) => {
+    const angle = phase + segment * Math.PI * 2 / circleSegments;
+    return [radius * Math.cos(angle), radius * Math.sin(angle)];
+  });
+  const connect = (bottom2, top2, count, inward = false) => {
+    for (let i = 0; i < count; i++) {
+      const next = (i + 1) % count;
+      if (inward)
+        indices.push(
+          bottom2 + i,
+          top2 + next,
+          bottom2 + next,
+          bottom2 + i,
+          top2 + i,
+          top2 + next
+        );
+      else
+        indices.push(
+          bottom2 + i,
+          bottom2 + next,
+          top2 + next,
+          bottom2 + i,
+          top2 + next,
+          top2 + i
+        );
+    }
+  };
+  const cap = (outer, outerStart, upward, inner) => {
+    const points = inner ? [...outer, ...inner.points] : outer;
+    const triangles = earcut(
+      points.flatMap(([x, y]) => [x, y]),
+      inner ? [outer.length] : []
+    );
+    const vertex = (index) => index < outer.length ? outerStart + index : inner.start + index - outer.length;
+    for (let i = 0; i < triangles.length; i += 3) {
+      const a = triangles[i];
+      const b = triangles[i + 1];
+      const c = triangles[i + 2];
+      const pa = points[a];
+      const pb = points[b];
+      const pc = points[c];
+      const area = (pb[0] - pa[0]) * (pc[1] - pa[1]) - (pb[1] - pa[1]) * (pc[0] - pa[0]);
+      if (area > 0 === upward) indices.push(vertex(a), vertex(b), vertex(c));
+      else indices.push(vertex(a), vertex(c), vertex(b));
+    }
+  };
+  const bottom = ring(outline, 0);
+  let top = bottom;
+  let topOutline = outline;
+  for (let layer = 1; layer <= layers; layer++) {
+    const angle = twist * (layer / layers);
+    topOutline = twist === 0 ? outline : outline.map(
+      ([x, y]) => [
+        x * Math.cos(angle) - y * Math.sin(angle),
+        x * Math.sin(angle) + y * Math.cos(angle)
+      ]
+    );
+    const next = ring(topOutline, props.faceWidth * (layer / layers));
+    connect(top, next, outline.length);
+    top = next;
+  }
+  const hasHub = props.hubDiameter > 0 && props.hubLength > 0;
+  const height10 = props.faceWidth + (hasHub ? props.hubLength : 0);
+  const bore = props.boreDiameter > 0 ? circle2(props.boreDiameter / 2) : void 0;
+  const boreBottom = bore ? ring(bore, 0) : void 0;
+  const boreTop = bore ? ring(bore, height10) : void 0;
+  if (bore) connect(boreBottom, boreTop, bore.length, true);
+  cap(
+    outline,
+    bottom,
+    false,
+    bore ? { points: bore, start: boreBottom } : void 0
+  );
+  if (hasHub) {
+    const hub = circle2(props.hubDiameter / 2);
+    const hubBottom = ring(hub, props.faceWidth);
+    const hubTop = ring(hub, height10);
+    cap(topOutline, top, true, { points: hub, start: hubBottom });
+    connect(hubBottom, hubTop, hub.length);
+    if (bore) connect(hubTop, boreTop, hub.length);
+    else cap(hub, hubTop, true);
+  } else
+    cap(
+      topOutline,
+      top,
+      true,
+      bore ? { points: bore, start: boreTop } : void 0
+    );
+  return { positions, indices };
+}
+
+// lib/mechanical/helical-gear-mesh.ts
+function createHelicalGearMesh(input) {
+  const props = helicalGearModelPropsSchema.parse(input);
+  const { twistAngle } = getHelicalGearDimensions(props);
+  const { helixAngle, handedness, segmentsPerTurn, ...spur } = props;
+  return createTwistedSpurGearMesh(
+    spur,
+    twistAngle * Math.PI / 180,
+    segmentsPerTurn
+  );
+}
+
+// lib/HelicalGear.tsx
+function createHelicalGearGeom(input) {
+  return indexedMeshToGeom3(createHelicalGearMesh(input));
+}
+function HelicalGear({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createHelicalGearGeom(props) }) });
+}
+
 // lib/mechanical/hex-socket-bolt-mesh.ts
 import {
   hexSocketBoltDimensions,
@@ -295,21 +514,6 @@ var createHexSocketBoltMesh = (input) => {
   return { positions, indices };
 };
 
-// lib/mechanical/indexedMeshToGeom3.ts
-import jscad from "@jscad/modeling";
-function indexedMeshToGeom3(mesh) {
-  const polygons = [];
-  for (let i = 0; i < mesh.indices.length; i += 3)
-    polygons.push(
-      mesh.indices.slice(i, i + 3).map((index) => [
-        mesh.positions[index * 3],
-        mesh.positions[index * 3 + 1],
-        mesh.positions[index * 3 + 2]
-      ])
-    );
-  return jscad.geometries.geom3.fromPoints(polygons);
-}
-
 // lib/HexSocketBolt.tsx
 function createHexSocketBoltGeom(input) {
   return indexedMeshToGeom3(createHexSocketBoltMesh(input));
@@ -322,7 +526,7 @@ function HexSocketBolt({
 }
 
 // lib/mechanical/sheet-metal-mesh.ts
-import earcut from "earcut";
+import earcut2 from "earcut";
 import {
   sheetMetalModelPropsSchema
 } from "@tscircuit/modelprinter";
@@ -390,7 +594,7 @@ function createSheetMetalMesh(input) {
     const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
     const points = loops.flat();
     const starts = holes.map((_, i) => 4 + i * 64);
-    const triangles = earcut(
+    const triangles = earcut2(
       points.flatMap((p) => [p.u, p.v]),
       starts
     );
@@ -474,158 +678,6 @@ function SheetMetal({ color = "#737e8f", ...props }) {
   return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSheetMetalGeom(props) }) });
 }
 
-// lib/mechanical/spur-gear-mesh.ts
-import {
-  getSpurGearDimensions,
-  spurGearModelPropsSchema
-} from "@tscircuit/modelprinter";
-import earcut2 from "earcut";
-function createSpurGearMesh(input) {
-  const props = spurGearModelPropsSchema.parse(input);
-  const dimensions = getSpurGearDimensions(props);
-  const pitchRadius = dimensions.pitchDiameter / 2;
-  const baseRadius = dimensions.baseDiameter / 2;
-  const outsideRadius = dimensions.outsideDiameter / 2;
-  const rootRadius = dimensions.rootDiameter / 2;
-  const pressureAngle = props.pressureAngle * Math.PI / 180;
-  const toothAngle = Math.PI * 2 / props.toothCount;
-  const phase = (props.phase % 360 + 360) % 360 * (Math.PI / 180);
-  const baseHalfAngle = dimensions.toothThickness / (2 * pitchRadius) + Math.tan(pressureAngle) - pressureAngle;
-  const startRadius = Math.max(baseRadius, rootRadius);
-  const startT = Math.sqrt(Math.max(0, (startRadius / baseRadius) ** 2 - 1));
-  const outsideT = Math.sqrt((outsideRadius / baseRadius) ** 2 - 1);
-  const halfAngle = (t) => baseHalfAngle - (t - Math.atan(t));
-  const rootHalfAngle = halfAngle(startT);
-  const tipHalfAngle = halfAngle(outsideT);
-  const flankSteps = Math.max(2, Math.ceil(props.segmentsPerTooth / 2));
-  const arcSteps = Math.max(1, Math.ceil(props.segmentsPerTooth / 4));
-  const rootValleyAngle = toothAngle - 2 * rootHalfAngle;
-  const innerRadius = Math.max(props.boreDiameter, props.hubDiameter) / 2;
-  const safeRootStep = innerRadius > 0 ? 1.8 * Math.acos(innerRadius / rootRadius) : Math.PI;
-  const rootArcSteps = Math.max(
-    arcSteps,
-    Math.ceil(rootValleyAngle / safeRootStep)
-  );
-  const pointsPerTooth = 2 * flankSteps + arcSteps + rootArcSteps + (rootRadius < baseRadius ? 2 : 0);
-  if (!Number.isFinite(rootArcSteps) || 2 * props.toothCount * pointsPerTooth + 1024 > 1e6)
-    throw new Error(
-      "Spur gear bore or hub clearance exceeds mesh resolution limit (1 million vertices)"
-    );
-  const outline = [];
-  const polar = (radius, angle) => {
-    outline.push([radius * Math.cos(angle), radius * Math.sin(angle)]);
-  };
-  for (let tooth = 0; tooth < props.toothCount; tooth++) {
-    const center = phase + tooth * toothAngle;
-    polar(rootRadius, center - rootHalfAngle);
-    if (rootRadius < baseRadius) polar(baseRadius, center - baseHalfAngle);
-    for (let step = 1; step <= flankSteps; step++) {
-      const t = startT + (outsideT - startT) * step / flankSteps;
-      polar(baseRadius * Math.sqrt(1 + t * t), center - halfAngle(t));
-    }
-    for (let step = 1; step <= arcSteps; step++)
-      polar(
-        outsideRadius,
-        center - tipHalfAngle + 2 * tipHalfAngle * step / arcSteps
-      );
-    for (let step = flankSteps - 1; step >= 0; step--) {
-      const t = startT + (outsideT - startT) * step / flankSteps;
-      polar(baseRadius * Math.sqrt(1 + t * t), center + halfAngle(t));
-    }
-    if (rootRadius < baseRadius) polar(rootRadius, center + baseHalfAngle);
-    for (let step = 1; step < rootArcSteps; step++)
-      polar(
-        rootRadius,
-        center + rootHalfAngle + rootValleyAngle * step / rootArcSteps
-      );
-  }
-  const positions = [];
-  const indices = [];
-  const ring = (points, z) => {
-    const start = positions.length / 3;
-    for (const [x, y] of points) positions.push(x, y, z);
-    return start;
-  };
-  const circleSegments = Math.max(48, Math.min(256, props.toothCount * 4));
-  const circle2 = (radius) => Array.from({ length: circleSegments }, (_, segment) => {
-    const angle = phase + segment * Math.PI * 2 / circleSegments;
-    return [radius * Math.cos(angle), radius * Math.sin(angle)];
-  });
-  const connect = (bottom2, top2, count, inward = false) => {
-    for (let i = 0; i < count; i++) {
-      const next = (i + 1) % count;
-      if (inward)
-        indices.push(
-          bottom2 + i,
-          top2 + next,
-          bottom2 + next,
-          bottom2 + i,
-          top2 + i,
-          top2 + next
-        );
-      else
-        indices.push(
-          bottom2 + i,
-          bottom2 + next,
-          top2 + next,
-          bottom2 + i,
-          top2 + next,
-          top2 + i
-        );
-    }
-  };
-  const cap = (outer, outerStart, upward, inner) => {
-    const points = inner ? [...outer, ...inner.points] : outer;
-    const triangles = earcut2(
-      points.flatMap(([x, y]) => [x, y]),
-      inner ? [outer.length] : []
-    );
-    const vertex = (index) => index < outer.length ? outerStart + index : inner.start + index - outer.length;
-    for (let i = 0; i < triangles.length; i += 3) {
-      const a = triangles[i];
-      const b = triangles[i + 1];
-      const c = triangles[i + 2];
-      const pa = points[a];
-      const pb = points[b];
-      const pc = points[c];
-      const area = (pb[0] - pa[0]) * (pc[1] - pa[1]) - (pb[1] - pa[1]) * (pc[0] - pa[0]);
-      if (area > 0 === upward) indices.push(vertex(a), vertex(b), vertex(c));
-      else indices.push(vertex(a), vertex(c), vertex(b));
-    }
-  };
-  const bottom = ring(outline, 0);
-  const top = ring(outline, props.faceWidth);
-  connect(bottom, top, outline.length);
-  const hasHub = props.hubDiameter > 0 && props.hubLength > 0;
-  const height10 = props.faceWidth + (hasHub ? props.hubLength : 0);
-  const bore = props.boreDiameter > 0 ? circle2(props.boreDiameter / 2) : void 0;
-  const boreBottom = bore ? ring(bore, 0) : void 0;
-  const boreTop = bore ? ring(bore, height10) : void 0;
-  if (bore) connect(boreBottom, boreTop, bore.length, true);
-  cap(
-    outline,
-    bottom,
-    false,
-    bore ? { points: bore, start: boreBottom } : void 0
-  );
-  if (hasHub) {
-    const hub = circle2(props.hubDiameter / 2);
-    const hubBottom = ring(hub, props.faceWidth);
-    const hubTop = ring(hub, height10);
-    cap(outline, top, true, { points: hub, start: hubBottom });
-    connect(hubBottom, hubTop, hub.length);
-    if (bore) connect(hubTop, boreTop, hub.length);
-    else cap(hub, hubTop, true);
-  } else
-    cap(
-      outline,
-      top,
-      true,
-      bore ? { points: bore, start: boreTop } : void 0
-    );
-  return { positions, indices };
-}
-
 // lib/SpurGear.tsx
 function createSpurGearGeom(input) {
   return indexedMeshToGeom3(createSpurGearMesh(input));
@@ -9068,6 +9120,10 @@ var Footprinter3d = ({ footprint }) => {
         const { fn, ...props } = model;
         return /* @__PURE__ */ jsx(SheetMetal, { ...props });
       }
+      case "helicalgear": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(HelicalGear, { ...props });
+      }
       case "spurgear": {
         const { fn, ...props } = model;
         return /* @__PURE__ */ jsx(SpurGear, { ...props });
@@ -9997,6 +10053,7 @@ function createJSCADRenderer(jscad4) {
 }
 export {
   Fragment,
+  HelicalGear,
   HexSocketBolt,
   NEMA17,
   NEMA23,
@@ -10006,6 +10063,8 @@ export {
   SpurGear,
   WormGear,
   convertCSGToThreeGeom,
+  createHelicalGearGeom,
+  createHelicalGearMesh,
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,