jscad-electronics 0.0.195 → 0.0.196

package/dist/vanilla.d.ts

@@ -3,7 +3,7 @@ import { BufferGeometry } from 'three';
 import * as jscadModeling from '@jscad/modeling';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
-import { FlatHeadScrewModelPropsInput, SpurGearModelPropsInput, HelicalGearModelPropsInput, HexBoltModelPropsInput, HexSocketBoltModelPropsInput, NemaMotorModelPropsInput, SheetMetalModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
+import { FlatHeadScrewModelPropsInput, SpurGearModelPropsInput, HelicalGearModelPropsInput, HexBoltModelPropsInput, HexSocketBoltModelPropsInput, NemaMotorModelPropsInput, PanScrewModelPropsInput, SheetMetalModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
 
 type VNode = {
     type: any;
@@ -124,6 +124,23 @@ declare const NEMA8: (props: NemaFrameMotorProps) => react_jsx_runtime.JSX.Eleme
 declare const NEMA17: (props: NemaFrameMotorProps) => react_jsx_runtime.JSX.Element;
 declare const NEMA23: (props: NemaFrameMotorProps) => react_jsx_runtime.JSX.Element;
 
+interface PanScrewMeshOptions {
+    radialSegments?: number;
+    threadStepsPerTurn?: number;
+}
+/** Outward-oriented, welded indexed surface, in millimeters. */
+interface PanScrewMesh {
+    positions: number[];
+    indices: number[];
+}
+declare function createPanScrewMesh(input: PanScrewModelPropsInput, options?: PanScrewMeshOptions): PanScrewMesh;
+
+type PanScrewProps = PanScrewModelPropsInput & {
+    color?: string;
+};
+declare function createPanScrewGeom(input: PanScrewModelPropsInput, options?: PanScrewMeshOptions): _jscad_modeling_src_geometries_types.Geom3;
+declare function PanScrew({ color, ...props }: PanScrewProps): react_jsx_runtime.JSX.Element;
+
 interface SheetMetalMesh {
     positions: number[];
     indices: number[];
@@ -178,4 +195,4 @@ declare function createJSCADRenderer(jscad: typeof jscadModeling): {
     };
 };
 
-export { type ColoredGeom, FlatHeadScrew, type FlatHeadScrewMesh, type FlatHeadScrewMeshOptions, type FlatHeadScrewProps, 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, createFlatHeadScrewGeom, createFlatHeadScrewMesh, createHelicalGearGeom, createHelicalGearMesh, createHexBoltGeom, createHexBoltMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };
+export { type ColoredGeom, FlatHeadScrew, type FlatHeadScrewMesh, type FlatHeadScrewMeshOptions, type FlatHeadScrewProps, 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, PanScrew, type PanScrewMesh, type PanScrewMeshOptions, type PanScrewProps, type RenderResult, SheetMetal, type SheetMetalMesh, type SheetMetalProps, SpurGear, type SpurGearMesh, type SpurGearProps, type VNode, WormGear, type WormGearMesh, type WormGearProps, convertCSGToThreeGeom, createFlatHeadScrewGeom, createFlatHeadScrewMesh, createHelicalGearGeom, createHelicalGearMesh, createHexBoltGeom, createHexBoltMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createPanScrewGeom, createPanScrewMesh, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -183,24 +183,24 @@ var FootprintPlatedHole = ({
 import { flatHeadScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model10) {
-  return model10;
+function defineModelRenderer(model11) {
+  return model11;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model10) {
-    if (typeof model10.name !== "string" || !/^[a-z]+$/.test(model10.name)) {
+  register(model11) {
+    if (typeof model11.name !== "string" || !/^[a-z]+$/.test(model11.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model10.name)) {
-      throw new Error(`Model renderer "${model10.name}" is already registered`);
+    if (this.models.has(model11.name)) {
+      throw new Error(`Model renderer "${model11.name}" is already registered`);
     }
-    if (model10.pads !== "none" && model10.pads !== "footprinter") {
+    if (model11.pads !== "none" && model11.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model10;
+    const { name, schema, render: render2, pads } = model11;
     this.models.set(name, {
       name,
       schema,
@@ -1819,6 +1819,225 @@ function register6(registry) {
   registry.register(model6);
 }
 
+// lib/models/panscrew/register.tsx
+import { panScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/panscrew/mesh.ts
+import {
+  panScrewModelPropsSchema
+} from "@tscircuit/modelprinter";
+function createPanScrewMesh(input, options = {}) {
+  const p = panScrewModelPropsSchema.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 point2 = (i) => positions.slice(3 * i, 3 * i + 3);
+    const A = point2(a), B = point2(b), C = point2(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 + 160) * 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 crown = (r) => p.headHeight - p.crownRadius + Math.sqrt(p.crownRadius * p.crownRadius - r * r);
+  const rad265 = p.recessOuterWingAngle * Math.PI / 180, rad28 = p.recessInnerWingAngle * Math.PI / 180;
+  const tg = (p.recessReferenceDiameter - p.recessG) / 2 / Math.tan(rad265);
+  const totalDepth = tg + p.recessG / 2 * Math.tan(rad28);
+  const tb = tg + (p.recessG - p.recessB) / 2 * Math.tan(rad28);
+  const beta = p.recessBeta * Math.PI / 180;
+  const alphaProjected = Math.atan(
+    Math.tan(p.recessAlpha * Math.PI / 360) / Math.cos(beta)
+  );
+  const cornerProjected = Math.atan(
+    Math.tan(46 * Math.PI / 180) / Math.cos(beta)
+  );
+  const dre = p.recessE / 2 / Math.tan(alphaProjected);
+  const cornerRadius = (z, theta) => {
+    const depth = p.recessReferencePlaneHeight - z;
+    const b = p.recessB / 2 - (depth - tb) * Math.tan(beta);
+    const delta = Math.abs(
+      (theta - Math.PI / 4 + Math.PI / 4 + 4 * Math.PI) % (Math.PI / 2) - Math.PI / 4
+    );
+    const ca = Math.cos(delta), sa = Math.sin(delta);
+    const tanA = Math.tan(alphaProjected), tanC = Math.tan(cornerProjected);
+    const first = tanA * b / (tanA * ca - sa);
+    const corner = first * ca <= b + dre ? first : (tanC * (b + dre) - p.recessE / 2) / (tanC * ca - sa);
+    return Math.max(0, corner);
+  };
+  const recessRadius = (z, theta) => {
+    const depth = p.recessReferencePlaneHeight - z;
+    const outer = depth <= tg ? p.recessReferenceDiameter / 2 - depth * Math.tan(rad265) : (totalDepth - depth) / Math.tan(rad28);
+    return Math.max(0, Math.min(outer, cornerRadius(z, theta)));
+  };
+  const entryRadius = p.recessRadius, sphereZ = p.headHeight - p.crownRadius, slope = Math.tan(rad265), line = p.recessReferenceDiameter / 2 - slope * p.recessReferencePlaneHeight + entryRadius / Math.cos(rad265), offset = slope * sphereZ + line, innerSphere = p.crownRadius - entryRadius, centerAboveSphere = (-slope * offset + Math.sqrt((1 + slope * slope) * innerSphere ** 2 - offset ** 2)) / (1 + slope * slope), entryCenterZ = sphereZ + centerAboveSphere, entryCenterR = slope * entryCenterZ + line, entryStart = Math.atan2(centerAboveSphere, entryCenterR), entryEnd = Math.PI - rad265, mouthR = entryCenterR + entryRadius * Math.cos(entryStart), wallZ = entryCenterZ + entryRadius * Math.sin(entryEnd);
+  add(() => p.headDiameter / 2, 0);
+  add(() => p.headDiameter / 2, crown(p.headDiameter / 2));
+  const opening = Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments;
+    let lo = 0, hi = mouthR;
+    for (let n = 0; n < 48; n++) {
+      const r = (lo + hi) / 2;
+      if (r < cornerRadius(crown(r), theta)) lo = r;
+      else hi = r;
+    }
+    return (lo + hi) / 2;
+  });
+  for (let n = 1; n <= 20; n++) {
+    const r = (theta) => {
+      const i = Math.round(theta * segments / (2 * Math.PI)) % segments;
+      return p.headDiameter / 2 + (opening[i] - p.headDiameter / 2) * n / 20;
+    };
+    add(r, (theta) => crown(r(theta)));
+  }
+  const entryClips = Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments;
+    const point2 = (angle2) => ({
+      r: entryCenterR + entryRadius * Math.cos(angle2),
+      z: entryCenterZ + entryRadius * Math.sin(angle2)
+    });
+    const outside = (angle2) => {
+      const q = point2(angle2);
+      return q.r > cornerRadius(q.z, theta);
+    };
+    if (!outside(entryStart)) return { angle: entryStart, ...point2(entryStart) };
+    if (outside(entryEnd))
+      return { angle: entryEnd, r: cornerRadius(wallZ, theta), z: wallZ };
+    let lo = entryStart, hi = entryEnd;
+    for (let n = 0; n < 48; n++) {
+      const angle2 = (lo + hi) / 2;
+      if (outside(angle2)) lo = angle2;
+      else hi = angle2;
+    }
+    const angle = (lo + hi) / 2;
+    return { angle, ...point2(angle) };
+  });
+  for (let n = 0; n <= 24; n++) {
+    const angle = entryStart + (entryEnd - entryStart) * n / 24;
+    const r = entryCenterR + entryRadius * Math.cos(angle), z = entryCenterZ + entryRadius * Math.sin(angle);
+    const clip = (theta) => entryClips[Math.round(theta * segments / (2 * Math.PI)) % segments];
+    add(
+      (theta) => angle <= clip(theta).angle ? clip(theta).r : r,
+      (theta) => angle <= clip(theta).angle ? clip(theta).z : z
+    );
+  }
+  const floor = p.recessReferencePlaneHeight - totalDepth;
+  const driveLevels = /* @__PURE__ */ new Set([p.recessReferencePlaneHeight - tg]);
+  for (let n = 1; n < 48; n++)
+    driveLevels.add(wallZ + (floor - wallZ) * n / 48);
+  for (const z of [...driveLevels].filter((z2) => z2 < wallZ && z2 > floor).sort((a, b) => b - a)) {
+    add((theta) => recessRadius(z, theta), z);
+  }
+  const point = vertex(0, 0, floor);
+  for (let i = 0; i < segments; i++)
+    triangle(point, previous[i], previous[(i + 1) % segments]);
+  return { positions, indices };
+}
+
+// lib/models/panscrew/PanScrew.tsx
+function createPanScrewGeom(input, options) {
+  return indexedMeshToGeom3(createPanScrewMesh(input, options));
+}
+function PanScrew({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createPanScrewGeom(props) }) });
+}
+
+// lib/models/panscrew/register.tsx
+var model7 = defineModelRenderer({
+  name: "panscrew",
+  schema: panScrewModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
+  pads: "none"
+});
+function register7(registry) {
+  registry.register(model7);
+}
+
 // lib/models/sheetmetal/register.tsx
 import { sheetMetalModelDefinitionSchema } from "@tscircuit/modelprinter";
 
@@ -1976,14 +2195,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model7 = defineModelRenderer({
+var model8 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register7(registry) {
-  registry.register(model7);
+function register8(registry) {
+  registry.register(model8);
 }
 
 // lib/models/spurgear/register.tsx
@@ -1998,14 +2217,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model8 = defineModelRenderer({
+var model9 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register8(registry) {
-  registry.register(model8);
+function register9(registry) {
+  registry.register(model9);
 }
 
 // lib/models/wormgear/register.tsx
@@ -2197,14 +2416,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model9 = defineModelRenderer({
+var model10 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register9(registry) {
-  registry.register(model9);
+function register10(registry) {
+  registry.register(model10);
 }
 
 // lib/generated/model-renderers.ts
@@ -2218,6 +2437,7 @@ function registerAllModelRenderers(registry) {
   register7(registry);
   register8(registry);
   register9(registry);
+  register10(registry);
 }
 
 // lib/default-model-registry.ts
@@ -9774,10 +9994,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model10 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model10.fn);
+    const model11 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model11.fn);
     if (renderer) {
-      return renderer.render(model10);
+      return renderer.render(model11);
     }
   }
   let normalizedFootprint = footprint;
@@ -10737,6 +10957,7 @@ export {
   NEMA23,
   NEMA8,
   NemaMotor,
+  PanScrew,
   SheetMetal,
   SpurGear,
   WormGear,
@@ -10750,6 +10971,8 @@ export {
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,
+  createPanScrewGeom,
+  createPanScrewMesh,
   createSheetMetalGeom,
   createSheetMetalMesh,
   createSpurGearGeom,