jscad-electronics 0.0.187 → 0.0.188

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, HelicalGearModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
+import { NemaMotorModelPropsInput, HexSocketBoltModelPropsInput, SheetMetalModelPropsInput, SpurGearModelPropsInput, HelicalGearModelPropsInput, WormGearModelPropsInput, HexBoltModelPropsInput } from '@tscircuit/modelprinter';
 import * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
 
 type VNode = {
@@ -134,6 +134,23 @@ type WormGearProps = WormGearModelPropsInput & {
 declare function createWormGearGeom(input: WormGearModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
 declare function WormGear({ color, ...props }: WormGearProps): react_jsx_runtime.JSX.Element;
 
+interface HexBoltMeshOptions {
+    radialSegments?: number;
+    threadStepsPerTurn?: number;
+}
+/** Outward-oriented, welded indexed surface, in millimeters. */
+interface HexBoltMesh {
+    positions: number[];
+    indices: number[];
+}
+declare function createHexBoltMesh(input: HexBoltModelPropsInput, options?: HexBoltMeshOptions): HexBoltMesh;
+
+type HexBoltProps = HexBoltModelPropsInput & {
+    color?: string;
+};
+declare function createHexBoltGeom(input: HexBoltModelPropsInput, options?: HexBoltMeshOptions): _jscad_modeling_src_geometries_types.Geom3;
+declare function HexBolt({ color, ...props }: HexBoltProps): react_jsx_runtime.JSX.Element;
+
 declare function getJscadModelForFootprint(footprint: string, jscad: typeof jscadModeling): RenderResult;
 declare function getJscadModelForFootprintWithPads(footprint: string, jscad: typeof jscadModeling): RenderResult;
 declare function createJSCADRenderer(jscad: typeof jscadModeling): {
@@ -142,4 +159,4 @@ declare function createJSCADRenderer(jscad: typeof jscadModeling): {
     };
 };
 
-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 };
+export { type ColoredGeom, Fragment, HelicalGear, type HelicalGearMesh, type HelicalGearProps, HexBolt, type HexBoltMesh, type HexBoltMeshOptions, type HexBoltProps, 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, createHexBoltGeom, createHexBoltMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -175,6 +175,7 @@ var ExtrudedPads = ({
   if (!circuitJson && footprint && [
     "nema",
     "hexsocketbolt",
+    "hexbolt",
     "sheetmetal",
     "spurgear",
     "wormgear",
@@ -206,6 +207,132 @@ var ExtrudedPads = ({
   ] });
 };
 
+// lib/models/hexbolt/mesh.ts
+import {
+  hexBoltModelPropsSchema
+} from "@tscircuit/modelprinter";
+function createHexBoltMesh(input, options = {}) {
+  const p = hexBoltModelPropsSchema.parse(input);
+  const segments = options.radialSegments ?? 96;
+  const axial = options.threadStepsPerTurn ?? 24;
+  if (!Number.isInteger(segments) || segments < 24 || segments > 192 || segments % 24 !== 0 || !Number.isInteger(axial) || axial < 24 || axial > 96)
+    throw new Error(
+      "Screw mesh resolution requires 24..192 radial segments divisible by 24 and 24..96 thread steps"
+    );
+  const positions = [], indices = [];
+  const welded = /* @__PURE__ */ new Map();
+  const vertex = (x, y, z) => {
+    const key = [x, y, z].map((v) => Math.round(v * 1e10)).join(":");
+    const existing = welded.get(key);
+    if (existing !== void 0) return existing;
+    const index = positions.length / 3;
+    positions.push(x, y, z);
+    welded.set(key, index);
+    return index;
+  };
+  const triangle = (a, b, c) => {
+    if (a === b || b === c || c === a) return;
+    const point = (i) => positions.slice(3 * i, 3 * i + 3);
+    const A = point(a), B = point(b), C = point(c);
+    const u = B.map((v2, i) => v2 - A[i]), v = C.map((w, i) => w - A[i]);
+    const area = Math.hypot(
+      u[1] * v[2] - u[2] * v[1],
+      u[2] * v[0] - u[0] * v[2],
+      u[0] * v[1] - u[1] * v[0]
+    );
+    if (area > 1e-12) indices.push(a, b, c);
+  };
+  const ring = (radiusAt, zAt) => Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments, r = radiusAt(theta);
+    return vertex(
+      r * Math.cos(theta),
+      r * Math.sin(theta),
+      typeof zAt === "number" ? zAt : zAt(theta)
+    );
+  });
+  const connect = (a, b) => {
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      triangle(a[i], a[n], b[n]);
+      triangle(a[i], b[n], b[i]);
+    }
+  };
+  const cap = (a, z, up) => {
+    const c = vertex(0, 0, z);
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      up ? triangle(c, a[i], a[n]) : triangle(c, a[n], a[i]);
+    }
+  };
+  let previous = [];
+  const add = (radiusAt, zAt) => {
+    const r = ring(radiusAt, zAt);
+    if (previous.length) connect(previous, r);
+    previous = r;
+    return r;
+  };
+  const major = p.diameter / 2, minor = p.threadRootDiameter / 2, pitch = p.threadPitch;
+  const shaftEnd = -p.underHeadRadius;
+  const steps = p.showThreads ? Math.ceil((shaftEnd + p.length) / pitch * axial) : 1;
+  if ((steps + 100) * segments > 4e5)
+    throw new Error("Screw exceeds mesh resolution limit");
+  const levels = /* @__PURE__ */ new Set([
+    -p.length,
+    -p.length + p.tipChamfer,
+    shaftEnd
+  ]);
+  if (p.showThreads)
+    for (let i = 0; i <= steps; i++)
+      levels.add(-p.length + (shaftEnd + p.length) * i / steps);
+  for (const z of [...levels].sort((a, b) => a - b)) {
+    const r = add((theta) => {
+      const phase = (((z + p.length) / pitch - (p.threadHand === "right" ? 1 : -1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
+      const d = Math.min(phase, 1 - phase);
+      const groove = Math.min(
+        major - minor,
+        Math.max(0, (d - 1 / 16) * pitch * Math.sqrt(3))
+      );
+      const thread = p.showThreads ? major - groove : major;
+      return Math.min(
+        thread,
+        major - Math.max(0, p.tipChamfer - (z + p.length))
+      );
+    }, z);
+    if (z === -p.length) cap(r, z, false);
+  }
+  add(() => major, shaftEnd);
+  const filletCenterR = major + p.underHeadRadius;
+  const filletCenterZ = shaftEnd;
+  for (let i = 1; i <= 16; i++) {
+    const angle = Math.PI - (Math.PI - Math.PI / 2) * i / 16;
+    add(
+      () => filletCenterR + p.underHeadRadius * Math.cos(angle),
+      filletCenterZ + p.underHeadRadius * Math.sin(angle)
+    );
+  }
+  const hexRadius = (theta) => p.headAcrossFlats / 2 / Math.max(
+    Math.abs(Math.sin(theta)),
+    Math.abs(Math.sin(theta + 2 * Math.PI / 3)),
+    Math.abs(Math.sin(theta + 4 * Math.PI / 3))
+  );
+  add(hexRadius, 0);
+  const slope = Math.tan(p.headChamferAngle * Math.PI / 180);
+  const start = p.headHeight - (p.headCornerDiameter - p.headChamferDiameter) / 2 * slope;
+  add(hexRadius, start);
+  for (let i = 1; i <= 12; i++) {
+    const z = start + (p.headHeight - start) * i / 12;
+    add(
+      (theta) => Math.min(
+        hexRadius(theta),
+        p.headChamferDiameter / 2 + (p.headHeight - z) / slope
+      ),
+      z
+    );
+  }
+  cap(previous, p.headHeight, true);
+  return { positions, indices };
+}
+
 // lib/mechanical/indexedMeshToGeom3.ts
 import jscad from "@jscad/modeling";
 function indexedMeshToGeom3(mesh) {
@@ -221,6 +348,14 @@ function indexedMeshToGeom3(mesh) {
   return jscad.geometries.geom3.fromPoints(polygons);
 }
 
+// lib/models/hexbolt/HexBolt.tsx
+function createHexBoltGeom(input, options) {
+  return indexedMeshToGeom3(createHexBoltMesh(input, options));
+}
+function HexBolt({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createHexBoltGeom(props) }) });
+}
+
 // lib/mechanical/helical-gear-mesh.ts
 import {
   getHelicalGearDimensions,
@@ -8790,34 +8925,56 @@ var CableStrip = ({
   color,
   acrossOffset = 0,
   normalOffset = 0,
-  overlap = 0.03
-}) => /* @__PURE__ */ jsx(Colorize, { color, children: points.slice(1).map((point, index) => {
-  const previous = points[index];
-  const dx = point[0] - previous[0];
-  const dy = point[1] - previous[1];
-  const dz = point[2] - previous[2];
-  const segmentLength = Math.hypot(dx, dy, dz);
-  if (segmentLength < EPSILON) return null;
-  const pitch = Math.asin(dz / segmentLength);
-  const yaw = Math.atan2(-dx, dy);
-  const midpoint = [
-    (previous[0] + point[0]) / 2,
-    (previous[1] + point[1]) / 2,
-    (previous[2] + point[2]) / 2
-  ];
-  const roundRadius = Math.max(
-    1e-3,
-    Math.min(width10, thickness, segmentLength) / 2 - 1e-3
-  );
-  return /* @__PURE__ */ jsx(Translate, { offset: midpoint, children: /* @__PURE__ */ jsx(Rotate, { rotation: [pitch, 0, yaw], children: /* @__PURE__ */ jsx(
-    RoundedCuboid,
-    {
-      size: [width10, segmentLength + overlap, thickness],
-      center: [acrossOffset, 0, normalOffset],
-      roundRadius
-    }
-  ) }) }, `${index}:${midpoint.join(":")}`);
-}) });
+  overlap = 0.03,
+  widthAtDistance,
+  startDistance = 0
+}) => {
+  const distances = getPathDistances(points);
+  return /* @__PURE__ */ jsx(Colorize, { color, children: points.slice(1).map((point, index) => {
+    const previous = points[index];
+    const dx = point[0] - previous[0];
+    const dy = point[1] - previous[1];
+    const dz = point[2] - previous[2];
+    const segmentLength = Math.hypot(dx, dy, dz);
+    if (segmentLength < EPSILON) return null;
+    const pitch = Math.asin(dz / segmentLength);
+    const yaw = Math.atan2(-dx, dy);
+    const midpoint = [
+      (previous[0] + point[0]) / 2,
+      (previous[1] + point[1]) / 2,
+      (previous[2] + point[2]) / 2
+    ];
+    const roundRadius = Math.max(
+      1e-3,
+      Math.min(width10, thickness, segmentLength) / 2 - 1e-3
+    );
+    const startWidth = widthAtDistance?.(startDistance + distances[index]) ?? width10;
+    const endWidth = widthAtDistance?.(startDistance + distances[index + 1]) ?? width10;
+    return /* @__PURE__ */ jsx(Translate, { offset: midpoint, children: /* @__PURE__ */ jsx(Rotate, { rotation: [pitch, 0, yaw], children: widthAtDistance ? /* @__PURE__ */ jsxs(Hull, { children: [
+      /* @__PURE__ */ jsx(
+        Cuboid,
+        {
+          size: [startWidth, overlap, thickness],
+          center: [acrossOffset, -segmentLength / 2, normalOffset]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Cuboid,
+        {
+          size: [endWidth, overlap, thickness],
+          center: [acrossOffset, segmentLength / 2, normalOffset]
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx(
+      RoundedCuboid,
+      {
+        size: [width10, segmentLength + overlap, thickness],
+        center: [acrossOffset, 0, normalOffset],
+        roundRadius
+      }
+    ) }) }, `${index}:${midpoint.join(":")}`);
+  }) });
+};
 var FlexScreen = (props) => {
   const {
     width: width10,
@@ -8837,13 +8994,15 @@ var FlexScreen = (props) => {
     flexCableLength = 28,
     flexCableThickness = 0.18,
     flexCableColor = "#d79528",
-    conductorCount = 8,
-    conductorPitch,
-    conductorWidth,
+    pinCount: conductorCount = props.conductorCount ?? 8,
+    pitch: conductorPitch = props.conductorPitch,
+    padWidth: conductorWidth = props.conductorWidth,
     conductorThickness = 0.035,
     conductorColor = "#8c4a18",
     cableEdgeMargin = 0.6,
-    exposedContactLength = 2.4,
+    padLength: exposedContactLength = props.exposedContactLength ?? 2.4,
+    tailLength,
+    taperLength,
     showConductors = true,
     showFlexCable = true,
     showStiffeners = true,
@@ -8891,8 +9050,11 @@ var FlexScreen = (props) => {
   assertPositive("foldOutset", foldOutset);
   assertPositive("boardThickness", boardThickness);
   if (showStiffeners) assertPositive("stiffenerThickness", stiffenerThickness);
+  if (!Number.isFinite(exposedContactLength) || exposedContactLength < 0) {
+    throw new Error("padLength must be a finite nonnegative length");
+  }
   if (!Number.isInteger(conductorCount) || conductorCount < 1) {
-    throw new Error("conductorCount must be a positive integer");
+    throw new Error("pinCount must be a positive integer");
   }
   if (!Number.isInteger(bendSegments) || bendSegments < 2) {
     throw new Error("bendSegments must be an integer of at least 2");
@@ -8912,17 +9074,22 @@ var FlexScreen = (props) => {
     throw new Error("cableEdgeMargin leaves no usable flex cable width");
   }
   const resolvedConductorPitch = conductorPitch ?? (conductorCount === 1 ? 0 : usableCableWidth / conductorCount);
-  if (conductorCount > 1 && (!Number.isFinite(resolvedConductorPitch) || resolvedConductorPitch <= 0)) {
-    throw new Error("conductorPitch must be greater than zero");
+  if ((conductorPitch !== void 0 || conductorCount > 1) && (!Number.isFinite(resolvedConductorPitch) || resolvedConductorPitch <= 0)) {
+    throw new Error("pitch must be greater than zero");
   }
   const resolvedConductorWidth = conductorWidth ?? (conductorCount === 1 ? Math.min(usableCableWidth, resolvedCableWidth * 0.45) : resolvedConductorPitch * 0.48);
-  assertPositive("conductorWidth", resolvedConductorWidth);
+  assertPositive("padWidth", resolvedConductorWidth);
   const conductorSpan = (conductorCount - 1) * resolvedConductorPitch + resolvedConductorWidth;
-  if (conductorSpan > usableCableWidth + EPSILON) {
-    throw new Error(
-      "conductorPitch and conductorWidth do not fit inside the flex cable margins"
-    );
-  }
+  const connectorWidth = Math.max(
+    resolvedCableWidth,
+    conductorSpan + cableEdgeMargin * 2
+  );
+  const widensAtConnector = connectorWidth > resolvedCableWidth + EPSILON;
+  const screenConductorPitch = widensAtConnector ? conductorCount === 1 ? 0 : usableCableWidth / conductorCount : resolvedConductorPitch;
+  const screenConductorWidth = widensAtConnector ? Math.min(
+    resolvedConductorWidth,
+    conductorCount === 1 ? usableCableWidth : screenConductorPitch * 0.48
+  ) : resolvedConductorWidth;
   const cableStartsBelowBoard = belowBoard && !foldedFace;
   const defaultCableZ = cableStartsBelowBoard ? boardTopZ - boardThickness - boardClearance - flexCableThickness / 2 : boardTopZ + boardClearance + flexCableThickness / 2;
   const start = [
@@ -8949,23 +9116,56 @@ var FlexScreen = (props) => {
     direction
   }) : createFlatPath(start, flexCableLength);
   const totalCableLength = getPathDistances(path).at(-1);
+  if (tailLength !== void 0) {
+    assertPositive("tailLength", tailLength);
+    if (tailLength >= totalCableLength) {
+      throw new Error("tailLength must be shorter than flexCableLength");
+    }
+  }
+  if (taperLength !== void 0) assertPositive("taperLength", taperLength);
   const contactLength = Math.min(
     Math.max(0, exposedContactLength),
-    totalCableLength / 2
+    totalCableLength / 2,
+    tailLength ?? Infinity
   );
   const resolvedStiffenerLength = Math.min(
     Math.max(0, stiffenerLength),
-    totalCableLength / 2
+    totalCableLength / 2,
+    tailLength ?? Infinity
   );
+  const connectorLeadLength = tailLength ?? Math.max(contactLength, resolvedStiffenerLength);
+  if (taperLength !== void 0 && connectorLeadLength + taperLength > totalCableLength + EPSILON) {
+    throw new Error(
+      "tailLength and taperLength must fit within flexCableLength"
+    );
+  }
+  const taperEndDistance = Math.min(
+    totalCableLength,
+    connectorLeadLength + (taperLength ?? Math.max(3, (connectorWidth - resolvedCableWidth) / 2))
+  );
+  const cableWidthAtDistance = (distance2) => {
+    if (distance2 <= connectorLeadLength) return connectorWidth;
+    const progress = Math.min(
+      1,
+      (distance2 - connectorLeadLength) / (taperEndDistance - connectorLeadLength)
+    );
+    return connectorWidth + (resolvedCableWidth - connectorWidth) * progress;
+  };
+  const cablePath = widensAtConnector ? [
+    ...slicePath(path, 0, connectorLeadLength),
+    ...slicePath(path, connectorLeadLength, taperEndDistance).slice(1),
+    ...slicePath(path, taperEndDistance, totalCableLength).slice(1)
+  ] : path;
+  const widthProfile = widensAtConnector ? cableWidthAtDistance : void 0;
   const startContacts = slicePath(path, 0, contactLength);
   const endContacts = slicePath(
     path,
     totalCableLength - contactLength,
     totalCableLength
   );
-  const startStiffener = slicePath(path, 0, resolvedStiffenerLength);
+  const startStiffener = slicePath(cablePath, 0, resolvedStiffenerLength);
   const endStiffener = slicePath(
-    path,
+    cablePath,
     totalCableLength - resolvedStiffenerLength,
     totalCableLength
   );
@@ -9014,7 +9214,7 @@ var FlexScreen = (props) => {
   ];
   const conductorOffsets = Array.from(
     { length: conductorCount },
-    (_, index) => conductorCount === 1 ? 0 : (index - (conductorCount - 1) / 2) * resolvedConductorPitch
+    (_, index) => (index - (conductorCount - 1) / 2) * resolvedConductorPitch
   );
   const conductorNormalOffset = (flexCableThickness + conductorThickness) / 2;
   const stiffenerNormalOffset = -(flexCableThickness + stiffenerThickness) / 2;
@@ -9022,8 +9222,9 @@ var FlexScreen = (props) => {
     showFlexCable && /* @__PURE__ */ jsx(
       CableStrip,
       {
-        points: path,
+        points: cablePath,
         width: resolvedCableWidth,
+        widthAtDistance: widthProfile,
         thickness: flexCableThickness,
         color: flexCableColor
       }
@@ -9033,7 +9234,7 @@ var FlexScreen = (props) => {
         CableStrip,
         {
           points: startStiffener,
-          width: resolvedCableWidth,
+          width: connectorWidth,
           thickness: stiffenerThickness,
           color: stiffenerColor,
           normalOffset: stiffenerNormalOffset
@@ -9044,6 +9245,8 @@ var FlexScreen = (props) => {
         {
           points: endStiffener,
           width: resolvedCableWidth,
+          widthAtDistance: widthProfile,
+          startDistance: totalCableLength - resolvedStiffenerLength,
           thickness: stiffenerThickness,
           color: stiffenerColor,
           normalOffset: stiffenerNormalOffset
@@ -9066,10 +9269,10 @@ var FlexScreen = (props) => {
         CableStrip,
         {
           points: endContacts,
-          width: resolvedConductorWidth,
+          width: screenConductorWidth,
           thickness: conductorThickness,
           color: conductorColor,
-          acrossOffset,
+          acrossOffset: (index - (conductorCount - 1) / 2) * screenConductorPitch,
           normalOffset: conductorNormalOffset
         }
       )
@@ -9108,6 +9311,10 @@ var Footprinter3d = ({ footprint }) => {
   if (mp3.getModelNames().includes(modelFn)) {
     const model = mp3.string(footprint).json();
     switch (model.fn) {
+      case "hexbolt": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(HexBolt, { ...props });
+      }
       case "nema": {
         const { fn, ...props } = model;
         return /* @__PURE__ */ jsx(NemaMotor, { ...props });
@@ -10054,6 +10261,7 @@ function createJSCADRenderer(jscad4) {
 export {
   Fragment,
   HelicalGear,
+  HexBolt,
   HexSocketBolt,
   NEMA17,
   NEMA23,
@@ -10065,6 +10273,8 @@ export {
   convertCSGToThreeGeom,
   createHelicalGearGeom,
   createHelicalGearMesh,
+  createHexBoltGeom,
+  createHexBoltMesh,
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,