jscad-electronics 0.0.148 → 0.0.150

package/dist/index.d.ts

@@ -96,7 +96,7 @@ declare const ExtrudedPads: ({ circuitJson, footprint, }: {
 declare const FootprintPad: ({ pad, isPin1, }: {
     pad: PcbSmtPad;
     isPin1?: boolean;
-}) => react_jsx_runtime.JSX.Element;
+}) => react_jsx_runtime.JSX.Element | null;
 
 declare const FootprintPlatedHole: ({ hole, isPin1, }: {
     hole: PcbPlatedHole;
@@ -334,7 +334,26 @@ declare const SOD123F: () => react_jsx_runtime.JSX.Element;
 
 declare const SOD123FL: () => react_jsx_runtime.JSX.Element;
 
-declare const SOD123W: () => react_jsx_runtime.JSX.Element;
+interface SOD123WProps {
+    /** Body extent along the leads (X). */
+    bodyWidth?: number;
+    /** Body extent across the leads (Y). */
+    bodyLength?: number;
+    bodyHeight?: number;
+}
+/**
+ * SOD-123W.
+ *
+ * Defaults are the package outline for that designation — 2.60 x 1.70, per
+ * KiCad's `Nexperia_CFP3_SOD-123W` F.Fab layer, which is the same reference
+ * footprinter's own kicad-parity tests compare against.
+ *
+ * The dimensions are props because the shape (a moulded body with a metal cap
+ * at each end) serves several designations at different sizes; the SIZE is
+ * what makes it one package or another, so it must never be assumed. `sod110`
+ * used these defaults for a while and rendered a body 24% too long.
+ */
+declare const SOD123W: ({ bodyWidth, bodyLength, bodyHeight, }?: SOD123WProps) => react_jsx_runtime.JSX.Element;
 
 declare const SOD128: () => react_jsx_runtime.JSX.Element;
 
@@ -346,7 +365,29 @@ declare const SOD323FL: () => react_jsx_runtime.JSX.Element;
 
 declare const SOD923: () => react_jsx_runtime.JSX.Element;
 
-declare const SOT223: () => react_jsx_runtime.JSX.Element;
+interface SOT223Props {
+    /** Pad-to-pad span across the leads (X). */
+    fullWidth?: number;
+    /** X extent of the moulded body. */
+    bodyWidth?: number;
+    /** Y extent of the moulded body. */
+    bodyLength?: number;
+    bodyHeight?: number;
+    /** Y width of the three signal leads. */
+    leadWidth?: number;
+    /** Y width of the single wide tab lead on the opposite side. */
+    tabLeadWidth?: number;
+    /** Y pitch of the signal leads. */
+    padPitch?: number;
+    /** How high the lead rises from the pad to the body face. */
+    leadHeight?: number;
+}
+/**
+ * SOT-223 and its smaller relative SOT-89: three leads one side, one wide tab
+ * lead the other. Same construction, different dimensions, so the dimensions
+ * are props — SOT-89's body is 4.5 x 2.5 x 1.5, barely a third of the volume.
+ */
+declare const SOT223: ({ fullWidth, bodyWidth, bodyLength, bodyHeight, leadWidth, tabLeadWidth, padPitch, leadHeight, }?: SOT223Props) => react_jsx_runtime.JSX.Element;
 
 declare const SOT457: () => react_jsx_runtime.JSX.Element;
 
@@ -419,9 +460,94 @@ declare const MS013: ({ pinCount, padContactLength, leadWidth, pitch, }: {
     padContactLength?: number;
 }) => react_jsx_runtime.JSX.Element;
 
-declare const TO220: () => react_jsx_runtime.JSX.Element;
+interface TO220Lead {
+    x: number;
+    y: number;
+}
+interface TO220Props {
+    /**
+     * TO-220F is the fully-moulded (isolated) variant: same outline, but the
+     * metal tab is encapsulated rather than exposed. Aliasing the two would
+     * report a bare metal face where there is plastic — which matters as soon
+     * as anything reasons about the tab, so it is a flag rather than an alias.
+     */
+    mouldedTab?: boolean;
+    /** Where the leads meet the board, from the footprint's plated holes. */
+    leads?: TO220Lead[];
+    /** Width across the package (X). */
+    bodyWidth?: number;
+    /** Thickness of the moulded body (Y). */
+    bodyThickness?: number;
+    /** Height of the moulded body above its own base. */
+    bodyHeight?: number;
+    /** How much metal tab stands above the moulded body. */
+    tabHeight?: number;
+    tabThickness?: number;
+    mountingHoleDiameter?: number;
+    /** Gap between the board and the underside of the body. */
+    standoff?: number;
+    /** How far the leads run below the board. */
+    leadLength?: number;
+    bodyColor?: string;
+    tabColor?: string;
+    leadColor?: string;
+}
+/**
+ * TO-220, mounted upright.
+ *
+ * Authored standing up, in board coordinates, rather than lying down and
+ * rotated into place. The rotations it used to carry were bare numbers
+ * (`rotation={[0, 55, -55]}`), which both renderers read as RADIANS: 55 rad is
+ * 271.3°, so the part stood up only because 271.3° is nearly -90°, and it
+ * leaned 1.3° off vertical. With 16mm leads it also measured 32.5mm tall for a
+ * part that is 18mm over the board, and the holes met the leads at their tips
+ * instead of just under the body.
+ */
+declare const TO220: ({ mouldedTab, leads, bodyWidth, bodyThickness, bodyHeight, tabHeight, tabThickness, mountingHoleDiameter, standoff, leadLength, bodyColor, tabColor, leadColor, }?: TO220Props) => react_jsx_runtime.JSX.Element;
 
-declare const TO92: () => react_jsx_runtime.JSX.Element;
+interface TO92Lead {
+    x: number;
+    y: number;
+}
+interface TO92Props {
+    /**
+     * Diameter of the round body. TO-92 comes in more than one size — `to92l`
+     * is 4.8mm across, `to92s` 2.5mm — and the difference is the whole reason
+     * these are separate footprints, so it must not be baked in.
+     */
+    bodyDiameter?: number;
+    bodyHeight?: number;
+    /** Depth of the flat cut across the cylinder. */
+    flatCut?: number;
+    /**
+     * Where the leads meet the board, taken from the footprint's plated holes.
+     *
+     * The pattern differs per footprint and cannot be inferred from the pitch:
+     * `to92` sets its middle pin 1.27mm behind the outer two, `to92s` puts all
+     * three in a row, and `to92l` places pin 1 at the origin so the group is not
+     * centred at all. Defaults to `to92`'s pattern.
+     */
+    leads?: TO92Lead[];
+    /**
+     * Gap between the board and the underside of the moulded body — the leads
+     * are formed in it.
+     */
+    standoff?: number;
+    /** How far the leads run below the board. */
+    leadLength?: number;
+    bodyColor?: string;
+}
+/**
+ * TO-92.
+ *
+ * Seated and aligned from the footprint: the body is centred on the two outer
+ * leads, starts `standoff` above the board and ends `bodyHeight` higher, and
+ * every lead is formed from its own hole up to a row of exit points under the
+ * body. It used to be translated 10.5mm up with 15mm leads on a hardcoded
+ * pattern, which measured 19.5mm end to end for a 4.5mm part and only lined up
+ * with one of the three TO-92 footprints.
+ */
+declare const TO92: ({ bodyDiameter, bodyHeight, flatCut, leads, standoff, leadLength, bodyColor, }?: TO92Props) => react_jsx_runtime.JSX.Element;
 
 declare const MountedPcbModule: ({ numPins, rows, p, id, od, boardThickness, width, height, pinRowSide, holes, holeInset, pinRowHoleEdgeToEdgeDist, female, nopin, screen, screenWidth, screenHeight, screenCenterOffsetX, screenCenterOffsetY, }: {
     numPins?: number;
@@ -540,4 +666,215 @@ interface RJ45Props {
  */
 declare const RJ45: ({ bodyWidth, bodyDepth, bodyHeight, bodyCenterY, ledPins, firstPinLeft, firstPinTop, signalPitch, signalRowPitch, signalHoleDiameter, shieldPinX, shieldPinY, shieldHoleDiameter, locatorHoleX, locatorHoleY, locatorHoleDiameter, ledPinX, ledPinPitch, ledPinY, openingDirection, shellColor, housingColor, contactColor, }: RJ45Props) => react_jsx_runtime.JSX.Element;
 
-export { A01005, A0201, A0402, A0603, A0805, A1206, A1210, A2010, A2512, AxialCapacitor, BGA, ChipBody, type ChipBodyProps, Crystal, type CrystalProps, DFN, Display, ExtrudedPads, FPC, type FPCProps, FemaleHeader, FemaleHeaderRow, FootprintPad, FootprintPlatedHole, Footprinter3d, HC49, type HC49Props, JSTZH1_5mm, LQFP, Led5050, type Led5050Props, MELF, type MELFProps, MINIMELF, type MINIMELFProps, MS012, MS013, MSOP, MicroMELF, type MicroMELFProps, MountedPcbModule, PinHeader, PinRow, QFN, QFP, RJ45, type RJ45Props, SMA, SMB, SMC, SMF, SOD123, SOD123F, SOD123FL, type SOD123Props, SOD123W, SOD128, SOD323, SOD323F, SOD323FL, SOD523, SOD723, SOD882, SOD923, SOT223, SOT233P, SOT23W, SOT323, SOT363, SOT457, SOT563, SOT723, SOT886, SOT963, Screen, type ScreenProps, SmdChipLead, type SmdChipLeadProps, SmdPinHeader, type SmdPinHeaderProps, StampBoard, TO220, TO92, TQFP, Tssop, VSSOP };
+interface DPAKProps {
+    /** X extent of the moulded body (the lead-to-tab axis) */
+    bodyWidth?: number;
+    /** Y extent of the moulded body (across the leads) */
+    bodyLength?: number;
+    /** Height of the moulded body above the board */
+    bodyHeight?: number;
+    /** X extent of the exposed metal tab (the drain/collector pad) */
+    tabWidth?: number;
+    /** Y extent of the exposed metal tab */
+    tabLength?: number;
+    /** Distance between the lead pad centres and the tab pad centre */
+    span?: number;
+    /** Lead pitch along Y */
+    pitch?: number;
+    /** Y width of one lead */
+    leadWidth?: number;
+    /** X length of the lead's flat pad contact */
+    leadContactLength?: number;
+    /**
+     * TO-252 (DPAK) and TO-263 (D2PAK) differ only in size, so one body serves
+     * both — pass the dimensions footprinter reports for the specific package.
+     */
+    color?: string;
+    tabColor?: string;
+    leadColor?: string;
+}
+/**
+ * TO-252 (DPAK) / TO-263 (D2PAK): a moulded body sitting on a large exposed
+ * metal tab, with gull leads leaving the opposite face.
+ *
+ * The footprint is asymmetric — footprinter puts the lead pads at -span/2 and
+ * the tab pad at +span/2 — so the body is placed over the tab rather than over
+ * the origin. Getting that wrong moves a 4.4mm-tall part several millimetres,
+ * which is exactly the error an enclosure clearance check cannot see.
+ */
+declare const DPAK: ({ bodyWidth, bodyLength, bodyHeight, tabWidth, tabLength, span, pitch, leadWidth, leadContactLength, color, tabColor, leadColor, }: DPAKProps) => react_jsx_runtime.JSX.Element;
+
+interface ElectrolyticCapacitorProps {
+    /** Can diameter. footprinter reports this as `d` for `electrolytic`. */
+    diameter?: number;
+    /**
+     * Can height. Not part of any footprint: the same 10mm can is made in a
+     * dozen heights. Defaults to `heightToDiameterRatio * diameter`, which for
+     * the common radial series is a slight OVER-estimate — for a clearance
+     * check that is the safe direction to be wrong in.
+     */
+    height?: number;
+    heightToDiameterRatio?: number;
+    /** Lead pitch (footprinter's `p`). */
+    leadPitch?: number;
+    leadDiameter?: number;
+    /** How far the leads run below the board. */
+    leadLength?: number;
+    sleeveColor?: string;
+    baseColor?: string;
+}
+/**
+ * Radial (can) electrolytic capacitor: the part an enclosure cavity is usually
+ * sized around, and until now one with no body at all.
+ *
+ * Only the diameter and the lead pitch come from the footprint. The height is
+ * derived, and deliberately generous — see `heightToDiameterRatio`.
+ */
+declare const ElectrolyticCapacitor: ({ diameter, heightToDiameterRatio, height, leadPitch, leadDiameter, leadLength, sleeveColor, baseColor, }: ElectrolyticCapacitorProps) => react_jsx_runtime.JSX.Element;
+
+interface Led2835Props {
+    /** X extent of the package (footprinter reports 3.5 for `led2835`). */
+    bodyWidth?: number;
+    /** Y extent of the package. */
+    bodyLength?: number;
+    bodyHeight?: number;
+    /** Emitter colour when lit — the lens square on the top face. */
+    color?: string;
+    bodyColor?: string;
+    padColor?: string;
+    /** Pad centres and widths, so the terminals line up with the footprint. */
+    pad1X?: number;
+    pad1Width?: number;
+    pad2X?: number;
+    pad2Width?: number;
+    padLength?: number;
+}
+/**
+ * 2835 chip LED: a flat rectangular package with an emitter window, unlike the
+ * symmetric two-terminal chips (0805 etc.) whose pads are mirrored — footprinter
+ * gives `led2835` two DIFFERENT pad widths at two different offsets, so the body
+ * is not centred on the pads.
+ */
+declare const Led2835: ({ bodyWidth, bodyLength, bodyHeight, color, bodyColor, padColor, pad1X, pad1Width, pad2X, pad2Width, padLength, }?: Led2835Props) => react_jsx_runtime.JSX.Element;
+
+interface PotentiometerLead {
+    x: number;
+    y: number;
+}
+interface PotentiometerProps {
+    /** X extent of the body (footprinter's `w`). */
+    bodyWidth?: number;
+    /** Y extent of the body (footprinter's `ca`). */
+    bodyLength?: number;
+    /** Height of the body above the board (footprinter's `h`). */
+    bodyHeight?: number;
+    /** X offset of the body centre from the footprint origin. */
+    bodyCenterX?: number;
+    /** Diameter of the adjuster on the top face. */
+    adjusterDiameter?: number;
+    /**
+     * A panel-mount pot's shaft. Zero by default and on purpose: the footprint
+     * carries no shaft dimension, and inventing one would make an enclosure
+     * cut a hole for a part that has no shaft, or clear a volume it does not
+     * need. Pass it explicitly for a panel pot.
+     */
+    shaftDiameter?: number;
+    shaftHeight?: number;
+    /**
+     * Where the pins meet the board, from the footprint's plated holes. A
+     * through-hole part with no pins at all is not a body anyone can check
+     * against its footprint — it just floats over three empty holes.
+     */
+    leads?: PotentiometerLead[];
+    /** Diameter of a pin, and how far it runs below the board. */
+    leadDiameter?: number;
+    leadLength?: number;
+    bodyColor?: string;
+    adjusterColor?: string;
+}
+/**
+ * Trimmer / potentiometer body.
+ *
+ * The extent comes from the footprint: `w` across, `ca` along, `h` tall. What
+ * the footprint cannot tell us is the shaft, so there is none unless asked
+ * for — see `shaftHeight`.
+ *
+ * Name: `core` also exports a `Potentiometer`, and that one is a circuit
+ * element (a React component with ports and a footprint). This is a JSCAD
+ * solid with no electrical meaning, and it is named for the package the way
+ * every other body in this directory is (`PushButton`, `RJ45`, `Crystal`,
+ * which shadow core the same way). Renaming it would break that convention to
+ * avoid a collision that cannot occur: nothing imports both.
+ */
+declare const Potentiometer: ({ bodyWidth, bodyLength, bodyHeight, bodyCenterX, adjusterDiameter, shaftDiameter, shaftHeight, leads, leadDiameter, leadLength, bodyColor, adjusterColor, }: PotentiometerProps) => react_jsx_runtime.JSX.Element;
+
+interface SmdPushButtonProps {
+    /** X extent of the moulded body. */
+    bodyWidth?: number;
+    /** Y extent of the moulded body. */
+    bodyLength?: number;
+    /** Height of the body above the board. */
+    bodyHeight?: number;
+    /** Diameter of the actuator on the top face. */
+    actuatorDiameter?: number;
+    /** How far the actuator stands proud of the body — the real part height. */
+    actuatorHeight?: number;
+    /** X distance between the pad centres on opposite sides. */
+    padSpanX?: number;
+    /** Y distance between the two pad rows. */
+    padSpanY?: number;
+    padWidth?: number;
+    padLength?: number;
+    bodyColor?: string;
+    actuatorColor?: string;
+    leadColor?: string;
+}
+/**
+ * SMD tactile push button.
+ *
+ * The body outline is the footprint's silkscreen (2.86 x 3.04 for footprinter's
+ * `smdpushbutton`); the height is the switch's, not the footprint's — a
+ * footprint cannot describe an actuator. `actuatorHeight` is the part of that
+ * height an enclosure lid has to clear or press on, so it is separate from
+ * `bodyHeight` rather than folded into it.
+ */
+declare const SmdPushButton: ({ bodyWidth, bodyLength, bodyHeight, actuatorDiameter, actuatorHeight, padSpanX, padSpanY, padWidth, padLength, bodyColor, actuatorColor, leadColor, }: SmdPushButtonProps) => react_jsx_runtime.JSX.Element;
+
+interface SmdLeadPad {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+interface GullWingBodyProps {
+    /** X extent of the moulded body. */
+    bodyWidth: number;
+    /** Y extent of the moulded body. */
+    bodyLength: number;
+    bodyHeight?: number;
+    /** Where each lead meets the board, from the footprint's own pads. */
+    pads: SmdLeadPad[];
+    leadThickness?: number;
+    /** How high the lead rises from the board to the body, as a fraction of the body height. */
+    leadHeightRatio?: number;
+}
+/**
+ * A small-outline package with gull-wing leads on its left and right faces,
+ * one lead per PAD.
+ *
+ * Two things come from two different places on purpose:
+ *
+ *  - the body is the designation's (`bodyWidth`/`bodyLength` are passed in
+ *    from the package outline, never derived from the land pattern);
+ *  - the leads are the footprint's, because lead COUNT is not a property of a
+ *    body outline. SOT-23-5 and SOT-23-6 share a body; SC-70-4 and SC-70-6
+ *    share a body. A body picked by outline alone ends up with the wrong
+ *    number of legs, which is what this component exists to prevent.
+ *
+ * The leg itself is `SmdChipLead`, the same S-curve every other gull-wing part
+ * here uses (SOIC, SOT-235, SOT-223, MSOP, QFP, MS-012). Anything else is a
+ * second kind of leg in a repo that already has one.
+ */
+declare const GullWingBody: ({ bodyWidth, bodyLength, bodyHeight, pads, leadThickness, leadHeightRatio, }: GullWingBodyProps) => react_jsx_runtime.JSX.Element;
+
+export { A01005, A0201, A0402, A0603, A0805, A1206, A1210, A2010, A2512, AxialCapacitor, BGA, ChipBody, type ChipBodyProps, Crystal, type CrystalProps, DFN, DPAK, type DPAKProps, Display, ElectrolyticCapacitor, type ElectrolyticCapacitorProps, ExtrudedPads, FPC, type FPCProps, FemaleHeader, FemaleHeaderRow, FootprintPad, FootprintPlatedHole, Footprinter3d, GullWingBody, type GullWingBodyProps, HC49, type HC49Props, JSTZH1_5mm, LQFP, Led2835, type Led2835Props, Led5050, type Led5050Props, MELF, type MELFProps, MINIMELF, type MINIMELFProps, MS012, MS013, MSOP, MicroMELF, type MicroMELFProps, MountedPcbModule, PinHeader, PinRow, Potentiometer, type PotentiometerLead, type PotentiometerProps, QFN, QFP, RJ45, type RJ45Props, SMA, SMB, SMC, SMF, SOD123, SOD123F, SOD123FL, type SOD123Props, SOD123W, type SOD123WProps, SOD128, SOD323, SOD323F, SOD323FL, SOD523, SOD723, SOD882, SOD923, SOT223, type SOT223Props, SOT233P, SOT23W, SOT323, SOT363, SOT457, SOT563, SOT723, SOT886, SOT963, Screen, type ScreenProps, SmdChipLead, type SmdChipLeadProps, type SmdLeadPad, SmdPinHeader, type SmdPinHeaderProps, SmdPushButton, type SmdPushButtonProps, StampBoard, TO220, type TO220Lead, type TO220Props, TO92, type TO92Lead, type TO92Props, TQFP, Tssop, VSSOP };