@tscircuit/footprinter 0.0.280 → 0.0.281
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +1 -0
- package/dist/index.js +873 -735
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -35,6 +35,7 @@ __export(fn_exports, {
|
|
|
35
35
|
qfn: () => qfn,
|
|
36
36
|
qfp: () => qfp,
|
|
37
37
|
quad: () => quad,
|
|
38
|
+
radial: () => radial,
|
|
38
39
|
res: () => res,
|
|
39
40
|
sma: () => sma,
|
|
40
41
|
smb: () => smb,
|
|
@@ -2379,10 +2380,147 @@ var axial = (raw_params) => {
|
|
|
2379
2380
|
};
|
|
2380
2381
|
};
|
|
2381
2382
|
|
|
2382
|
-
// src/fn/
|
|
2383
|
-
import {
|
|
2383
|
+
// src/fn/radial.ts
|
|
2384
|
+
import {
|
|
2385
|
+
length as length11
|
|
2386
|
+
} from "circuit-json";
|
|
2384
2387
|
import { z as z19 } from "zod";
|
|
2385
2388
|
|
|
2389
|
+
// src/helpers/generateCircleArcs.ts
|
|
2390
|
+
var generateCircleArcs = (centerX, centerY, radius, cut, cutHeight, segmentLength = 0.1) => {
|
|
2391
|
+
const topArc = [];
|
|
2392
|
+
const bottomArc = [];
|
|
2393
|
+
const segments = Math.max(1, Math.ceil(Math.PI * radius / segmentLength));
|
|
2394
|
+
const thetaStep = Math.PI / segments;
|
|
2395
|
+
for (let i = 0; i <= segments; i++) {
|
|
2396
|
+
const theta = i * thetaStep;
|
|
2397
|
+
const x = centerX + Math.cos(theta) * radius;
|
|
2398
|
+
const y = centerY + Math.sin(theta) * radius;
|
|
2399
|
+
if (x < centerX - cut && y >= centerY - cutHeight / 2 && y <= centerY + cutHeight / 2) {
|
|
2400
|
+
continue;
|
|
2401
|
+
}
|
|
2402
|
+
topArc.push({ x, y });
|
|
2403
|
+
}
|
|
2404
|
+
for (let i = 0; i <= segments; i++) {
|
|
2405
|
+
const theta = Math.PI + i * thetaStep;
|
|
2406
|
+
const x = centerX + Math.cos(theta) * radius;
|
|
2407
|
+
const y = centerY + Math.sin(theta) * radius;
|
|
2408
|
+
if (x < centerX - cut && y >= centerY - cutHeight / 2 && y <= centerY + cutHeight / 2) {
|
|
2409
|
+
continue;
|
|
2410
|
+
}
|
|
2411
|
+
bottomArc.push({ x, y });
|
|
2412
|
+
}
|
|
2413
|
+
return { topArc, bottomArc };
|
|
2414
|
+
};
|
|
2415
|
+
|
|
2416
|
+
// src/fn/radial.ts
|
|
2417
|
+
var radial_def = base_def.extend({
|
|
2418
|
+
fn: z19.string(),
|
|
2419
|
+
p: length11.optional().default("5mm"),
|
|
2420
|
+
id: length11.optional().default("0.8mm"),
|
|
2421
|
+
od: length11.optional().default("1.6mm"),
|
|
2422
|
+
ceramic: z19.boolean().optional(),
|
|
2423
|
+
electrolytic: z19.boolean().optional(),
|
|
2424
|
+
polarized: z19.boolean().optional()
|
|
2425
|
+
});
|
|
2426
|
+
var radial = (raw_params) => {
|
|
2427
|
+
const parameters = radial_def.parse(raw_params);
|
|
2428
|
+
const { p, id, od } = parameters;
|
|
2429
|
+
if (id === 0.8 && od === 1.6) {
|
|
2430
|
+
parameters.id = p === 5 ? 0.8 : p * 0.25;
|
|
2431
|
+
parameters.od = p === 5 ? 1.6 : p * 0.5;
|
|
2432
|
+
}
|
|
2433
|
+
const plated_holes = [
|
|
2434
|
+
platedhole(1, -p / 2, 0, parameters.id, parameters.od),
|
|
2435
|
+
platedhole(2, p / 2, 0, parameters.id, parameters.od)
|
|
2436
|
+
];
|
|
2437
|
+
const bodyR = p + 0.1;
|
|
2438
|
+
const { topArc, bottomArc } = generateCircleArcs(
|
|
2439
|
+
0,
|
|
2440
|
+
0,
|
|
2441
|
+
bodyR,
|
|
2442
|
+
parameters.od / 2,
|
|
2443
|
+
parameters.od
|
|
2444
|
+
);
|
|
2445
|
+
const strokeWidth = 0.02 * p;
|
|
2446
|
+
const silkscreenBodyTop = {
|
|
2447
|
+
type: "pcb_silkscreen_path",
|
|
2448
|
+
layer: "top",
|
|
2449
|
+
pcb_component_id: "",
|
|
2450
|
+
route: topArc,
|
|
2451
|
+
stroke_width: strokeWidth,
|
|
2452
|
+
pcb_silkscreen_path_id: ""
|
|
2453
|
+
};
|
|
2454
|
+
const silkscreenBodyBottom = {
|
|
2455
|
+
type: "pcb_silkscreen_path",
|
|
2456
|
+
layer: "top",
|
|
2457
|
+
pcb_component_id: "",
|
|
2458
|
+
route: bottomArc,
|
|
2459
|
+
stroke_width: strokeWidth,
|
|
2460
|
+
pcb_silkscreen_path_id: ""
|
|
2461
|
+
};
|
|
2462
|
+
const silkscreenCenterLine = {
|
|
2463
|
+
type: "pcb_silkscreen_path",
|
|
2464
|
+
layer: "top",
|
|
2465
|
+
pcb_component_id: "",
|
|
2466
|
+
route: [
|
|
2467
|
+
{ x: 0, y: bodyR },
|
|
2468
|
+
{ x: 0, y: -bodyR }
|
|
2469
|
+
],
|
|
2470
|
+
stroke_width: strokeWidth,
|
|
2471
|
+
pcb_silkscreen_path_id: ""
|
|
2472
|
+
};
|
|
2473
|
+
const plusSize = 0.1 * p;
|
|
2474
|
+
const plusX = -(p + plusSize + 0.04 * p);
|
|
2475
|
+
const plusY = bodyR - plusSize - 0.08 * p;
|
|
2476
|
+
const plusHoriz = {
|
|
2477
|
+
type: "pcb_silkscreen_path",
|
|
2478
|
+
layer: "top",
|
|
2479
|
+
pcb_component_id: "",
|
|
2480
|
+
route: [
|
|
2481
|
+
{ x: plusX - plusSize, y: plusY },
|
|
2482
|
+
{ x: plusX + plusSize, y: plusY }
|
|
2483
|
+
],
|
|
2484
|
+
stroke_width: strokeWidth,
|
|
2485
|
+
pcb_silkscreen_path_id: ""
|
|
2486
|
+
};
|
|
2487
|
+
const plusVert = {
|
|
2488
|
+
type: "pcb_silkscreen_path",
|
|
2489
|
+
layer: "top",
|
|
2490
|
+
pcb_component_id: "",
|
|
2491
|
+
route: [
|
|
2492
|
+
{ x: plusX, y: plusY - plusSize },
|
|
2493
|
+
{ x: plusX, y: plusY + plusSize }
|
|
2494
|
+
],
|
|
2495
|
+
stroke_width: strokeWidth,
|
|
2496
|
+
pcb_silkscreen_path_id: ""
|
|
2497
|
+
};
|
|
2498
|
+
const silkscreenRefText = silkscreenRef(
|
|
2499
|
+
0,
|
|
2500
|
+
bodyR + 0.12 * p,
|
|
2501
|
+
0.1 * p
|
|
2502
|
+
);
|
|
2503
|
+
const circuitJson = [
|
|
2504
|
+
...plated_holes,
|
|
2505
|
+
silkscreenBodyTop,
|
|
2506
|
+
silkscreenBodyBottom,
|
|
2507
|
+
silkscreenCenterLine,
|
|
2508
|
+
silkscreenRefText
|
|
2509
|
+
];
|
|
2510
|
+
const hasPolarity = parameters.electrolytic === true || parameters.polarized === true;
|
|
2511
|
+
if (hasPolarity) {
|
|
2512
|
+
circuitJson.push(plusHoriz, plusVert);
|
|
2513
|
+
}
|
|
2514
|
+
return {
|
|
2515
|
+
circuitJson,
|
|
2516
|
+
parameters
|
|
2517
|
+
};
|
|
2518
|
+
};
|
|
2519
|
+
|
|
2520
|
+
// src/fn/pushbutton.ts
|
|
2521
|
+
import { length as length12 } from "circuit-json";
|
|
2522
|
+
import { z as z20 } from "zod";
|
|
2523
|
+
|
|
2386
2524
|
// src/helpers/silkscreenpath.ts
|
|
2387
2525
|
var silkscreenpath = (route, options = {}) => {
|
|
2388
2526
|
return {
|
|
@@ -2397,11 +2535,11 @@ var silkscreenpath = (route, options = {}) => {
|
|
|
2397
2535
|
|
|
2398
2536
|
// src/fn/pushbutton.ts
|
|
2399
2537
|
var pushbutton_def = base_def.extend({
|
|
2400
|
-
fn:
|
|
2401
|
-
w:
|
|
2402
|
-
h:
|
|
2403
|
-
id:
|
|
2404
|
-
od:
|
|
2538
|
+
fn: z20.literal("pushbutton"),
|
|
2539
|
+
w: length12.default(4.5),
|
|
2540
|
+
h: length12.default(6.5),
|
|
2541
|
+
id: length12.default(1),
|
|
2542
|
+
od: length12.default(1.2)
|
|
2405
2543
|
});
|
|
2406
2544
|
var pushbutton = (raw_params) => {
|
|
2407
2545
|
const parameters = pushbutton_def.parse(raw_params);
|
|
@@ -2448,24 +2586,24 @@ var pushbutton = (raw_params) => {
|
|
|
2448
2586
|
|
|
2449
2587
|
// src/fn/stampboard.ts
|
|
2450
2588
|
import {
|
|
2451
|
-
length as
|
|
2589
|
+
length as length13
|
|
2452
2590
|
} from "circuit-json";
|
|
2453
|
-
import { z as
|
|
2591
|
+
import { z as z21 } from "zod";
|
|
2454
2592
|
var stampboard_def = base_def.extend({
|
|
2455
|
-
fn:
|
|
2456
|
-
w:
|
|
2457
|
-
h:
|
|
2458
|
-
left:
|
|
2459
|
-
right:
|
|
2460
|
-
top:
|
|
2461
|
-
bottom:
|
|
2462
|
-
p:
|
|
2463
|
-
pw:
|
|
2464
|
-
pl:
|
|
2465
|
-
innerhole:
|
|
2466
|
-
innerholeedgedistance:
|
|
2467
|
-
silkscreenlabels:
|
|
2468
|
-
silkscreenlabelmargin:
|
|
2593
|
+
fn: z21.string(),
|
|
2594
|
+
w: length13.default("22.58mm"),
|
|
2595
|
+
h: length13.optional(),
|
|
2596
|
+
left: length13.optional().default(20),
|
|
2597
|
+
right: length13.optional().default(20),
|
|
2598
|
+
top: length13.optional().default(2),
|
|
2599
|
+
bottom: length13.optional().default(2),
|
|
2600
|
+
p: length13.default(length13.parse("2.54mm")),
|
|
2601
|
+
pw: length13.default(length13.parse("1.6mm")),
|
|
2602
|
+
pl: length13.default(length13.parse("2.4mm")),
|
|
2603
|
+
innerhole: z21.boolean().default(false),
|
|
2604
|
+
innerholeedgedistance: length13.default(length13.parse("1.61mm")),
|
|
2605
|
+
silkscreenlabels: z21.boolean().default(false),
|
|
2606
|
+
silkscreenlabelmargin: length13.default(length13.parse("0.1mm"))
|
|
2469
2607
|
});
|
|
2470
2608
|
var getHeight = (parameters) => {
|
|
2471
2609
|
const params = stampboard_def.parse(parameters);
|
|
@@ -2874,22 +3012,22 @@ var stampboard = (raw_params) => {
|
|
|
2874
3012
|
|
|
2875
3013
|
// src/fn/stampreceiver.ts
|
|
2876
3014
|
import {
|
|
2877
|
-
length as
|
|
3015
|
+
length as length14
|
|
2878
3016
|
} from "circuit-json";
|
|
2879
|
-
import { z as
|
|
3017
|
+
import { z as z22 } from "zod";
|
|
2880
3018
|
var stampreceiver_def = base_def.extend({
|
|
2881
|
-
fn:
|
|
2882
|
-
w:
|
|
2883
|
-
h:
|
|
2884
|
-
left:
|
|
2885
|
-
right:
|
|
2886
|
-
top:
|
|
2887
|
-
bottom:
|
|
2888
|
-
p:
|
|
2889
|
-
pw:
|
|
2890
|
-
pl:
|
|
2891
|
-
innerhole:
|
|
2892
|
-
innerholeedgedistance:
|
|
3019
|
+
fn: z22.string(),
|
|
3020
|
+
w: length14.default("22.58mm"),
|
|
3021
|
+
h: length14.optional(),
|
|
3022
|
+
left: length14.optional().default(20),
|
|
3023
|
+
right: length14.optional().default(20),
|
|
3024
|
+
top: length14.optional().default(2),
|
|
3025
|
+
bottom: length14.optional().default(2),
|
|
3026
|
+
p: length14.default(length14.parse("2.54mm")),
|
|
3027
|
+
pw: length14.default(length14.parse("1.6mm")),
|
|
3028
|
+
pl: length14.default(length14.parse("3.2mm")),
|
|
3029
|
+
innerhole: z22.boolean().default(false),
|
|
3030
|
+
innerholeedgedistance: length14.default(length14.parse("1.61mm"))
|
|
2893
3031
|
});
|
|
2894
3032
|
var getHeight2 = (parameters) => {
|
|
2895
3033
|
const params = stampreceiver_def.parse(parameters);
|
|
@@ -3190,20 +3328,20 @@ var lqfp = (parameters) => {
|
|
|
3190
3328
|
|
|
3191
3329
|
// src/fn/breakoutheaders.ts
|
|
3192
3330
|
import {
|
|
3193
|
-
length as
|
|
3331
|
+
length as length15
|
|
3194
3332
|
} from "circuit-json";
|
|
3195
|
-
import { z as
|
|
3333
|
+
import { z as z23 } from "zod";
|
|
3196
3334
|
var breakoutheaders_def = base_def.extend({
|
|
3197
|
-
fn:
|
|
3198
|
-
w:
|
|
3199
|
-
h:
|
|
3200
|
-
left:
|
|
3201
|
-
right:
|
|
3202
|
-
top:
|
|
3203
|
-
bottom:
|
|
3204
|
-
p:
|
|
3205
|
-
id:
|
|
3206
|
-
od:
|
|
3335
|
+
fn: z23.string(),
|
|
3336
|
+
w: length15.default("10mm"),
|
|
3337
|
+
h: length15.optional(),
|
|
3338
|
+
left: length15.optional().default(20),
|
|
3339
|
+
right: length15.optional().default(20),
|
|
3340
|
+
top: length15.optional().default(0),
|
|
3341
|
+
bottom: length15.optional().default(0),
|
|
3342
|
+
p: length15.default(length15.parse("2.54mm")),
|
|
3343
|
+
id: length15.optional().default(length15.parse("1mm")),
|
|
3344
|
+
od: length15.optional().default(length15.parse("1.5mm"))
|
|
3207
3345
|
});
|
|
3208
3346
|
var getHeight3 = (parameters) => {
|
|
3209
3347
|
const params = breakoutheaders_def.parse(parameters);
|
|
@@ -3395,9 +3533,9 @@ var breakoutheaders = (raw_params) => {
|
|
|
3395
3533
|
|
|
3396
3534
|
// src/fn/hc49.ts
|
|
3397
3535
|
import {
|
|
3398
|
-
length as
|
|
3536
|
+
length as length16
|
|
3399
3537
|
} from "circuit-json";
|
|
3400
|
-
import { z as
|
|
3538
|
+
import { z as z24 } from "zod";
|
|
3401
3539
|
var generate_u_curve = (centerX, centerY, radius, direction) => {
|
|
3402
3540
|
return Array.from({ length: 25 }, (_, i) => {
|
|
3403
3541
|
const theta = i / 24 * Math.PI - Math.PI / 2;
|
|
@@ -3408,12 +3546,12 @@ var generate_u_curve = (centerX, centerY, radius, direction) => {
|
|
|
3408
3546
|
});
|
|
3409
3547
|
};
|
|
3410
3548
|
var hc49_def = base_def.extend({
|
|
3411
|
-
fn:
|
|
3412
|
-
p:
|
|
3413
|
-
id:
|
|
3414
|
-
od:
|
|
3415
|
-
w:
|
|
3416
|
-
h:
|
|
3549
|
+
fn: z24.string(),
|
|
3550
|
+
p: length16.optional().default("4.88mm"),
|
|
3551
|
+
id: length16.optional().default("0.8mm"),
|
|
3552
|
+
od: length16.optional().default("1.5mm"),
|
|
3553
|
+
w: length16.optional().default("5.6mm"),
|
|
3554
|
+
h: length16.optional().default("3.5mm")
|
|
3417
3555
|
});
|
|
3418
3556
|
var hc49 = (raw_params) => {
|
|
3419
3557
|
const parameters = hc49_def.parse(raw_params);
|
|
@@ -3454,11 +3592,11 @@ var hc49 = (raw_params) => {
|
|
|
3454
3592
|
|
|
3455
3593
|
// src/fn/pad.ts
|
|
3456
3594
|
import "zod";
|
|
3457
|
-
import { length as
|
|
3595
|
+
import { length as length17 } from "circuit-json";
|
|
3458
3596
|
import { mm as mm5 } from "@tscircuit/mm";
|
|
3459
3597
|
var pad_def = base_def.extend({
|
|
3460
|
-
w:
|
|
3461
|
-
h:
|
|
3598
|
+
w: length17,
|
|
3599
|
+
h: length17
|
|
3462
3600
|
});
|
|
3463
3601
|
var pad = (params) => {
|
|
3464
3602
|
const { w, h } = params;
|
|
@@ -3474,7 +3612,7 @@ var pad = (params) => {
|
|
|
3474
3612
|
};
|
|
3475
3613
|
|
|
3476
3614
|
// src/fn/to92.ts
|
|
3477
|
-
import { z as
|
|
3615
|
+
import { z as z26 } from "zod";
|
|
3478
3616
|
import "@tscircuit/mm";
|
|
3479
3617
|
|
|
3480
3618
|
// src/helpers/platedHolePill.ts
|
|
@@ -3499,15 +3637,15 @@ var platedHolePill = (pn, x, y, holeDiameter, outerWidth, outerHeight) => {
|
|
|
3499
3637
|
|
|
3500
3638
|
// src/fn/to92.ts
|
|
3501
3639
|
var to92_def = base_def.extend({
|
|
3502
|
-
fn:
|
|
3503
|
-
num_pins:
|
|
3504
|
-
p:
|
|
3505
|
-
id:
|
|
3506
|
-
od:
|
|
3507
|
-
w:
|
|
3508
|
-
h:
|
|
3509
|
-
inline:
|
|
3510
|
-
string:
|
|
3640
|
+
fn: z26.string(),
|
|
3641
|
+
num_pins: z26.union([z26.literal(3), z26.literal(2)]).default(3),
|
|
3642
|
+
p: z26.string().default("1.27mm"),
|
|
3643
|
+
id: z26.string().default("0.72mm"),
|
|
3644
|
+
od: z26.string().default("0.95mm"),
|
|
3645
|
+
w: z26.string().default("4.5mm"),
|
|
3646
|
+
h: z26.string().default("4.5mm"),
|
|
3647
|
+
inline: z26.boolean().default(false),
|
|
3648
|
+
string: z26.string().optional()
|
|
3511
3649
|
});
|
|
3512
3650
|
var generateSemicircle = (centerX, centerY, radius) => {
|
|
3513
3651
|
return Array.from({ length: 25 }, (_, i) => {
|
|
@@ -3623,22 +3761,22 @@ var to92 = (raw_params) => {
|
|
|
3623
3761
|
};
|
|
3624
3762
|
|
|
3625
3763
|
// src/fn/sod523.ts
|
|
3626
|
-
import { z as
|
|
3627
|
-
import { length as
|
|
3764
|
+
import { z as z27 } from "zod";
|
|
3765
|
+
import { length as length18 } from "circuit-json";
|
|
3628
3766
|
var sod_def2 = base_def.extend({
|
|
3629
|
-
fn:
|
|
3630
|
-
num_pins:
|
|
3631
|
-
w:
|
|
3632
|
-
h:
|
|
3633
|
-
pl:
|
|
3634
|
-
pw:
|
|
3635
|
-
p:
|
|
3767
|
+
fn: z27.string(),
|
|
3768
|
+
num_pins: z27.literal(2).default(2),
|
|
3769
|
+
w: z27.string().default("2.15mm"),
|
|
3770
|
+
h: z27.string().default("1.20mm"),
|
|
3771
|
+
pl: z27.string().default("0.5mm"),
|
|
3772
|
+
pw: z27.string().default("0.6mm"),
|
|
3773
|
+
p: z27.string().default("1.4mm")
|
|
3636
3774
|
});
|
|
3637
3775
|
var sod523 = (raw_params) => {
|
|
3638
3776
|
const parameters = sod_def2.parse(raw_params);
|
|
3639
3777
|
const silkscreenRefText = silkscreenRef(
|
|
3640
3778
|
0,
|
|
3641
|
-
|
|
3779
|
+
length18.parse(parameters.h),
|
|
3642
3780
|
0.3
|
|
3643
3781
|
);
|
|
3644
3782
|
const silkscreenLine = {
|
|
@@ -3647,20 +3785,20 @@ var sod523 = (raw_params) => {
|
|
|
3647
3785
|
pcb_component_id: "",
|
|
3648
3786
|
route: [
|
|
3649
3787
|
{
|
|
3650
|
-
x:
|
|
3651
|
-
y:
|
|
3788
|
+
x: length18.parse(parameters.p) / 2,
|
|
3789
|
+
y: length18.parse(parameters.h) / 2
|
|
3652
3790
|
},
|
|
3653
3791
|
{
|
|
3654
|
-
x: -
|
|
3655
|
-
y:
|
|
3792
|
+
x: -length18.parse(parameters.w) / 2 - 0.2,
|
|
3793
|
+
y: length18.parse(parameters.h) / 2
|
|
3656
3794
|
},
|
|
3657
3795
|
{
|
|
3658
|
-
x: -
|
|
3659
|
-
y: -
|
|
3796
|
+
x: -length18.parse(parameters.w) / 2 - 0.2,
|
|
3797
|
+
y: -length18.parse(parameters.h) / 2
|
|
3660
3798
|
},
|
|
3661
3799
|
{
|
|
3662
|
-
x:
|
|
3663
|
-
y: -
|
|
3800
|
+
x: length18.parse(parameters.p) / 2,
|
|
3801
|
+
y: -length18.parse(parameters.h) / 2
|
|
3664
3802
|
}
|
|
3665
3803
|
],
|
|
3666
3804
|
stroke_width: 0.1,
|
|
@@ -3748,22 +3886,22 @@ var sop8 = (raw_params) => {
|
|
|
3748
3886
|
};
|
|
3749
3887
|
|
|
3750
3888
|
// src/fn/sod80.ts
|
|
3751
|
-
import { z as
|
|
3752
|
-
import { length as
|
|
3889
|
+
import { z as z28 } from "zod";
|
|
3890
|
+
import { length as length19 } from "circuit-json";
|
|
3753
3891
|
var sod80_def = base_def.extend({
|
|
3754
|
-
fn:
|
|
3755
|
-
num_pins:
|
|
3756
|
-
w:
|
|
3757
|
-
h:
|
|
3758
|
-
pl:
|
|
3759
|
-
pw:
|
|
3760
|
-
p:
|
|
3892
|
+
fn: z28.string(),
|
|
3893
|
+
num_pins: z28.literal(2).default(2),
|
|
3894
|
+
w: z28.string().default("5.0mm"),
|
|
3895
|
+
h: z28.string().default("2.30mm"),
|
|
3896
|
+
pl: z28.string().default("1.25mm"),
|
|
3897
|
+
pw: z28.string().default("2mm"),
|
|
3898
|
+
p: z28.string().default("3.75mm")
|
|
3761
3899
|
});
|
|
3762
3900
|
var sod80 = (raw_params) => {
|
|
3763
3901
|
const parameters = sod80_def.parse(raw_params);
|
|
3764
3902
|
const silkscreenRefText = silkscreenRef(
|
|
3765
3903
|
0,
|
|
3766
|
-
|
|
3904
|
+
length19.parse(parameters.h) / 2 + 1,
|
|
3767
3905
|
0.3
|
|
3768
3906
|
);
|
|
3769
3907
|
const silkscreenLine = {
|
|
@@ -3772,20 +3910,20 @@ var sod80 = (raw_params) => {
|
|
|
3772
3910
|
pcb_component_id: "",
|
|
3773
3911
|
route: [
|
|
3774
3912
|
{
|
|
3775
|
-
x:
|
|
3776
|
-
y:
|
|
3913
|
+
x: length19.parse(parameters.p) / 2 + 0.5,
|
|
3914
|
+
y: length19.parse(parameters.h) / 2 + 0.5
|
|
3777
3915
|
},
|
|
3778
3916
|
{
|
|
3779
|
-
x: -
|
|
3780
|
-
y:
|
|
3917
|
+
x: -length19.parse(parameters.w) / 2 - 0.5,
|
|
3918
|
+
y: length19.parse(parameters.h) / 2 + 0.5
|
|
3781
3919
|
},
|
|
3782
3920
|
{
|
|
3783
|
-
x: -
|
|
3784
|
-
y: -
|
|
3921
|
+
x: -length19.parse(parameters.w) / 2 - 0.5,
|
|
3922
|
+
y: -length19.parse(parameters.h) / 2 - 0.5
|
|
3785
3923
|
},
|
|
3786
3924
|
{
|
|
3787
|
-
x:
|
|
3788
|
-
y: -
|
|
3925
|
+
x: length19.parse(parameters.p) / 2 + 0.5,
|
|
3926
|
+
y: -length19.parse(parameters.h) / 2 - 0.5
|
|
3789
3927
|
}
|
|
3790
3928
|
],
|
|
3791
3929
|
stroke_width: 0.1,
|
|
@@ -3824,22 +3962,22 @@ var sod80WithoutParsing = (parameters) => {
|
|
|
3824
3962
|
};
|
|
3825
3963
|
|
|
3826
3964
|
// src/fn/sod123w.ts
|
|
3827
|
-
import { z as
|
|
3828
|
-
import { length as
|
|
3965
|
+
import { z as z29 } from "zod";
|
|
3966
|
+
import { length as length20 } from "circuit-json";
|
|
3829
3967
|
var sod_def3 = base_def.extend({
|
|
3830
|
-
fn:
|
|
3831
|
-
num_pins:
|
|
3832
|
-
w:
|
|
3833
|
-
h:
|
|
3834
|
-
pl:
|
|
3835
|
-
pw:
|
|
3836
|
-
p:
|
|
3968
|
+
fn: z29.string(),
|
|
3969
|
+
num_pins: z29.literal(2).default(2),
|
|
3970
|
+
w: z29.string().default("4.4mm"),
|
|
3971
|
+
h: z29.string().default("2.1mm"),
|
|
3972
|
+
pl: z29.string().default("1.2mm"),
|
|
3973
|
+
pw: z29.string().default("1.2mm"),
|
|
3974
|
+
p: z29.string().default("2.9mm")
|
|
3837
3975
|
});
|
|
3838
3976
|
var sod123w = (raw_params) => {
|
|
3839
3977
|
const parameters = sod_def3.parse(raw_params);
|
|
3840
3978
|
const silkscreenRefText = silkscreenRef(
|
|
3841
3979
|
0,
|
|
3842
|
-
|
|
3980
|
+
length20.parse(parameters.h) - 0.5,
|
|
3843
3981
|
0.3
|
|
3844
3982
|
);
|
|
3845
3983
|
const silkscreenLine = {
|
|
@@ -3848,20 +3986,20 @@ var sod123w = (raw_params) => {
|
|
|
3848
3986
|
pcb_component_id: "",
|
|
3849
3987
|
route: [
|
|
3850
3988
|
{
|
|
3851
|
-
x:
|
|
3852
|
-
y:
|
|
3989
|
+
x: length20.parse(parameters.p) / 2,
|
|
3990
|
+
y: length20.parse(parameters.h) / 2
|
|
3853
3991
|
},
|
|
3854
3992
|
{
|
|
3855
|
-
x: -
|
|
3856
|
-
y:
|
|
3993
|
+
x: -length20.parse(parameters.w) / 2 - 0.2,
|
|
3994
|
+
y: length20.parse(parameters.h) / 2
|
|
3857
3995
|
},
|
|
3858
3996
|
{
|
|
3859
|
-
x: -
|
|
3860
|
-
y: -
|
|
3997
|
+
x: -length20.parse(parameters.w) / 2 - 0.2,
|
|
3998
|
+
y: -length20.parse(parameters.h) / 2
|
|
3861
3999
|
},
|
|
3862
4000
|
{
|
|
3863
|
-
x:
|
|
3864
|
-
y: -
|
|
4001
|
+
x: length20.parse(parameters.p) / 2,
|
|
4002
|
+
y: -length20.parse(parameters.h) / 2
|
|
3865
4003
|
}
|
|
3866
4004
|
],
|
|
3867
4005
|
stroke_width: 0.1,
|
|
@@ -3903,22 +4041,22 @@ var sodWithoutParsing3 = (parameters) => {
|
|
|
3903
4041
|
};
|
|
3904
4042
|
|
|
3905
4043
|
// src/fn/sod323.ts
|
|
3906
|
-
import { z as
|
|
3907
|
-
import { length as
|
|
4044
|
+
import { z as z30 } from "zod";
|
|
4045
|
+
import { length as length21 } from "circuit-json";
|
|
3908
4046
|
var sod_def4 = base_def.extend({
|
|
3909
|
-
fn:
|
|
3910
|
-
num_pins:
|
|
3911
|
-
w:
|
|
3912
|
-
h:
|
|
3913
|
-
pl:
|
|
3914
|
-
pw:
|
|
3915
|
-
p:
|
|
4047
|
+
fn: z30.string(),
|
|
4048
|
+
num_pins: z30.literal(2).default(2),
|
|
4049
|
+
w: z30.string().default("3.30mm"),
|
|
4050
|
+
h: z30.string().default("1.80mm"),
|
|
4051
|
+
pl: z30.string().default("0.60mm"),
|
|
4052
|
+
pw: z30.string().default("0.45mm"),
|
|
4053
|
+
p: z30.string().default("2.1mm")
|
|
3916
4054
|
});
|
|
3917
4055
|
var sod323 = (raw_params) => {
|
|
3918
4056
|
const parameters = sod_def4.parse(raw_params);
|
|
3919
4057
|
const silkscreenRefText = silkscreenRef(
|
|
3920
4058
|
0,
|
|
3921
|
-
|
|
4059
|
+
length21.parse(parameters.h) - 0.5,
|
|
3922
4060
|
0.3
|
|
3923
4061
|
);
|
|
3924
4062
|
const silkscreenLine = {
|
|
@@ -3927,20 +4065,20 @@ var sod323 = (raw_params) => {
|
|
|
3927
4065
|
pcb_component_id: "",
|
|
3928
4066
|
route: [
|
|
3929
4067
|
{
|
|
3930
|
-
x:
|
|
3931
|
-
y:
|
|
4068
|
+
x: length21.parse(parameters.p) / 2,
|
|
4069
|
+
y: length21.parse(parameters.h) / 2
|
|
3932
4070
|
},
|
|
3933
4071
|
{
|
|
3934
|
-
x: -
|
|
3935
|
-
y:
|
|
4072
|
+
x: -length21.parse(parameters.w) / 2,
|
|
4073
|
+
y: length21.parse(parameters.h) / 2
|
|
3936
4074
|
},
|
|
3937
4075
|
{
|
|
3938
|
-
x: -
|
|
3939
|
-
y: -
|
|
4076
|
+
x: -length21.parse(parameters.w) / 2,
|
|
4077
|
+
y: -length21.parse(parameters.h) / 2
|
|
3940
4078
|
},
|
|
3941
4079
|
{
|
|
3942
|
-
x:
|
|
3943
|
-
y: -
|
|
4080
|
+
x: length21.parse(parameters.p) / 2,
|
|
4081
|
+
y: -length21.parse(parameters.h) / 2
|
|
3944
4082
|
}
|
|
3945
4083
|
],
|
|
3946
4084
|
stroke_width: 0.1,
|
|
@@ -3982,22 +4120,22 @@ var sodWithoutParsing4 = (parameters) => {
|
|
|
3982
4120
|
};
|
|
3983
4121
|
|
|
3984
4122
|
// src/fn/sod923.ts
|
|
3985
|
-
import { z as
|
|
3986
|
-
import { length as
|
|
4123
|
+
import { z as z31 } from "zod";
|
|
4124
|
+
import { length as length22 } from "circuit-json";
|
|
3987
4125
|
var sod_def5 = base_def.extend({
|
|
3988
|
-
fn:
|
|
3989
|
-
num_pins:
|
|
3990
|
-
w:
|
|
3991
|
-
h:
|
|
3992
|
-
pl:
|
|
3993
|
-
pw:
|
|
3994
|
-
p:
|
|
4126
|
+
fn: z31.string(),
|
|
4127
|
+
num_pins: z31.literal(2).default(2),
|
|
4128
|
+
w: z31.string().default("1.4mm"),
|
|
4129
|
+
h: z31.string().default("0.9mm"),
|
|
4130
|
+
pl: z31.string().default("0.36mm"),
|
|
4131
|
+
pw: z31.string().default("0.25mm"),
|
|
4132
|
+
p: z31.string().default("0.85mm")
|
|
3995
4133
|
});
|
|
3996
4134
|
var sod923 = (raw_params) => {
|
|
3997
4135
|
const parameters = sod_def5.parse(raw_params);
|
|
3998
4136
|
const silkscreenRefText = silkscreenRef(
|
|
3999
4137
|
0,
|
|
4000
|
-
|
|
4138
|
+
length22.parse(parameters.h),
|
|
4001
4139
|
0.3
|
|
4002
4140
|
);
|
|
4003
4141
|
const silkscreenLine = {
|
|
@@ -4006,20 +4144,20 @@ var sod923 = (raw_params) => {
|
|
|
4006
4144
|
pcb_component_id: "",
|
|
4007
4145
|
route: [
|
|
4008
4146
|
{
|
|
4009
|
-
x:
|
|
4010
|
-
y:
|
|
4147
|
+
x: length22.parse(parameters.p) / 2 + 0.15,
|
|
4148
|
+
y: length22.parse(parameters.h) / 2
|
|
4011
4149
|
},
|
|
4012
4150
|
{
|
|
4013
|
-
x: -
|
|
4014
|
-
y:
|
|
4151
|
+
x: -length22.parse(parameters.w) / 2 - 0.15,
|
|
4152
|
+
y: length22.parse(parameters.h) / 2
|
|
4015
4153
|
},
|
|
4016
4154
|
{
|
|
4017
|
-
x: -
|
|
4018
|
-
y: -
|
|
4155
|
+
x: -length22.parse(parameters.w) / 2 - 0.15,
|
|
4156
|
+
y: -length22.parse(parameters.h) / 2
|
|
4019
4157
|
},
|
|
4020
4158
|
{
|
|
4021
|
-
x:
|
|
4022
|
-
y: -
|
|
4159
|
+
x: length22.parse(parameters.p) / 2 + 0.15,
|
|
4160
|
+
y: -length22.parse(parameters.h) / 2
|
|
4023
4161
|
}
|
|
4024
4162
|
],
|
|
4025
4163
|
stroke_width: 0.1,
|
|
@@ -4062,22 +4200,22 @@ var sodWithoutParsing5 = (parameters) => {
|
|
|
4062
4200
|
};
|
|
4063
4201
|
|
|
4064
4202
|
// src/fn/sod882.ts
|
|
4065
|
-
import { z as
|
|
4066
|
-
import { length as
|
|
4203
|
+
import { z as z32 } from "zod";
|
|
4204
|
+
import { length as length23 } from "circuit-json";
|
|
4067
4205
|
var sod_def6 = base_def.extend({
|
|
4068
|
-
fn:
|
|
4069
|
-
num_pins:
|
|
4070
|
-
w:
|
|
4071
|
-
h:
|
|
4072
|
-
pl:
|
|
4073
|
-
pw:
|
|
4074
|
-
p:
|
|
4206
|
+
fn: z32.string(),
|
|
4207
|
+
num_pins: z32.literal(2).default(2),
|
|
4208
|
+
w: z32.string().default("1.3mm"),
|
|
4209
|
+
h: z32.string().default("0.9mm"),
|
|
4210
|
+
pl: z32.string().default("0.4mm"),
|
|
4211
|
+
pw: z32.string().default("0.7mm"),
|
|
4212
|
+
p: z32.string().default("0.7mm")
|
|
4075
4213
|
});
|
|
4076
4214
|
var sod882 = (raw_params) => {
|
|
4077
4215
|
const parameters = sod_def6.parse(raw_params);
|
|
4078
4216
|
const silkscreenRefText = silkscreenRef(
|
|
4079
4217
|
0,
|
|
4080
|
-
|
|
4218
|
+
length23.parse(parameters.h) + 0.1,
|
|
4081
4219
|
0.3
|
|
4082
4220
|
);
|
|
4083
4221
|
const silkscreenLine = {
|
|
@@ -4086,20 +4224,20 @@ var sod882 = (raw_params) => {
|
|
|
4086
4224
|
pcb_component_id: "",
|
|
4087
4225
|
route: [
|
|
4088
4226
|
{
|
|
4089
|
-
x:
|
|
4090
|
-
y:
|
|
4227
|
+
x: length23.parse(parameters.p) / 2 + 0.2,
|
|
4228
|
+
y: length23.parse(parameters.h) / 2 + 0.2
|
|
4091
4229
|
},
|
|
4092
4230
|
{
|
|
4093
|
-
x: -
|
|
4094
|
-
y:
|
|
4231
|
+
x: -length23.parse(parameters.w) / 2 - 0.2,
|
|
4232
|
+
y: length23.parse(parameters.h) / 2 + 0.2
|
|
4095
4233
|
},
|
|
4096
4234
|
{
|
|
4097
|
-
x: -
|
|
4098
|
-
y: -
|
|
4235
|
+
x: -length23.parse(parameters.w) / 2 - 0.2,
|
|
4236
|
+
y: -length23.parse(parameters.h) / 2 - 0.2
|
|
4099
4237
|
},
|
|
4100
4238
|
{
|
|
4101
|
-
x:
|
|
4102
|
-
y: -
|
|
4239
|
+
x: length23.parse(parameters.p) / 2 + 0.2,
|
|
4240
|
+
y: -length23.parse(parameters.h) / 2 - 0.2
|
|
4103
4241
|
}
|
|
4104
4242
|
],
|
|
4105
4243
|
stroke_width: 0.1,
|
|
@@ -4142,22 +4280,22 @@ var sodWithoutParsing6 = (parameters) => {
|
|
|
4142
4280
|
};
|
|
4143
4281
|
|
|
4144
4282
|
// src/fn/sod323f.ts
|
|
4145
|
-
import { z as
|
|
4146
|
-
import { length as
|
|
4283
|
+
import { z as z33 } from "zod";
|
|
4284
|
+
import { length as length24 } from "circuit-json";
|
|
4147
4285
|
var sod_def7 = base_def.extend({
|
|
4148
|
-
fn:
|
|
4149
|
-
num_pins:
|
|
4150
|
-
w:
|
|
4151
|
-
h:
|
|
4152
|
-
pl:
|
|
4153
|
-
pw:
|
|
4154
|
-
pad_spacing:
|
|
4286
|
+
fn: z33.string(),
|
|
4287
|
+
num_pins: z33.literal(2).default(2),
|
|
4288
|
+
w: z33.string().default("3,05mm"),
|
|
4289
|
+
h: z33.string().default("1.65mm"),
|
|
4290
|
+
pl: z33.string().default("0.6mm"),
|
|
4291
|
+
pw: z33.string().default("0.6mm"),
|
|
4292
|
+
pad_spacing: z33.string().default("2.2mm")
|
|
4155
4293
|
});
|
|
4156
4294
|
var sod323f = (raw_params) => {
|
|
4157
4295
|
const parameters = sod_def7.parse(raw_params);
|
|
4158
4296
|
const silkscreenRefText = silkscreenRef(
|
|
4159
4297
|
0,
|
|
4160
|
-
|
|
4298
|
+
length24.parse(parameters.h),
|
|
4161
4299
|
0.3
|
|
4162
4300
|
);
|
|
4163
4301
|
const silkscreenLine = {
|
|
@@ -4166,20 +4304,20 @@ var sod323f = (raw_params) => {
|
|
|
4166
4304
|
pcb_component_id: "",
|
|
4167
4305
|
route: [
|
|
4168
4306
|
{
|
|
4169
|
-
x:
|
|
4170
|
-
y:
|
|
4307
|
+
x: length24.parse(parameters.pad_spacing) / 2,
|
|
4308
|
+
y: length24.parse(parameters.h) / 2
|
|
4171
4309
|
},
|
|
4172
4310
|
{
|
|
4173
|
-
x: -
|
|
4174
|
-
y:
|
|
4311
|
+
x: -length24.parse(parameters.w) / 2 - 0.2,
|
|
4312
|
+
y: length24.parse(parameters.h) / 2
|
|
4175
4313
|
},
|
|
4176
4314
|
{
|
|
4177
|
-
x: -
|
|
4178
|
-
y: -
|
|
4315
|
+
x: -length24.parse(parameters.w) / 2 - 0.2,
|
|
4316
|
+
y: -length24.parse(parameters.h) / 2
|
|
4179
4317
|
},
|
|
4180
4318
|
{
|
|
4181
|
-
x:
|
|
4182
|
-
y: -
|
|
4319
|
+
x: length24.parse(parameters.pad_spacing) / 2,
|
|
4320
|
+
y: -length24.parse(parameters.h) / 2
|
|
4183
4321
|
}
|
|
4184
4322
|
],
|
|
4185
4323
|
stroke_width: 0.1,
|
|
@@ -4222,22 +4360,22 @@ var sodWithoutParsing7 = (parameters) => {
|
|
|
4222
4360
|
};
|
|
4223
4361
|
|
|
4224
4362
|
// src/fn/sod123f.ts
|
|
4225
|
-
import { z as
|
|
4226
|
-
import { length as
|
|
4363
|
+
import { z as z34 } from "zod";
|
|
4364
|
+
import { length as length25 } from "circuit-json";
|
|
4227
4365
|
var sod_def8 = base_def.extend({
|
|
4228
|
-
fn:
|
|
4229
|
-
num_pins:
|
|
4230
|
-
w:
|
|
4231
|
-
h:
|
|
4232
|
-
pl:
|
|
4233
|
-
pw:
|
|
4234
|
-
p:
|
|
4366
|
+
fn: z34.string(),
|
|
4367
|
+
num_pins: z34.literal(2).default(2),
|
|
4368
|
+
w: z34.string().default("4.4mm"),
|
|
4369
|
+
h: z34.string().default("2.1mm"),
|
|
4370
|
+
pl: z34.string().default("1.2mm"),
|
|
4371
|
+
pw: z34.string().default("1.2mm"),
|
|
4372
|
+
p: z34.string().default("2.9mm")
|
|
4235
4373
|
});
|
|
4236
4374
|
var sod123f = (raw_params) => {
|
|
4237
4375
|
const parameters = sod_def8.parse(raw_params);
|
|
4238
4376
|
const silkscreenRefText = silkscreenRef(
|
|
4239
4377
|
0,
|
|
4240
|
-
|
|
4378
|
+
length25.parse(parameters.h),
|
|
4241
4379
|
0.3
|
|
4242
4380
|
);
|
|
4243
4381
|
const silkscreenLine = {
|
|
@@ -4246,20 +4384,20 @@ var sod123f = (raw_params) => {
|
|
|
4246
4384
|
pcb_component_id: "",
|
|
4247
4385
|
route: [
|
|
4248
4386
|
{
|
|
4249
|
-
x:
|
|
4250
|
-
y:
|
|
4387
|
+
x: length25.parse(parameters.p) / 2,
|
|
4388
|
+
y: length25.parse(parameters.h) / 2
|
|
4251
4389
|
},
|
|
4252
4390
|
{
|
|
4253
|
-
x: -
|
|
4254
|
-
y:
|
|
4391
|
+
x: -length25.parse(parameters.w) / 2 - 0.2,
|
|
4392
|
+
y: length25.parse(parameters.h) / 2
|
|
4255
4393
|
},
|
|
4256
4394
|
{
|
|
4257
|
-
x: -
|
|
4258
|
-
y: -
|
|
4395
|
+
x: -length25.parse(parameters.w) / 2 - 0.2,
|
|
4396
|
+
y: -length25.parse(parameters.h) / 2
|
|
4259
4397
|
},
|
|
4260
4398
|
{
|
|
4261
|
-
x:
|
|
4262
|
-
y: -
|
|
4399
|
+
x: length25.parse(parameters.p) / 2,
|
|
4400
|
+
y: -length25.parse(parameters.h) / 2
|
|
4263
4401
|
}
|
|
4264
4402
|
],
|
|
4265
4403
|
stroke_width: 0.1,
|
|
@@ -4302,22 +4440,22 @@ var sodWithoutParsing8 = (parameters) => {
|
|
|
4302
4440
|
};
|
|
4303
4441
|
|
|
4304
4442
|
// src/fn/sod123fl.ts
|
|
4305
|
-
import { z as
|
|
4306
|
-
import { length as
|
|
4443
|
+
import { z as z35 } from "zod";
|
|
4444
|
+
import { length as length26 } from "circuit-json";
|
|
4307
4445
|
var sod123FL_def = base_def.extend({
|
|
4308
|
-
fn:
|
|
4309
|
-
num_pins:
|
|
4310
|
-
w:
|
|
4311
|
-
h:
|
|
4312
|
-
pl:
|
|
4313
|
-
pw:
|
|
4314
|
-
p:
|
|
4446
|
+
fn: z35.string(),
|
|
4447
|
+
num_pins: z35.literal(2).default(2),
|
|
4448
|
+
w: z35.string().default("4.4mm"),
|
|
4449
|
+
h: z35.string().default("2.1mm"),
|
|
4450
|
+
pl: z35.string().default("0.91mm"),
|
|
4451
|
+
pw: z35.string().default("1.22mm"),
|
|
4452
|
+
p: z35.string().default("3.146mm")
|
|
4315
4453
|
});
|
|
4316
4454
|
var sod123fl = (raw_params) => {
|
|
4317
4455
|
const parameters = sod123FL_def.parse(raw_params);
|
|
4318
4456
|
const silkscreenRefText = silkscreenRef(
|
|
4319
4457
|
0,
|
|
4320
|
-
|
|
4458
|
+
length26.parse(parameters.h),
|
|
4321
4459
|
0.3
|
|
4322
4460
|
);
|
|
4323
4461
|
const silkscreenLine = {
|
|
@@ -4326,20 +4464,20 @@ var sod123fl = (raw_params) => {
|
|
|
4326
4464
|
pcb_component_id: "",
|
|
4327
4465
|
route: [
|
|
4328
4466
|
{
|
|
4329
|
-
x:
|
|
4330
|
-
y:
|
|
4467
|
+
x: length26.parse(parameters.p) / 2,
|
|
4468
|
+
y: length26.parse(parameters.h) / 2
|
|
4331
4469
|
},
|
|
4332
4470
|
{
|
|
4333
|
-
x: -
|
|
4334
|
-
y:
|
|
4471
|
+
x: -length26.parse(parameters.w) / 2 - 0.2,
|
|
4472
|
+
y: length26.parse(parameters.h) / 2
|
|
4335
4473
|
},
|
|
4336
4474
|
{
|
|
4337
|
-
x: -
|
|
4338
|
-
y: -
|
|
4475
|
+
x: -length26.parse(parameters.w) / 2 - 0.2,
|
|
4476
|
+
y: -length26.parse(parameters.h) / 2
|
|
4339
4477
|
},
|
|
4340
4478
|
{
|
|
4341
|
-
x:
|
|
4342
|
-
y: -
|
|
4479
|
+
x: length26.parse(parameters.p) / 2,
|
|
4480
|
+
y: -length26.parse(parameters.h) / 2
|
|
4343
4481
|
}
|
|
4344
4482
|
],
|
|
4345
4483
|
stroke_width: 0.1,
|
|
@@ -4382,22 +4520,22 @@ var sodWithoutParsing9 = (parameters) => {
|
|
|
4382
4520
|
};
|
|
4383
4521
|
|
|
4384
4522
|
// src/fn/sod723.ts
|
|
4385
|
-
import { z as
|
|
4386
|
-
import { length as
|
|
4523
|
+
import { z as z36 } from "zod";
|
|
4524
|
+
import { length as length27 } from "circuit-json";
|
|
4387
4525
|
var sod_def9 = base_def.extend({
|
|
4388
|
-
fn:
|
|
4389
|
-
num_pins:
|
|
4390
|
-
w:
|
|
4391
|
-
h:
|
|
4392
|
-
pl:
|
|
4393
|
-
pw:
|
|
4394
|
-
p:
|
|
4526
|
+
fn: z36.string(),
|
|
4527
|
+
num_pins: z36.literal(2).default(2),
|
|
4528
|
+
w: z36.string().default("1.80mm"),
|
|
4529
|
+
h: z36.string().default("1.00mm"),
|
|
4530
|
+
pl: z36.string().default("0.66mm"),
|
|
4531
|
+
pw: z36.string().default("0.5mm"),
|
|
4532
|
+
p: z36.string().default("0.8mm")
|
|
4395
4533
|
});
|
|
4396
4534
|
var sod723 = (raw_params) => {
|
|
4397
4535
|
const parameters = sod_def9.parse(raw_params);
|
|
4398
4536
|
const silkscreenRefText = silkscreenRef(
|
|
4399
4537
|
0,
|
|
4400
|
-
|
|
4538
|
+
length27.parse(parameters.h),
|
|
4401
4539
|
0.3
|
|
4402
4540
|
);
|
|
4403
4541
|
const silkscreenLine = {
|
|
@@ -4406,20 +4544,20 @@ var sod723 = (raw_params) => {
|
|
|
4406
4544
|
pcb_component_id: "",
|
|
4407
4545
|
route: [
|
|
4408
4546
|
{
|
|
4409
|
-
x:
|
|
4410
|
-
y:
|
|
4547
|
+
x: length27.parse(parameters.p) / 2,
|
|
4548
|
+
y: length27.parse(parameters.h) / 2
|
|
4411
4549
|
},
|
|
4412
4550
|
{
|
|
4413
|
-
x: -
|
|
4414
|
-
y:
|
|
4551
|
+
x: -length27.parse(parameters.w) / 2 - 0.1,
|
|
4552
|
+
y: length27.parse(parameters.h) / 2
|
|
4415
4553
|
},
|
|
4416
4554
|
{
|
|
4417
|
-
x: -
|
|
4418
|
-
y: -
|
|
4555
|
+
x: -length27.parse(parameters.w) / 2 - 0.1,
|
|
4556
|
+
y: -length27.parse(parameters.h) / 2
|
|
4419
4557
|
},
|
|
4420
4558
|
{
|
|
4421
|
-
x:
|
|
4422
|
-
y: -
|
|
4559
|
+
x: length27.parse(parameters.p) / 2,
|
|
4560
|
+
y: -length27.parse(parameters.h) / 2
|
|
4423
4561
|
}
|
|
4424
4562
|
],
|
|
4425
4563
|
stroke_width: 0.1,
|
|
@@ -4462,22 +4600,22 @@ var sodWithoutParsing10 = (parameters) => {
|
|
|
4462
4600
|
};
|
|
4463
4601
|
|
|
4464
4602
|
// src/fn/sod128.ts
|
|
4465
|
-
import { z as
|
|
4466
|
-
import { length as
|
|
4603
|
+
import { z as z37 } from "zod";
|
|
4604
|
+
import { length as length28 } from "circuit-json";
|
|
4467
4605
|
var sod_def10 = base_def.extend({
|
|
4468
|
-
fn:
|
|
4469
|
-
num_pins:
|
|
4470
|
-
w:
|
|
4471
|
-
h:
|
|
4472
|
-
pl:
|
|
4473
|
-
pw:
|
|
4474
|
-
p:
|
|
4606
|
+
fn: z37.string(),
|
|
4607
|
+
num_pins: z37.literal(2).default(2),
|
|
4608
|
+
w: z37.string().default("6.2mm"),
|
|
4609
|
+
h: z37.string().default("3.4mm"),
|
|
4610
|
+
pl: z37.string().default("1.4mm"),
|
|
4611
|
+
pw: z37.string().default("2.1mm"),
|
|
4612
|
+
p: z37.string().default("4.4mm")
|
|
4475
4613
|
});
|
|
4476
4614
|
var sod128 = (raw_params) => {
|
|
4477
4615
|
const parameters = sod_def10.parse(raw_params);
|
|
4478
4616
|
const silkscreenRefText = silkscreenRef(
|
|
4479
4617
|
0,
|
|
4480
|
-
|
|
4618
|
+
length28.parse(parameters.h) / 2 + 0.4,
|
|
4481
4619
|
0.3
|
|
4482
4620
|
);
|
|
4483
4621
|
const silkscreenLine = {
|
|
@@ -4486,20 +4624,20 @@ var sod128 = (raw_params) => {
|
|
|
4486
4624
|
pcb_component_id: "",
|
|
4487
4625
|
route: [
|
|
4488
4626
|
{
|
|
4489
|
-
x:
|
|
4490
|
-
y:
|
|
4627
|
+
x: length28.parse(parameters.p) / 2,
|
|
4628
|
+
y: length28.parse(parameters.h) / 2
|
|
4491
4629
|
},
|
|
4492
4630
|
{
|
|
4493
|
-
x: -
|
|
4494
|
-
y:
|
|
4631
|
+
x: -length28.parse(parameters.w) / 2 - 0.2,
|
|
4632
|
+
y: length28.parse(parameters.h) / 2
|
|
4495
4633
|
},
|
|
4496
4634
|
{
|
|
4497
|
-
x: -
|
|
4498
|
-
y: -
|
|
4635
|
+
x: -length28.parse(parameters.w) / 2 - 0.2,
|
|
4636
|
+
y: -length28.parse(parameters.h) / 2
|
|
4499
4637
|
},
|
|
4500
4638
|
{
|
|
4501
|
-
x:
|
|
4502
|
-
y: -
|
|
4639
|
+
x: length28.parse(parameters.p) / 2,
|
|
4640
|
+
y: -length28.parse(parameters.h) / 2
|
|
4503
4641
|
}
|
|
4504
4642
|
],
|
|
4505
4643
|
stroke_width: 0.1,
|
|
@@ -4542,29 +4680,29 @@ var sodWithoutParsing11 = (parameters) => {
|
|
|
4542
4680
|
};
|
|
4543
4681
|
|
|
4544
4682
|
// src/fn/sot89.ts
|
|
4545
|
-
import { z as
|
|
4683
|
+
import { z as z38 } from "zod";
|
|
4546
4684
|
var sot89_def = base_def.extend({
|
|
4547
|
-
fn:
|
|
4548
|
-
num_pins:
|
|
4549
|
-
w:
|
|
4550
|
-
h:
|
|
4551
|
-
pl:
|
|
4552
|
-
pw:
|
|
4553
|
-
p:
|
|
4554
|
-
string:
|
|
4685
|
+
fn: z38.string(),
|
|
4686
|
+
num_pins: z38.union([z38.literal(3), z38.literal(5)]).default(3),
|
|
4687
|
+
w: z38.string().default("4.20mm"),
|
|
4688
|
+
h: z38.string().default("4.80mm"),
|
|
4689
|
+
pl: z38.string().default("1.3mm"),
|
|
4690
|
+
pw: z38.string().default("0.9mm"),
|
|
4691
|
+
p: z38.string().default("1.5mm"),
|
|
4692
|
+
string: z38.string().optional()
|
|
4555
4693
|
});
|
|
4556
4694
|
var sot89_3 = (parameters) => {
|
|
4557
4695
|
const pads = [];
|
|
4558
4696
|
const padGap = Number.parseFloat(parameters.p);
|
|
4559
4697
|
const padWidth = Number.parseFloat(parameters.pw);
|
|
4560
|
-
const
|
|
4698
|
+
const length51 = Number.parseFloat(parameters.w);
|
|
4561
4699
|
const padHeight = Number.parseFloat(parameters.pl);
|
|
4562
4700
|
const centerExtra = 0.175;
|
|
4563
4701
|
const outerPadXShift = (padHeight - (padHeight + centerExtra)) / 2;
|
|
4564
4702
|
pads.push(
|
|
4565
|
-
rectpad(1, -
|
|
4566
|
-
rectpad(2, -
|
|
4567
|
-
rectpad(3, -
|
|
4703
|
+
rectpad(1, -length51 / 2 + outerPadXShift, padGap, padHeight, padWidth),
|
|
4704
|
+
rectpad(2, -length51 / 2, 0, padHeight + centerExtra, padWidth),
|
|
4705
|
+
rectpad(3, -length51 / 2 + outerPadXShift, -padGap, padHeight, padWidth)
|
|
4568
4706
|
);
|
|
4569
4707
|
const silkscreenRefText = silkscreenRef(0, 0, 0.3);
|
|
4570
4708
|
const width = Number.parseFloat(parameters.w) / 2 - 1;
|
|
@@ -4604,7 +4742,7 @@ var sot89_5 = (parameters) => {
|
|
|
4604
4742
|
const pads = [];
|
|
4605
4743
|
const padGap = Number.parseFloat(parameters.p);
|
|
4606
4744
|
const padWidth = Number.parseFloat(parameters.pw);
|
|
4607
|
-
const
|
|
4745
|
+
const length51 = Number.parseFloat(parameters.w);
|
|
4608
4746
|
pads.push(
|
|
4609
4747
|
rectpad(1, -1.85, -1.5, 1.5, 0.7),
|
|
4610
4748
|
rectpad(2, -1.85, 1.5, 1.5, 0.7),
|
|
@@ -4672,18 +4810,18 @@ var sot89 = (raw_params) => {
|
|
|
4672
4810
|
|
|
4673
4811
|
// src/fn/to220.ts
|
|
4674
4812
|
import {
|
|
4675
|
-
length as
|
|
4813
|
+
length as length29
|
|
4676
4814
|
} from "circuit-json";
|
|
4677
|
-
import { z as
|
|
4815
|
+
import { z as z39 } from "zod";
|
|
4678
4816
|
var to220_def = base_def.extend({
|
|
4679
|
-
fn:
|
|
4680
|
-
p:
|
|
4681
|
-
id:
|
|
4682
|
-
od:
|
|
4683
|
-
w:
|
|
4684
|
-
h:
|
|
4685
|
-
num_pins:
|
|
4686
|
-
string:
|
|
4817
|
+
fn: z39.string(),
|
|
4818
|
+
p: length29.optional().default("5.0mm"),
|
|
4819
|
+
id: length29.optional().default("1.0mm"),
|
|
4820
|
+
od: length29.optional().default("1.9mm"),
|
|
4821
|
+
w: length29.optional().default("13mm"),
|
|
4822
|
+
h: length29.optional().default("7mm"),
|
|
4823
|
+
num_pins: z39.number().optional(),
|
|
4824
|
+
string: z39.string().optional()
|
|
4687
4825
|
});
|
|
4688
4826
|
var to220 = (raw_params) => {
|
|
4689
4827
|
const parameters = to220_def.parse(raw_params);
|
|
@@ -4763,22 +4901,22 @@ var to220 = (raw_params) => {
|
|
|
4763
4901
|
};
|
|
4764
4902
|
|
|
4765
4903
|
// src/fn/minimelf.ts
|
|
4766
|
-
import { z as
|
|
4767
|
-
import { length as
|
|
4904
|
+
import { z as z40 } from "zod";
|
|
4905
|
+
import { length as length30 } from "circuit-json";
|
|
4768
4906
|
var minimelf_def = base_def.extend({
|
|
4769
|
-
fn:
|
|
4770
|
-
num_pins:
|
|
4771
|
-
w:
|
|
4772
|
-
h:
|
|
4773
|
-
pl:
|
|
4774
|
-
pw:
|
|
4775
|
-
p:
|
|
4907
|
+
fn: z40.string(),
|
|
4908
|
+
num_pins: z40.literal(2).default(2),
|
|
4909
|
+
w: z40.string().default("5.40mm"),
|
|
4910
|
+
h: z40.string().default("2.30mm"),
|
|
4911
|
+
pl: z40.string().default("1.30mm"),
|
|
4912
|
+
pw: z40.string().default("1.70mm"),
|
|
4913
|
+
p: z40.string().default("3.5mm")
|
|
4776
4914
|
});
|
|
4777
4915
|
var minimelf = (raw_params) => {
|
|
4778
4916
|
const parameters = minimelf_def.parse(raw_params);
|
|
4779
4917
|
const silkscreenRefText = silkscreenRef(
|
|
4780
4918
|
0,
|
|
4781
|
-
|
|
4919
|
+
length30.parse(parameters.h) / 2 + 0.4,
|
|
4782
4920
|
0.3
|
|
4783
4921
|
);
|
|
4784
4922
|
const silkscreenLine = {
|
|
@@ -4787,20 +4925,20 @@ var minimelf = (raw_params) => {
|
|
|
4787
4925
|
pcb_component_id: "",
|
|
4788
4926
|
route: [
|
|
4789
4927
|
{
|
|
4790
|
-
x:
|
|
4791
|
-
y:
|
|
4928
|
+
x: length30.parse(parameters.p) / 2,
|
|
4929
|
+
y: length30.parse(parameters.h) / 2
|
|
4792
4930
|
},
|
|
4793
4931
|
{
|
|
4794
|
-
x: -
|
|
4795
|
-
y:
|
|
4932
|
+
x: -length30.parse(parameters.w) / 2,
|
|
4933
|
+
y: length30.parse(parameters.h) / 2
|
|
4796
4934
|
},
|
|
4797
4935
|
{
|
|
4798
|
-
x: -
|
|
4799
|
-
y: -
|
|
4936
|
+
x: -length30.parse(parameters.w) / 2,
|
|
4937
|
+
y: -length30.parse(parameters.h) / 2
|
|
4800
4938
|
},
|
|
4801
4939
|
{
|
|
4802
|
-
x:
|
|
4803
|
-
y: -
|
|
4940
|
+
x: length30.parse(parameters.p) / 2,
|
|
4941
|
+
y: -length30.parse(parameters.h) / 2
|
|
4804
4942
|
}
|
|
4805
4943
|
],
|
|
4806
4944
|
stroke_width: 0.1,
|
|
@@ -4839,22 +4977,22 @@ var miniMelfWithoutParsing = (parameters) => {
|
|
|
4839
4977
|
};
|
|
4840
4978
|
|
|
4841
4979
|
// src/fn/sod882d.ts
|
|
4842
|
-
import { z as
|
|
4843
|
-
import { length as
|
|
4980
|
+
import { z as z41 } from "zod";
|
|
4981
|
+
import { length as length31 } from "circuit-json";
|
|
4844
4982
|
var sod_def11 = base_def.extend({
|
|
4845
|
-
fn:
|
|
4846
|
-
num_pins:
|
|
4847
|
-
w:
|
|
4848
|
-
h:
|
|
4849
|
-
pl:
|
|
4850
|
-
pw:
|
|
4851
|
-
p:
|
|
4983
|
+
fn: z41.string(),
|
|
4984
|
+
num_pins: z41.literal(2).default(2),
|
|
4985
|
+
w: z41.string().default("1.90mm"),
|
|
4986
|
+
h: z41.string().default("1.33mm"),
|
|
4987
|
+
pl: z41.string().default("0.5mm"),
|
|
4988
|
+
pw: z41.string().default("0.7mm"),
|
|
4989
|
+
p: z41.string().default("0.8mm")
|
|
4852
4990
|
});
|
|
4853
4991
|
var sod882d = (raw_params) => {
|
|
4854
4992
|
const parameters = sod_def11.parse(raw_params);
|
|
4855
4993
|
const silkscreenRefText = silkscreenRef(
|
|
4856
4994
|
0,
|
|
4857
|
-
|
|
4995
|
+
length31.parse(parameters.h) + 0.1,
|
|
4858
4996
|
0.3
|
|
4859
4997
|
);
|
|
4860
4998
|
const silkscreenLine = {
|
|
@@ -4863,20 +5001,20 @@ var sod882d = (raw_params) => {
|
|
|
4863
5001
|
pcb_component_id: "",
|
|
4864
5002
|
route: [
|
|
4865
5003
|
{
|
|
4866
|
-
x:
|
|
4867
|
-
y:
|
|
5004
|
+
x: length31.parse(parameters.p) / 2 + 0.1,
|
|
5005
|
+
y: length31.parse(parameters.h) / 2
|
|
4868
5006
|
},
|
|
4869
5007
|
{
|
|
4870
|
-
x: -
|
|
4871
|
-
y:
|
|
5008
|
+
x: -length31.parse(parameters.w) / 2,
|
|
5009
|
+
y: length31.parse(parameters.h) / 2
|
|
4872
5010
|
},
|
|
4873
5011
|
{
|
|
4874
|
-
x: -
|
|
4875
|
-
y: -
|
|
5012
|
+
x: -length31.parse(parameters.w) / 2,
|
|
5013
|
+
y: -length31.parse(parameters.h) / 2
|
|
4876
5014
|
},
|
|
4877
5015
|
{
|
|
4878
|
-
x:
|
|
4879
|
-
y: -
|
|
5016
|
+
x: length31.parse(parameters.p) / 2 + 0.1,
|
|
5017
|
+
y: -length31.parse(parameters.h) / 2
|
|
4880
5018
|
}
|
|
4881
5019
|
],
|
|
4882
5020
|
stroke_width: 0.1,
|
|
@@ -4919,22 +5057,22 @@ var sodWithoutParsing12 = (parameters) => {
|
|
|
4919
5057
|
};
|
|
4920
5058
|
|
|
4921
5059
|
// src/fn/melf.ts
|
|
4922
|
-
import { z as
|
|
4923
|
-
import { length as
|
|
5060
|
+
import { z as z42 } from "zod";
|
|
5061
|
+
import { length as length32 } from "circuit-json";
|
|
4924
5062
|
var melf_def = base_def.extend({
|
|
4925
|
-
fn:
|
|
4926
|
-
num_pins:
|
|
4927
|
-
w:
|
|
4928
|
-
h:
|
|
4929
|
-
pl:
|
|
4930
|
-
pw:
|
|
4931
|
-
p:
|
|
5063
|
+
fn: z42.string(),
|
|
5064
|
+
num_pins: z42.literal(2).default(2),
|
|
5065
|
+
w: z42.string().default("7.0mm"),
|
|
5066
|
+
h: z42.string().default("3.35mm"),
|
|
5067
|
+
pl: z42.string().default("1.50mm"),
|
|
5068
|
+
pw: z42.string().default("2.70mm"),
|
|
5069
|
+
p: z42.string().default("4.8mm")
|
|
4932
5070
|
});
|
|
4933
5071
|
var melf = (raw_params) => {
|
|
4934
5072
|
const parameters = melf_def.parse(raw_params);
|
|
4935
5073
|
const silkscreenRefText = silkscreenRef(
|
|
4936
5074
|
0,
|
|
4937
|
-
|
|
5075
|
+
length32.parse(parameters.h),
|
|
4938
5076
|
0.3
|
|
4939
5077
|
);
|
|
4940
5078
|
const silkscreenLine = {
|
|
@@ -4943,20 +5081,20 @@ var melf = (raw_params) => {
|
|
|
4943
5081
|
pcb_component_id: "",
|
|
4944
5082
|
route: [
|
|
4945
5083
|
{
|
|
4946
|
-
x:
|
|
4947
|
-
y:
|
|
5084
|
+
x: length32.parse(parameters.p) / 2,
|
|
5085
|
+
y: length32.parse(parameters.h) / 2
|
|
4948
5086
|
},
|
|
4949
5087
|
{
|
|
4950
|
-
x: -
|
|
4951
|
-
y:
|
|
5088
|
+
x: -length32.parse(parameters.w) / 2,
|
|
5089
|
+
y: length32.parse(parameters.h) / 2
|
|
4952
5090
|
},
|
|
4953
5091
|
{
|
|
4954
|
-
x: -
|
|
4955
|
-
y: -
|
|
5092
|
+
x: -length32.parse(parameters.w) / 2,
|
|
5093
|
+
y: -length32.parse(parameters.h) / 2
|
|
4956
5094
|
},
|
|
4957
5095
|
{
|
|
4958
|
-
x:
|
|
4959
|
-
y: -
|
|
5096
|
+
x: length32.parse(parameters.p) / 2,
|
|
5097
|
+
y: -length32.parse(parameters.h) / 2
|
|
4960
5098
|
}
|
|
4961
5099
|
],
|
|
4962
5100
|
stroke_width: 0.1,
|
|
@@ -4999,22 +5137,22 @@ var melfWithoutParsing = (parameters) => {
|
|
|
4999
5137
|
};
|
|
5000
5138
|
|
|
5001
5139
|
// src/fn/micromelf.ts
|
|
5002
|
-
import { z as
|
|
5003
|
-
import { length as
|
|
5140
|
+
import { z as z43 } from "zod";
|
|
5141
|
+
import { length as length33 } from "circuit-json";
|
|
5004
5142
|
var micromelf_def = base_def.extend({
|
|
5005
|
-
fn:
|
|
5006
|
-
num_pins:
|
|
5007
|
-
w:
|
|
5008
|
-
h:
|
|
5009
|
-
pl:
|
|
5010
|
-
pw:
|
|
5011
|
-
p:
|
|
5143
|
+
fn: z43.string(),
|
|
5144
|
+
num_pins: z43.literal(2).default(2),
|
|
5145
|
+
w: z43.string().default("3.0mm"),
|
|
5146
|
+
h: z43.string().default("1.80mm"),
|
|
5147
|
+
pl: z43.string().default("0.80mm"),
|
|
5148
|
+
pw: z43.string().default("1.20mm"),
|
|
5149
|
+
p: z43.string().default("1.6mm")
|
|
5012
5150
|
});
|
|
5013
5151
|
var micromelf = (raw_params) => {
|
|
5014
5152
|
const parameters = micromelf_def.parse(raw_params);
|
|
5015
5153
|
const silkscreenRefText = silkscreenRef(
|
|
5016
5154
|
0,
|
|
5017
|
-
|
|
5155
|
+
length33.parse(parameters.h),
|
|
5018
5156
|
0.3
|
|
5019
5157
|
);
|
|
5020
5158
|
const silkscreenLine = {
|
|
@@ -5023,20 +5161,20 @@ var micromelf = (raw_params) => {
|
|
|
5023
5161
|
pcb_component_id: "",
|
|
5024
5162
|
route: [
|
|
5025
5163
|
{
|
|
5026
|
-
x:
|
|
5027
|
-
y:
|
|
5164
|
+
x: length33.parse(parameters.p) / 2,
|
|
5165
|
+
y: length33.parse(parameters.h) / 2
|
|
5028
5166
|
},
|
|
5029
5167
|
{
|
|
5030
|
-
x: -
|
|
5031
|
-
y:
|
|
5168
|
+
x: -length33.parse(parameters.w) / 2 - 0.1,
|
|
5169
|
+
y: length33.parse(parameters.h) / 2
|
|
5032
5170
|
},
|
|
5033
5171
|
{
|
|
5034
|
-
x: -
|
|
5035
|
-
y: -
|
|
5172
|
+
x: -length33.parse(parameters.w) / 2 - 0.1,
|
|
5173
|
+
y: -length33.parse(parameters.h) / 2
|
|
5036
5174
|
},
|
|
5037
5175
|
{
|
|
5038
|
-
x:
|
|
5039
|
-
y: -
|
|
5176
|
+
x: length33.parse(parameters.p) / 2,
|
|
5177
|
+
y: -length33.parse(parameters.h) / 2
|
|
5040
5178
|
}
|
|
5041
5179
|
],
|
|
5042
5180
|
stroke_width: 0.1,
|
|
@@ -5079,22 +5217,22 @@ var microMelfWithoutParsing = (parameters) => {
|
|
|
5079
5217
|
};
|
|
5080
5218
|
|
|
5081
5219
|
// src/fn/sma.ts
|
|
5082
|
-
import { z as
|
|
5083
|
-
import { length as
|
|
5220
|
+
import { z as z44 } from "zod";
|
|
5221
|
+
import { length as length34 } from "circuit-json";
|
|
5084
5222
|
var sma_def = base_def.extend({
|
|
5085
|
-
fn:
|
|
5086
|
-
num_pins:
|
|
5087
|
-
w:
|
|
5088
|
-
h:
|
|
5089
|
-
pl:
|
|
5090
|
-
pw:
|
|
5091
|
-
p:
|
|
5223
|
+
fn: z44.string(),
|
|
5224
|
+
num_pins: z44.literal(2).default(2),
|
|
5225
|
+
w: z44.string().default("7.10mm"),
|
|
5226
|
+
h: z44.string().default("3.40mm"),
|
|
5227
|
+
pl: z44.string().default("2.45mm"),
|
|
5228
|
+
pw: z44.string().default("1.80mm"),
|
|
5229
|
+
p: z44.string().default("4.05mm")
|
|
5092
5230
|
});
|
|
5093
5231
|
var sma = (raw_params) => {
|
|
5094
5232
|
const parameters = sma_def.parse(raw_params);
|
|
5095
5233
|
const silkscreenRefText = silkscreenRef(
|
|
5096
5234
|
0,
|
|
5097
|
-
|
|
5235
|
+
length34.parse(parameters.h) / 2 + 0.5,
|
|
5098
5236
|
0.3
|
|
5099
5237
|
);
|
|
5100
5238
|
const silkscreenLine = {
|
|
@@ -5103,20 +5241,20 @@ var sma = (raw_params) => {
|
|
|
5103
5241
|
pcb_component_id: "",
|
|
5104
5242
|
route: [
|
|
5105
5243
|
{
|
|
5106
|
-
x:
|
|
5107
|
-
y:
|
|
5244
|
+
x: length34.parse(parameters.p) / 2,
|
|
5245
|
+
y: length34.parse(parameters.h) / 2
|
|
5108
5246
|
},
|
|
5109
5247
|
{
|
|
5110
|
-
x: -
|
|
5111
|
-
y:
|
|
5248
|
+
x: -length34.parse(parameters.w) / 2 - 0.5,
|
|
5249
|
+
y: length34.parse(parameters.h) / 2
|
|
5112
5250
|
},
|
|
5113
5251
|
{
|
|
5114
|
-
x: -
|
|
5115
|
-
y: -
|
|
5252
|
+
x: -length34.parse(parameters.w) / 2 - 0.5,
|
|
5253
|
+
y: -length34.parse(parameters.h) / 2
|
|
5116
5254
|
},
|
|
5117
5255
|
{
|
|
5118
|
-
x:
|
|
5119
|
-
y: -
|
|
5256
|
+
x: length34.parse(parameters.p) / 2,
|
|
5257
|
+
y: -length34.parse(parameters.h) / 2
|
|
5120
5258
|
}
|
|
5121
5259
|
],
|
|
5122
5260
|
stroke_width: 0.1,
|
|
@@ -5158,22 +5296,22 @@ var smaWithoutParsing = (parameters) => {
|
|
|
5158
5296
|
};
|
|
5159
5297
|
|
|
5160
5298
|
// src/fn/smf.ts
|
|
5161
|
-
import { z as
|
|
5162
|
-
import { length as
|
|
5299
|
+
import { z as z45 } from "zod";
|
|
5300
|
+
import { length as length35 } from "circuit-json";
|
|
5163
5301
|
var smf_def = base_def.extend({
|
|
5164
|
-
fn:
|
|
5165
|
-
num_pins:
|
|
5166
|
-
w:
|
|
5167
|
-
h:
|
|
5168
|
-
pl:
|
|
5169
|
-
pw:
|
|
5170
|
-
p:
|
|
5302
|
+
fn: z45.string(),
|
|
5303
|
+
num_pins: z45.literal(2).default(2),
|
|
5304
|
+
w: z45.string().default("4.80mm"),
|
|
5305
|
+
h: z45.string().default("2.10mm"),
|
|
5306
|
+
pl: z45.string().default("1.30mm"),
|
|
5307
|
+
pw: z45.string().default("1.40mm"),
|
|
5308
|
+
p: z45.string().default("2.9mm")
|
|
5171
5309
|
});
|
|
5172
5310
|
var smf = (raw_params) => {
|
|
5173
5311
|
const parameters = smf_def.parse(raw_params);
|
|
5174
5312
|
const silkscreenRefText = silkscreenRef(
|
|
5175
5313
|
0,
|
|
5176
|
-
|
|
5314
|
+
length35.parse(parameters.h) - 0.5,
|
|
5177
5315
|
0.3
|
|
5178
5316
|
);
|
|
5179
5317
|
const silkscreenLine = {
|
|
@@ -5182,20 +5320,20 @@ var smf = (raw_params) => {
|
|
|
5182
5320
|
pcb_component_id: "",
|
|
5183
5321
|
route: [
|
|
5184
5322
|
{
|
|
5185
|
-
x:
|
|
5186
|
-
y:
|
|
5323
|
+
x: length35.parse(parameters.p) / 2,
|
|
5324
|
+
y: length35.parse(parameters.h) / 2
|
|
5187
5325
|
},
|
|
5188
5326
|
{
|
|
5189
|
-
x: -
|
|
5190
|
-
y:
|
|
5327
|
+
x: -length35.parse(parameters.w) / 2,
|
|
5328
|
+
y: length35.parse(parameters.h) / 2
|
|
5191
5329
|
},
|
|
5192
5330
|
{
|
|
5193
|
-
x: -
|
|
5194
|
-
y: -
|
|
5331
|
+
x: -length35.parse(parameters.w) / 2,
|
|
5332
|
+
y: -length35.parse(parameters.h) / 2
|
|
5195
5333
|
},
|
|
5196
5334
|
{
|
|
5197
|
-
x:
|
|
5198
|
-
y: -
|
|
5335
|
+
x: length35.parse(parameters.p) / 2,
|
|
5336
|
+
y: -length35.parse(parameters.h) / 2
|
|
5199
5337
|
}
|
|
5200
5338
|
],
|
|
5201
5339
|
stroke_width: 0.1,
|
|
@@ -5238,22 +5376,22 @@ var smfWithoutParsing = (parameters) => {
|
|
|
5238
5376
|
};
|
|
5239
5377
|
|
|
5240
5378
|
// src/fn/smb.ts
|
|
5241
|
-
import { z as
|
|
5242
|
-
import { length as
|
|
5379
|
+
import { z as z46 } from "zod";
|
|
5380
|
+
import { length as length36 } from "circuit-json";
|
|
5243
5381
|
var smb_def = base_def.extend({
|
|
5244
|
-
fn:
|
|
5245
|
-
num_pins:
|
|
5246
|
-
w:
|
|
5247
|
-
h:
|
|
5248
|
-
pl:
|
|
5249
|
-
pw:
|
|
5250
|
-
p:
|
|
5382
|
+
fn: z46.string(),
|
|
5383
|
+
num_pins: z46.literal(2).default(2),
|
|
5384
|
+
w: z46.string().default("7.30mm"),
|
|
5385
|
+
h: z46.string().default("4.40mm"),
|
|
5386
|
+
pl: z46.string().default("2.50mm"),
|
|
5387
|
+
pw: z46.string().default("2.30mm"),
|
|
5388
|
+
p: z46.string().default("4.30mm")
|
|
5251
5389
|
});
|
|
5252
5390
|
var smb = (raw_params) => {
|
|
5253
5391
|
const parameters = smb_def.parse(raw_params);
|
|
5254
5392
|
const silkscreenRefText = silkscreenRef(
|
|
5255
5393
|
0,
|
|
5256
|
-
|
|
5394
|
+
length36.parse(parameters.h) / 2 + 0.5,
|
|
5257
5395
|
0.3
|
|
5258
5396
|
);
|
|
5259
5397
|
const silkscreenLine = {
|
|
@@ -5262,20 +5400,20 @@ var smb = (raw_params) => {
|
|
|
5262
5400
|
pcb_component_id: "",
|
|
5263
5401
|
route: [
|
|
5264
5402
|
{
|
|
5265
|
-
x:
|
|
5266
|
-
y:
|
|
5403
|
+
x: length36.parse(parameters.p) / 2,
|
|
5404
|
+
y: length36.parse(parameters.h) / 2
|
|
5267
5405
|
},
|
|
5268
5406
|
{
|
|
5269
|
-
x: -
|
|
5270
|
-
y:
|
|
5407
|
+
x: -length36.parse(parameters.w) / 2 - 0.1,
|
|
5408
|
+
y: length36.parse(parameters.h) / 2
|
|
5271
5409
|
},
|
|
5272
5410
|
{
|
|
5273
|
-
x: -
|
|
5274
|
-
y: -
|
|
5411
|
+
x: -length36.parse(parameters.w) / 2 - 0.1,
|
|
5412
|
+
y: -length36.parse(parameters.h) / 2
|
|
5275
5413
|
},
|
|
5276
5414
|
{
|
|
5277
|
-
x:
|
|
5278
|
-
y: -
|
|
5415
|
+
x: length36.parse(parameters.p) / 2,
|
|
5416
|
+
y: -length36.parse(parameters.h) / 2
|
|
5279
5417
|
}
|
|
5280
5418
|
],
|
|
5281
5419
|
stroke_width: 0.1,
|
|
@@ -5318,16 +5456,16 @@ var smbWithoutParsing = (parameters) => {
|
|
|
5318
5456
|
};
|
|
5319
5457
|
|
|
5320
5458
|
// src/fn/smc.ts
|
|
5321
|
-
import { z as
|
|
5322
|
-
import { length as
|
|
5459
|
+
import { z as z47 } from "zod";
|
|
5460
|
+
import { length as length37 } from "circuit-json";
|
|
5323
5461
|
var smc_def = base_def.extend({
|
|
5324
|
-
fn:
|
|
5325
|
-
num_pins:
|
|
5326
|
-
w:
|
|
5327
|
-
h:
|
|
5328
|
-
pl:
|
|
5329
|
-
pw:
|
|
5330
|
-
p:
|
|
5462
|
+
fn: z47.string(),
|
|
5463
|
+
num_pins: z47.literal(2).default(2),
|
|
5464
|
+
w: z47.string().default("10.70mm"),
|
|
5465
|
+
h: z47.string().default("6.60mm"),
|
|
5466
|
+
pl: z47.string().default("3.30mm"),
|
|
5467
|
+
pw: z47.string().default("2.50mm"),
|
|
5468
|
+
p: z47.string().default("6.80mm")
|
|
5331
5469
|
});
|
|
5332
5470
|
var smc = (raw_params) => {
|
|
5333
5471
|
const parameters = smc_def.parse(raw_params);
|
|
@@ -5338,20 +5476,20 @@ var smc = (raw_params) => {
|
|
|
5338
5476
|
pcb_component_id: "",
|
|
5339
5477
|
route: [
|
|
5340
5478
|
{
|
|
5341
|
-
x:
|
|
5342
|
-
y:
|
|
5479
|
+
x: length37.parse(parameters.p) / 2,
|
|
5480
|
+
y: length37.parse(parameters.h) / 2 - 0.8
|
|
5343
5481
|
},
|
|
5344
5482
|
{
|
|
5345
|
-
x: -
|
|
5346
|
-
y:
|
|
5483
|
+
x: -length37.parse(parameters.w) / 2 - 0.8,
|
|
5484
|
+
y: length37.parse(parameters.h) / 2 - 0.8
|
|
5347
5485
|
},
|
|
5348
5486
|
{
|
|
5349
|
-
x: -
|
|
5350
|
-
y: -
|
|
5487
|
+
x: -length37.parse(parameters.w) / 2 - 0.8,
|
|
5488
|
+
y: -length37.parse(parameters.h) / 2 + 0.8
|
|
5351
5489
|
},
|
|
5352
5490
|
{
|
|
5353
|
-
x:
|
|
5354
|
-
y: -
|
|
5491
|
+
x: length37.parse(parameters.p) / 2,
|
|
5492
|
+
y: -length37.parse(parameters.h) / 2 + 0.8
|
|
5355
5493
|
}
|
|
5356
5494
|
],
|
|
5357
5495
|
stroke_width: 0.1,
|
|
@@ -5393,16 +5531,16 @@ var smcWithoutParsing = (parameters) => {
|
|
|
5393
5531
|
};
|
|
5394
5532
|
|
|
5395
5533
|
// src/fn/sot223.ts
|
|
5396
|
-
import { z as
|
|
5534
|
+
import { z as z48 } from "zod";
|
|
5397
5535
|
var sot223_def = base_def.extend({
|
|
5398
|
-
fn:
|
|
5399
|
-
num_pins:
|
|
5400
|
-
w:
|
|
5401
|
-
h:
|
|
5402
|
-
pl:
|
|
5403
|
-
pw:
|
|
5404
|
-
p:
|
|
5405
|
-
string:
|
|
5536
|
+
fn: z48.string(),
|
|
5537
|
+
num_pins: z48.number().default(4),
|
|
5538
|
+
w: z48.string().default("8.50mm"),
|
|
5539
|
+
h: z48.string().default("6.90mm"),
|
|
5540
|
+
pl: z48.string().default("2mm"),
|
|
5541
|
+
pw: z48.string().default("1.5mm"),
|
|
5542
|
+
p: z48.string().default("2.30mm"),
|
|
5543
|
+
string: z48.string().optional()
|
|
5406
5544
|
});
|
|
5407
5545
|
var sot223 = (raw_params) => {
|
|
5408
5546
|
const match = raw_params.string?.match(/^sot223_(\d+)/);
|
|
@@ -5648,16 +5786,16 @@ var sot223_6 = (parameters) => {
|
|
|
5648
5786
|
};
|
|
5649
5787
|
|
|
5650
5788
|
// src/fn/sot23w.ts
|
|
5651
|
-
import { z as
|
|
5789
|
+
import { z as z49 } from "zod";
|
|
5652
5790
|
var sot23w_def = base_def.extend({
|
|
5653
|
-
fn:
|
|
5654
|
-
num_pins:
|
|
5655
|
-
w:
|
|
5656
|
-
h:
|
|
5657
|
-
pl:
|
|
5658
|
-
pw:
|
|
5659
|
-
p:
|
|
5660
|
-
string:
|
|
5791
|
+
fn: z49.string(),
|
|
5792
|
+
num_pins: z49.number().default(3),
|
|
5793
|
+
w: z49.string().default("3.40mm"),
|
|
5794
|
+
h: z49.string().default("3.30mm"),
|
|
5795
|
+
pl: z49.string().default("1mm"),
|
|
5796
|
+
pw: z49.string().default("0.7mm"),
|
|
5797
|
+
p: z49.string().default("1.2mm"),
|
|
5798
|
+
string: z49.string().optional()
|
|
5661
5799
|
});
|
|
5662
5800
|
var sot23w = (raw_params) => {
|
|
5663
5801
|
const match = raw_params.string?.match(/^sot23w_(\d+)/);
|
|
@@ -5745,16 +5883,16 @@ var sot23w_3 = (parameters) => {
|
|
|
5745
5883
|
};
|
|
5746
5884
|
|
|
5747
5885
|
// src/fn/to92s.ts
|
|
5748
|
-
import { z as
|
|
5886
|
+
import { z as z50 } from "zod";
|
|
5749
5887
|
var to92s_def = base_def.extend({
|
|
5750
|
-
fn:
|
|
5751
|
-
num_pins:
|
|
5752
|
-
p:
|
|
5753
|
-
id:
|
|
5754
|
-
od:
|
|
5755
|
-
w:
|
|
5756
|
-
h:
|
|
5757
|
-
string:
|
|
5888
|
+
fn: z50.string(),
|
|
5889
|
+
num_pins: z50.union([z50.literal(3), z50.literal(2)]).default(3),
|
|
5890
|
+
p: z50.string().default("1.27mm"),
|
|
5891
|
+
id: z50.string().default("0.72mm"),
|
|
5892
|
+
od: z50.string().default("0.95mm"),
|
|
5893
|
+
w: z50.string().default("2.5mm"),
|
|
5894
|
+
h: z50.string().default("4.2mm"),
|
|
5895
|
+
string: z50.string().optional()
|
|
5758
5896
|
});
|
|
5759
5897
|
var to92s_3 = (parameters) => {
|
|
5760
5898
|
const { p, id, od, w, h } = parameters;
|
|
@@ -5821,18 +5959,18 @@ var to92s = (raw_params) => {
|
|
|
5821
5959
|
|
|
5822
5960
|
// src/fn/jst.ts
|
|
5823
5961
|
import {
|
|
5824
|
-
length as
|
|
5962
|
+
length as length38
|
|
5825
5963
|
} from "circuit-json";
|
|
5826
|
-
import { z as
|
|
5964
|
+
import { z as z51 } from "zod";
|
|
5827
5965
|
var jst_def = base_def.extend({
|
|
5828
|
-
fn:
|
|
5829
|
-
p:
|
|
5830
|
-
id:
|
|
5831
|
-
pw:
|
|
5832
|
-
pl:
|
|
5833
|
-
w:
|
|
5834
|
-
h:
|
|
5835
|
-
sh:
|
|
5966
|
+
fn: z51.string(),
|
|
5967
|
+
p: length38.optional(),
|
|
5968
|
+
id: length38.optional(),
|
|
5969
|
+
pw: length38.optional(),
|
|
5970
|
+
pl: length38.optional(),
|
|
5971
|
+
w: length38.optional(),
|
|
5972
|
+
h: length38.optional(),
|
|
5973
|
+
sh: z51.union([z51.boolean(), z51.string(), z51.number()]).optional().transform((v) => {
|
|
5836
5974
|
if (typeof v === "string") {
|
|
5837
5975
|
const n = Number(v);
|
|
5838
5976
|
return Number.isNaN(n) ? true : n;
|
|
@@ -5841,26 +5979,26 @@ var jst_def = base_def.extend({
|
|
|
5841
5979
|
}).describe(
|
|
5842
5980
|
'JST SH (Surface-mount) connector family. SH stands for "Super High-density".'
|
|
5843
5981
|
),
|
|
5844
|
-
ph:
|
|
5982
|
+
ph: z51.boolean().optional().describe(
|
|
5845
5983
|
'JST PH (Through-hole) connector family. PH stands for "Pin Header".'
|
|
5846
5984
|
),
|
|
5847
|
-
string:
|
|
5985
|
+
string: z51.string().optional()
|
|
5848
5986
|
});
|
|
5849
5987
|
var variantDefaults = {
|
|
5850
5988
|
ph: {
|
|
5851
|
-
p:
|
|
5852
|
-
id:
|
|
5853
|
-
pw:
|
|
5854
|
-
pl:
|
|
5855
|
-
w:
|
|
5856
|
-
h:
|
|
5989
|
+
p: length38.parse("2.2mm"),
|
|
5990
|
+
id: length38.parse("0.70mm"),
|
|
5991
|
+
pw: length38.parse("1.20mm"),
|
|
5992
|
+
pl: length38.parse("1.20mm"),
|
|
5993
|
+
w: length38.parse("6mm"),
|
|
5994
|
+
h: length38.parse("5mm")
|
|
5857
5995
|
},
|
|
5858
5996
|
sh: {
|
|
5859
|
-
p:
|
|
5860
|
-
pw:
|
|
5861
|
-
pl:
|
|
5862
|
-
w:
|
|
5863
|
-
h:
|
|
5997
|
+
p: length38.parse("1mm"),
|
|
5998
|
+
pw: length38.parse("0.6mm"),
|
|
5999
|
+
pl: length38.parse("1.55mm"),
|
|
6000
|
+
w: length38.parse("5.8mm"),
|
|
6001
|
+
h: length38.parse("7.8mm")
|
|
5864
6002
|
}
|
|
5865
6003
|
};
|
|
5866
6004
|
function getVariant(params) {
|
|
@@ -5959,22 +6097,22 @@ var jst = (raw_params) => {
|
|
|
5959
6097
|
};
|
|
5960
6098
|
|
|
5961
6099
|
// src/fn/sod110.ts
|
|
5962
|
-
import { z as
|
|
5963
|
-
import { length as
|
|
6100
|
+
import { z as z52 } from "zod";
|
|
6101
|
+
import { length as length39 } from "circuit-json";
|
|
5964
6102
|
var sod_def12 = base_def.extend({
|
|
5965
|
-
fn:
|
|
5966
|
-
num_pins:
|
|
5967
|
-
w:
|
|
5968
|
-
h:
|
|
5969
|
-
pl:
|
|
5970
|
-
pw:
|
|
5971
|
-
p:
|
|
6103
|
+
fn: z52.string(),
|
|
6104
|
+
num_pins: z52.literal(2).default(2),
|
|
6105
|
+
w: z52.string().default("3.30mm"),
|
|
6106
|
+
h: z52.string().default("1.70mm"),
|
|
6107
|
+
pl: z52.string().default("0.80mm"),
|
|
6108
|
+
pw: z52.string().default("1mm"),
|
|
6109
|
+
p: z52.string().default("1.90mm")
|
|
5972
6110
|
});
|
|
5973
6111
|
var sod110 = (raw_params) => {
|
|
5974
6112
|
const parameters = sod_def12.parse(raw_params);
|
|
5975
6113
|
const silkscreenRefText = silkscreenRef(
|
|
5976
6114
|
0,
|
|
5977
|
-
|
|
6115
|
+
length39.parse(parameters.h) / 2 + 0.5,
|
|
5978
6116
|
0.3
|
|
5979
6117
|
);
|
|
5980
6118
|
const silkscreenLine = {
|
|
@@ -5983,20 +6121,20 @@ var sod110 = (raw_params) => {
|
|
|
5983
6121
|
pcb_component_id: "",
|
|
5984
6122
|
route: [
|
|
5985
6123
|
{
|
|
5986
|
-
x:
|
|
5987
|
-
y:
|
|
6124
|
+
x: length39.parse(parameters.p) / 2,
|
|
6125
|
+
y: length39.parse(parameters.h) / 2
|
|
5988
6126
|
},
|
|
5989
6127
|
{
|
|
5990
|
-
x: -
|
|
5991
|
-
y:
|
|
6128
|
+
x: -length39.parse(parameters.w) / 2,
|
|
6129
|
+
y: length39.parse(parameters.h) / 2
|
|
5992
6130
|
},
|
|
5993
6131
|
{
|
|
5994
|
-
x: -
|
|
5995
|
-
y: -
|
|
6132
|
+
x: -length39.parse(parameters.w) / 2,
|
|
6133
|
+
y: -length39.parse(parameters.h) / 2
|
|
5996
6134
|
},
|
|
5997
6135
|
{
|
|
5998
|
-
x:
|
|
5999
|
-
y: -
|
|
6136
|
+
x: length39.parse(parameters.p) / 2,
|
|
6137
|
+
y: -length39.parse(parameters.h) / 2
|
|
6000
6138
|
}
|
|
6001
6139
|
],
|
|
6002
6140
|
stroke_width: 0.1,
|
|
@@ -6038,8 +6176,8 @@ var sodWithoutParsing13 = (parameters) => {
|
|
|
6038
6176
|
};
|
|
6039
6177
|
|
|
6040
6178
|
// src/fn/vssop.ts
|
|
6041
|
-
import { z as
|
|
6042
|
-
import { length as
|
|
6179
|
+
import { z as z53 } from "zod";
|
|
6180
|
+
import { length as length40 } from "circuit-json";
|
|
6043
6181
|
var getDefaultValues = (num_pins) => {
|
|
6044
6182
|
switch (num_pins) {
|
|
6045
6183
|
case 8:
|
|
@@ -6069,23 +6207,23 @@ var getDefaultValues = (num_pins) => {
|
|
|
6069
6207
|
}
|
|
6070
6208
|
};
|
|
6071
6209
|
var vssop_def = base_def.extend({
|
|
6072
|
-
fn:
|
|
6073
|
-
num_pins:
|
|
6074
|
-
w:
|
|
6075
|
-
h:
|
|
6076
|
-
p:
|
|
6077
|
-
pl:
|
|
6078
|
-
pw:
|
|
6079
|
-
string:
|
|
6210
|
+
fn: z53.string(),
|
|
6211
|
+
num_pins: z53.union([z53.literal(8), z53.literal(10)]).default(8),
|
|
6212
|
+
w: z53.string().optional(),
|
|
6213
|
+
h: z53.string().optional(),
|
|
6214
|
+
p: z53.string().optional(),
|
|
6215
|
+
pl: z53.string().optional(),
|
|
6216
|
+
pw: z53.string().optional(),
|
|
6217
|
+
string: z53.string().optional()
|
|
6080
6218
|
});
|
|
6081
6219
|
var vssop = (raw_params) => {
|
|
6082
6220
|
const parameters = vssop_def.parse(raw_params);
|
|
6083
6221
|
const defaults = getDefaultValues(parameters.num_pins);
|
|
6084
|
-
const w =
|
|
6085
|
-
const h =
|
|
6086
|
-
const p =
|
|
6087
|
-
const pl =
|
|
6088
|
-
const pw =
|
|
6222
|
+
const w = length40.parse(parameters.w || defaults.w);
|
|
6223
|
+
const h = length40.parse(parameters.h || defaults.h);
|
|
6224
|
+
const p = length40.parse(parameters.p || defaults.p);
|
|
6225
|
+
const pl = length40.parse(parameters.pl || defaults.pl);
|
|
6226
|
+
const pw = length40.parse(parameters.pw || defaults.pw);
|
|
6089
6227
|
const pads = [];
|
|
6090
6228
|
const half = parameters.num_pins / 2;
|
|
6091
6229
|
for (let i = 0; i < parameters.num_pins; i++) {
|
|
@@ -6162,14 +6300,14 @@ var getVssopPadCoord = (pinCount, pn, w, p) => {
|
|
|
6162
6300
|
const col = pn <= half ? -1 : 1;
|
|
6163
6301
|
const row = (half - 1) / 2 - rowIndex;
|
|
6164
6302
|
return {
|
|
6165
|
-
x: col *
|
|
6303
|
+
x: col * length40.parse(pinCount === 8 ? "1.8mm" : "2.2mm"),
|
|
6166
6304
|
y: row * p
|
|
6167
6305
|
};
|
|
6168
6306
|
};
|
|
6169
6307
|
|
|
6170
6308
|
// src/fn/msop.ts
|
|
6171
|
-
import { z as
|
|
6172
|
-
import { length as
|
|
6309
|
+
import { z as z54 } from "zod";
|
|
6310
|
+
import { length as length41 } from "circuit-json";
|
|
6173
6311
|
var getDefaultValues2 = (num_pins) => {
|
|
6174
6312
|
switch (num_pins) {
|
|
6175
6313
|
case 10:
|
|
@@ -6207,14 +6345,14 @@ var getDefaultValues2 = (num_pins) => {
|
|
|
6207
6345
|
}
|
|
6208
6346
|
};
|
|
6209
6347
|
var msop_def = base_def.extend({
|
|
6210
|
-
fn:
|
|
6211
|
-
num_pins:
|
|
6212
|
-
w:
|
|
6213
|
-
h:
|
|
6214
|
-
p:
|
|
6215
|
-
pl:
|
|
6216
|
-
pw:
|
|
6217
|
-
string:
|
|
6348
|
+
fn: z54.string(),
|
|
6349
|
+
num_pins: z54.union([z54.literal(8), z54.literal(10), z54.literal(12), z54.literal(16)]).default(8),
|
|
6350
|
+
w: z54.string().optional(),
|
|
6351
|
+
h: z54.string().optional(),
|
|
6352
|
+
p: z54.string().optional(),
|
|
6353
|
+
pl: z54.string().optional(),
|
|
6354
|
+
pw: z54.string().optional(),
|
|
6355
|
+
string: z54.string().optional()
|
|
6218
6356
|
});
|
|
6219
6357
|
var getMsopCoords = (pinCount, pn, w, p) => {
|
|
6220
6358
|
const half = pinCount / 2;
|
|
@@ -6222,18 +6360,18 @@ var getMsopCoords = (pinCount, pn, w, p) => {
|
|
|
6222
6360
|
const col = pn <= half ? -1 : 1;
|
|
6223
6361
|
const row = (half - 1) / 2 - rowIndex;
|
|
6224
6362
|
return {
|
|
6225
|
-
x: col *
|
|
6363
|
+
x: col * length41.parse("2mm"),
|
|
6226
6364
|
y: row * p
|
|
6227
6365
|
};
|
|
6228
6366
|
};
|
|
6229
6367
|
var msop = (raw_params) => {
|
|
6230
6368
|
const parameters = msop_def.parse(raw_params);
|
|
6231
6369
|
const defaults = getDefaultValues2(parameters.num_pins);
|
|
6232
|
-
const w =
|
|
6233
|
-
const h =
|
|
6234
|
-
const p =
|
|
6235
|
-
const pl =
|
|
6236
|
-
const pw =
|
|
6370
|
+
const w = length41.parse(parameters.w || defaults.w);
|
|
6371
|
+
const h = length41.parse(parameters.h || defaults.h);
|
|
6372
|
+
const p = length41.parse(parameters.p || defaults.p);
|
|
6373
|
+
const pl = length41.parse(parameters.pl || defaults.pl);
|
|
6374
|
+
const pw = length41.parse(parameters.pw || defaults.pw);
|
|
6237
6375
|
const pads = [];
|
|
6238
6376
|
for (let i = 0; i < parameters.num_pins; i++) {
|
|
6239
6377
|
const { x, y } = getMsopCoords(parameters.num_pins, i + 1, w, p);
|
|
@@ -6304,22 +6442,22 @@ var msop = (raw_params) => {
|
|
|
6304
6442
|
};
|
|
6305
6443
|
|
|
6306
6444
|
// src/fn/sod323w.ts
|
|
6307
|
-
import { z as
|
|
6308
|
-
import { length as
|
|
6445
|
+
import { z as z55 } from "zod";
|
|
6446
|
+
import { length as length42 } from "circuit-json";
|
|
6309
6447
|
var sod323w_def = base_def.extend({
|
|
6310
|
-
fn:
|
|
6311
|
-
num_pins:
|
|
6312
|
-
w:
|
|
6313
|
-
h:
|
|
6314
|
-
pl:
|
|
6315
|
-
pw:
|
|
6316
|
-
pad_spacing:
|
|
6448
|
+
fn: z55.string(),
|
|
6449
|
+
num_pins: z55.literal(2).default(2),
|
|
6450
|
+
w: z55.string().default("3.8mm"),
|
|
6451
|
+
h: z55.string().default("1.65mm"),
|
|
6452
|
+
pl: z55.string().default("1.2mm"),
|
|
6453
|
+
pw: z55.string().default("1.2mm"),
|
|
6454
|
+
pad_spacing: z55.string().default("2.6mm")
|
|
6317
6455
|
});
|
|
6318
6456
|
var sod323w = (raw_params) => {
|
|
6319
6457
|
const parameters = sod323w_def.parse(raw_params);
|
|
6320
6458
|
const silkscreenRefText = silkscreenRef(
|
|
6321
6459
|
0,
|
|
6322
|
-
|
|
6460
|
+
length42.parse(parameters.h),
|
|
6323
6461
|
0.3
|
|
6324
6462
|
);
|
|
6325
6463
|
const silkscreenLine = {
|
|
@@ -6328,20 +6466,20 @@ var sod323w = (raw_params) => {
|
|
|
6328
6466
|
pcb_component_id: "",
|
|
6329
6467
|
route: [
|
|
6330
6468
|
{
|
|
6331
|
-
x:
|
|
6332
|
-
y:
|
|
6469
|
+
x: length42.parse(parameters.pad_spacing) / 2,
|
|
6470
|
+
y: length42.parse(parameters.h) / 2
|
|
6333
6471
|
},
|
|
6334
6472
|
{
|
|
6335
|
-
x: -
|
|
6336
|
-
y:
|
|
6473
|
+
x: -length42.parse(parameters.w) / 2 - 0.2,
|
|
6474
|
+
y: length42.parse(parameters.h) / 2
|
|
6337
6475
|
},
|
|
6338
6476
|
{
|
|
6339
|
-
x: -
|
|
6340
|
-
y: -
|
|
6477
|
+
x: -length42.parse(parameters.w) / 2 - 0.2,
|
|
6478
|
+
y: -length42.parse(parameters.h) / 2
|
|
6341
6479
|
},
|
|
6342
6480
|
{
|
|
6343
|
-
x:
|
|
6344
|
-
y: -
|
|
6481
|
+
x: length42.parse(parameters.pad_spacing) / 2,
|
|
6482
|
+
y: -length42.parse(parameters.h) / 2
|
|
6345
6483
|
}
|
|
6346
6484
|
],
|
|
6347
6485
|
stroke_width: 0.1,
|
|
@@ -6384,22 +6522,22 @@ var sodWithoutParsing14 = (parameters) => {
|
|
|
6384
6522
|
};
|
|
6385
6523
|
|
|
6386
6524
|
// src/fn/sod323fl.ts
|
|
6387
|
-
import { z as
|
|
6388
|
-
import { length as
|
|
6525
|
+
import { z as z56 } from "zod";
|
|
6526
|
+
import { length as length43 } from "circuit-json";
|
|
6389
6527
|
var sod323FL_def = base_def.extend({
|
|
6390
|
-
fn:
|
|
6391
|
-
num_pins:
|
|
6392
|
-
w:
|
|
6393
|
-
h:
|
|
6394
|
-
pl:
|
|
6395
|
-
pw:
|
|
6396
|
-
pad_spacing:
|
|
6528
|
+
fn: z56.string(),
|
|
6529
|
+
num_pins: z56.literal(2).default(2),
|
|
6530
|
+
w: z56.string().default("3.20mm"),
|
|
6531
|
+
h: z56.string().default("1.65mm"),
|
|
6532
|
+
pl: z56.string().default("0.8mm"),
|
|
6533
|
+
pw: z56.string().default("0.9mm"),
|
|
6534
|
+
pad_spacing: z56.string().default("2.1mm")
|
|
6397
6535
|
});
|
|
6398
6536
|
var sod323fl = (raw_params) => {
|
|
6399
6537
|
const parameters = sod323FL_def.parse(raw_params);
|
|
6400
6538
|
const silkscreenRefText = silkscreenRef(
|
|
6401
6539
|
0,
|
|
6402
|
-
|
|
6540
|
+
length43.parse(parameters.h),
|
|
6403
6541
|
0.3
|
|
6404
6542
|
);
|
|
6405
6543
|
const silkscreenLine = {
|
|
@@ -6408,20 +6546,20 @@ var sod323fl = (raw_params) => {
|
|
|
6408
6546
|
pcb_component_id: "",
|
|
6409
6547
|
route: [
|
|
6410
6548
|
{
|
|
6411
|
-
x:
|
|
6412
|
-
y:
|
|
6549
|
+
x: length43.parse(parameters.pad_spacing) / 2,
|
|
6550
|
+
y: length43.parse(parameters.h) / 2
|
|
6413
6551
|
},
|
|
6414
6552
|
{
|
|
6415
|
-
x: -
|
|
6416
|
-
y:
|
|
6553
|
+
x: -length43.parse(parameters.w) / 2 - 0.2,
|
|
6554
|
+
y: length43.parse(parameters.h) / 2
|
|
6417
6555
|
},
|
|
6418
6556
|
{
|
|
6419
|
-
x: -
|
|
6420
|
-
y: -
|
|
6557
|
+
x: -length43.parse(parameters.w) / 2 - 0.2,
|
|
6558
|
+
y: -length43.parse(parameters.h) / 2
|
|
6421
6559
|
},
|
|
6422
6560
|
{
|
|
6423
|
-
x:
|
|
6424
|
-
y: -
|
|
6561
|
+
x: length43.parse(parameters.pad_spacing) / 2,
|
|
6562
|
+
y: -length43.parse(parameters.h) / 2
|
|
6425
6563
|
}
|
|
6426
6564
|
],
|
|
6427
6565
|
stroke_width: 0.1,
|
|
@@ -6464,20 +6602,20 @@ var sodWithoutParsing15 = (parameters) => {
|
|
|
6464
6602
|
};
|
|
6465
6603
|
|
|
6466
6604
|
// src/fn/son.ts
|
|
6467
|
-
import { z as
|
|
6468
|
-
import { length as
|
|
6605
|
+
import { z as z57 } from "zod";
|
|
6606
|
+
import { length as length44 } from "circuit-json";
|
|
6469
6607
|
var son_def = base_def.extend({
|
|
6470
|
-
fn:
|
|
6471
|
-
num_pins:
|
|
6472
|
-
w:
|
|
6473
|
-
h:
|
|
6474
|
-
p:
|
|
6475
|
-
pl:
|
|
6476
|
-
pw:
|
|
6477
|
-
epw:
|
|
6478
|
-
eph:
|
|
6479
|
-
string:
|
|
6480
|
-
ep:
|
|
6608
|
+
fn: z57.string(),
|
|
6609
|
+
num_pins: z57.union([z57.literal(6), z57.literal(8)]).default(8),
|
|
6610
|
+
w: z57.string().default("3mm"),
|
|
6611
|
+
h: z57.string().default("3mm"),
|
|
6612
|
+
p: z57.string().default("0.5mm"),
|
|
6613
|
+
pl: z57.string().default("0.52mm"),
|
|
6614
|
+
pw: z57.string().default("0.35mm"),
|
|
6615
|
+
epw: z57.string().default("1.40mm"),
|
|
6616
|
+
eph: z57.string().default("1.60mm"),
|
|
6617
|
+
string: z57.string().optional(),
|
|
6618
|
+
ep: z57.boolean().default(false)
|
|
6481
6619
|
});
|
|
6482
6620
|
var son = (raw_params) => {
|
|
6483
6621
|
if (raw_params.string && raw_params.string.includes("_ep")) {
|
|
@@ -6489,13 +6627,13 @@ var son = (raw_params) => {
|
|
|
6489
6627
|
...raw_params,
|
|
6490
6628
|
num_pins: numPins
|
|
6491
6629
|
});
|
|
6492
|
-
const w =
|
|
6493
|
-
const h =
|
|
6494
|
-
const p =
|
|
6495
|
-
const pl =
|
|
6496
|
-
const pw =
|
|
6497
|
-
const epw =
|
|
6498
|
-
const eph =
|
|
6630
|
+
const w = length44.parse(parameters.w);
|
|
6631
|
+
const h = length44.parse(parameters.h);
|
|
6632
|
+
const p = length44.parse(parameters.p);
|
|
6633
|
+
const pl = length44.parse(parameters.pl);
|
|
6634
|
+
const pw = length44.parse(parameters.pw);
|
|
6635
|
+
const epw = length44.parse(parameters.epw);
|
|
6636
|
+
const eph = length44.parse(parameters.eph);
|
|
6499
6637
|
const pads = [];
|
|
6500
6638
|
for (let i = 0; i < parameters.num_pins; i++) {
|
|
6501
6639
|
const { x, y } = getSonPadCoord(parameters.num_pins, i + 1, w, p);
|
|
@@ -6573,18 +6711,18 @@ var getSonPadCoord = (num_pins, pn, w, p) => {
|
|
|
6573
6711
|
const col = pn <= half ? -1 : 1;
|
|
6574
6712
|
const row = (half - 1) / 2 - rowIndex;
|
|
6575
6713
|
return {
|
|
6576
|
-
x: col *
|
|
6714
|
+
x: col * length44.parse("1.4mm"),
|
|
6577
6715
|
y: row * p
|
|
6578
6716
|
};
|
|
6579
6717
|
};
|
|
6580
6718
|
|
|
6581
6719
|
// src/fn/solderjumper.ts
|
|
6582
|
-
import { length as
|
|
6720
|
+
import { length as length45 } from "circuit-json";
|
|
6583
6721
|
var solderjumper = (params) => {
|
|
6584
6722
|
const { num_pins, bridged, p = 2.54, pw = 1.5, ph = 1.5 } = params;
|
|
6585
|
-
const padSpacing =
|
|
6586
|
-
const padWidth =
|
|
6587
|
-
const padHeight =
|
|
6723
|
+
const padSpacing = length45.parse(p);
|
|
6724
|
+
const padWidth = length45.parse(pw);
|
|
6725
|
+
const padHeight = length45.parse(ph);
|
|
6588
6726
|
const traceWidth = Math.min(padHeight / 4, 0.5);
|
|
6589
6727
|
const pads = [];
|
|
6590
6728
|
for (let i = 0; i < num_pins; i++) {
|
|
@@ -6672,34 +6810,34 @@ var solderjumper = (params) => {
|
|
|
6672
6810
|
};
|
|
6673
6811
|
|
|
6674
6812
|
// src/fn/sot457.ts
|
|
6675
|
-
import { z as
|
|
6813
|
+
import { z as z58 } from "zod";
|
|
6676
6814
|
var commonSchema = {
|
|
6677
|
-
fn:
|
|
6678
|
-
num_pins:
|
|
6679
|
-
pillh:
|
|
6680
|
-
pillw:
|
|
6681
|
-
pl:
|
|
6682
|
-
pw:
|
|
6683
|
-
p:
|
|
6684
|
-
wave:
|
|
6685
|
-
reflow:
|
|
6815
|
+
fn: z58.literal("sot457"),
|
|
6816
|
+
num_pins: z58.literal(6).default(6),
|
|
6817
|
+
pillh: z58.string().default("0.45mm"),
|
|
6818
|
+
pillw: z58.string().default("1.45mm"),
|
|
6819
|
+
pl: z58.string(),
|
|
6820
|
+
pw: z58.string(),
|
|
6821
|
+
p: z58.string(),
|
|
6822
|
+
wave: z58.boolean().optional(),
|
|
6823
|
+
reflow: z58.boolean().optional()
|
|
6686
6824
|
};
|
|
6687
6825
|
var sot457DefSchema = base_def.extend({
|
|
6688
6826
|
...commonSchema,
|
|
6689
|
-
h:
|
|
6690
|
-
w:
|
|
6691
|
-
pl:
|
|
6692
|
-
pw:
|
|
6693
|
-
p:
|
|
6827
|
+
h: z58.string().default("2.5mm"),
|
|
6828
|
+
w: z58.string().default("2.7mm"),
|
|
6829
|
+
pl: z58.string().default("0.8mm"),
|
|
6830
|
+
pw: z58.string().default("0.55mm"),
|
|
6831
|
+
p: z58.string().default("0.95mm")
|
|
6694
6832
|
});
|
|
6695
6833
|
var sot457WaveSchema = base_def.extend({
|
|
6696
6834
|
...commonSchema,
|
|
6697
|
-
h:
|
|
6698
|
-
w:
|
|
6699
|
-
pillr:
|
|
6700
|
-
pl:
|
|
6701
|
-
pw:
|
|
6702
|
-
p:
|
|
6835
|
+
h: z58.string().default("3mm"),
|
|
6836
|
+
w: z58.string().default("4mm"),
|
|
6837
|
+
pillr: z58.string().default("0.225mm"),
|
|
6838
|
+
pl: z58.string().default("1.45mm"),
|
|
6839
|
+
pw: z58.string().default("1.5mm"),
|
|
6840
|
+
p: z58.string().default("1.475mm")
|
|
6703
6841
|
}).transform((data) => ({
|
|
6704
6842
|
...data,
|
|
6705
6843
|
wave: data.wave ?? (data.reflow === void 0 ? true : !data.reflow),
|
|
@@ -6838,25 +6976,25 @@ var sot457 = (rawParams) => {
|
|
|
6838
6976
|
};
|
|
6839
6977
|
|
|
6840
6978
|
// src/fn/sot963.ts
|
|
6841
|
-
import { z as
|
|
6842
|
-
import { length as
|
|
6979
|
+
import { z as z59 } from "zod";
|
|
6980
|
+
import { length as length46 } from "circuit-json";
|
|
6843
6981
|
var sot963_def = base_def.extend({
|
|
6844
|
-
fn:
|
|
6845
|
-
num_pins:
|
|
6846
|
-
w:
|
|
6847
|
-
h:
|
|
6848
|
-
p:
|
|
6849
|
-
pl:
|
|
6850
|
-
pw:
|
|
6851
|
-
string:
|
|
6982
|
+
fn: z59.string(),
|
|
6983
|
+
num_pins: z59.literal(6).default(6),
|
|
6984
|
+
w: z59.string().default("1.1mm"),
|
|
6985
|
+
h: z59.string().default("1.45mm"),
|
|
6986
|
+
p: z59.string().default("0.35mm"),
|
|
6987
|
+
pl: z59.string().default("0.2mm"),
|
|
6988
|
+
pw: z59.string().default("0.2mm"),
|
|
6989
|
+
string: z59.string().optional()
|
|
6852
6990
|
});
|
|
6853
6991
|
var sot963 = (raw_params) => {
|
|
6854
6992
|
const parameters = sot963_def.parse({ ...raw_params, fn: "sot963" });
|
|
6855
|
-
const w =
|
|
6856
|
-
const h =
|
|
6857
|
-
const p =
|
|
6858
|
-
const pl =
|
|
6859
|
-
const pw =
|
|
6993
|
+
const w = length46.parse(parameters.w);
|
|
6994
|
+
const h = length46.parse(parameters.h);
|
|
6995
|
+
const p = length46.parse(parameters.p);
|
|
6996
|
+
const pl = length46.parse(parameters.pl);
|
|
6997
|
+
const pw = length46.parse(parameters.pw);
|
|
6860
6998
|
const pads = [];
|
|
6861
6999
|
for (let i = 0; i < 6; i++) {
|
|
6862
7000
|
const { x, y } = getSot963PadCoord(i + 1, w, p, pl);
|
|
@@ -6919,19 +7057,19 @@ var getSot963PadCoord = (pn, w, p, pl) => {
|
|
|
6919
7057
|
};
|
|
6920
7058
|
|
|
6921
7059
|
// src/fn/potentiometer.ts
|
|
6922
|
-
import { z as
|
|
7060
|
+
import { z as z60 } from "zod";
|
|
6923
7061
|
var potentiometer_def = base_def.extend({
|
|
6924
|
-
fn:
|
|
6925
|
-
num_pins:
|
|
6926
|
-
p:
|
|
6927
|
-
id:
|
|
6928
|
-
od:
|
|
6929
|
-
ca:
|
|
7062
|
+
fn: z60.string(),
|
|
7063
|
+
num_pins: z60.union([z60.literal(3), z60.literal(2)]).default(3),
|
|
7064
|
+
p: z60.string().default("3.8mm"),
|
|
7065
|
+
id: z60.string().default("1.25mm"),
|
|
7066
|
+
od: z60.string().default("2.35mm"),
|
|
7067
|
+
ca: z60.string().default("14mm").describe(
|
|
6930
7068
|
"Caliper axis (width or diameter of the potentiometer body or adjustment knob)"
|
|
6931
7069
|
),
|
|
6932
|
-
w:
|
|
6933
|
-
h:
|
|
6934
|
-
string:
|
|
7070
|
+
w: z60.string().default("5.35mm"),
|
|
7071
|
+
h: z60.string().default("4mm"),
|
|
7072
|
+
string: z60.string().optional()
|
|
6935
7073
|
});
|
|
6936
7074
|
var potentiometer_acp = (parameters) => {
|
|
6937
7075
|
const { p, id, od, h, ca } = parameters;
|
|
@@ -6998,15 +7136,15 @@ var potentiometer = (raw_params) => {
|
|
|
6998
7136
|
|
|
6999
7137
|
// src/fn/electrolytic.ts
|
|
7000
7138
|
import {
|
|
7001
|
-
length as
|
|
7139
|
+
length as length47
|
|
7002
7140
|
} from "circuit-json";
|
|
7003
|
-
import { z as
|
|
7141
|
+
import { z as z61 } from "zod";
|
|
7004
7142
|
var electrolytic_def = base_def.extend({
|
|
7005
|
-
fn:
|
|
7006
|
-
p:
|
|
7007
|
-
id:
|
|
7008
|
-
od:
|
|
7009
|
-
d:
|
|
7143
|
+
fn: z61.string(),
|
|
7144
|
+
p: length47.optional().default("7.5mm"),
|
|
7145
|
+
id: length47.optional().default("1mm"),
|
|
7146
|
+
od: length47.optional().default("2mm"),
|
|
7147
|
+
d: length47.optional().default("10.5mm")
|
|
7010
7148
|
});
|
|
7011
7149
|
var generate_circle_arcs = (centerX, centerY, radius, cut, cutHeight) => {
|
|
7012
7150
|
const topArc = [];
|
|
@@ -7113,22 +7251,22 @@ var electrolytic = (raw_params) => {
|
|
|
7113
7251
|
};
|
|
7114
7252
|
|
|
7115
7253
|
// src/fn/smbf.ts
|
|
7116
|
-
import { z as
|
|
7117
|
-
import { length as
|
|
7254
|
+
import { z as z62 } from "zod";
|
|
7255
|
+
import { length as length48 } from "circuit-json";
|
|
7118
7256
|
var smbf_def = base_def.extend({
|
|
7119
|
-
fn:
|
|
7120
|
-
num_pins:
|
|
7121
|
-
w:
|
|
7122
|
-
h:
|
|
7123
|
-
pl:
|
|
7124
|
-
pw:
|
|
7125
|
-
p:
|
|
7257
|
+
fn: z62.string(),
|
|
7258
|
+
num_pins: z62.literal(2).default(2),
|
|
7259
|
+
w: z62.string().default("6.5mm"),
|
|
7260
|
+
h: z62.string().default("3mm"),
|
|
7261
|
+
pl: z62.string().default("1.75mm"),
|
|
7262
|
+
pw: z62.string().default("2.40mm"),
|
|
7263
|
+
p: z62.string().default("4.75mm")
|
|
7126
7264
|
});
|
|
7127
7265
|
var smbf = (raw_params) => {
|
|
7128
7266
|
const parameters = smbf_def.parse(raw_params);
|
|
7129
7267
|
const silkscreenRefText = silkscreenRef(
|
|
7130
7268
|
0,
|
|
7131
|
-
|
|
7269
|
+
length48.parse(parameters.h) - 0.5,
|
|
7132
7270
|
0.3
|
|
7133
7271
|
);
|
|
7134
7272
|
const silkscreenLine = {
|
|
@@ -7137,20 +7275,20 @@ var smbf = (raw_params) => {
|
|
|
7137
7275
|
pcb_component_id: "",
|
|
7138
7276
|
route: [
|
|
7139
7277
|
{
|
|
7140
|
-
x:
|
|
7141
|
-
y:
|
|
7278
|
+
x: length48.parse(parameters.p) / 2,
|
|
7279
|
+
y: length48.parse(parameters.h) / 2
|
|
7142
7280
|
},
|
|
7143
7281
|
{
|
|
7144
|
-
x: -
|
|
7145
|
-
y:
|
|
7282
|
+
x: -length48.parse(parameters.w) / 2 - 0.3,
|
|
7283
|
+
y: length48.parse(parameters.h) / 2
|
|
7146
7284
|
},
|
|
7147
7285
|
{
|
|
7148
|
-
x: -
|
|
7149
|
-
y: -
|
|
7286
|
+
x: -length48.parse(parameters.w) / 2 - 0.3,
|
|
7287
|
+
y: -length48.parse(parameters.h) / 2
|
|
7150
7288
|
},
|
|
7151
7289
|
{
|
|
7152
|
-
x:
|
|
7153
|
-
y: -
|
|
7290
|
+
x: length48.parse(parameters.p) / 2,
|
|
7291
|
+
y: -length48.parse(parameters.h) / 2
|
|
7154
7292
|
}
|
|
7155
7293
|
],
|
|
7156
7294
|
stroke_width: 0.1,
|
|
@@ -7192,16 +7330,16 @@ var smbfWithoutParsing = (parameters) => {
|
|
|
7192
7330
|
};
|
|
7193
7331
|
|
|
7194
7332
|
// src/fn/sot323.ts
|
|
7195
|
-
import { z as
|
|
7333
|
+
import { z as z63 } from "zod";
|
|
7196
7334
|
var sot323_def = base_def.extend({
|
|
7197
|
-
fn:
|
|
7198
|
-
num_pins:
|
|
7199
|
-
w:
|
|
7200
|
-
h:
|
|
7201
|
-
pl:
|
|
7202
|
-
pw:
|
|
7203
|
-
p:
|
|
7204
|
-
string:
|
|
7335
|
+
fn: z63.string(),
|
|
7336
|
+
num_pins: z63.number().default(3),
|
|
7337
|
+
w: z63.string().default("2.45mm"),
|
|
7338
|
+
h: z63.string().default("2.40mm"),
|
|
7339
|
+
pl: z63.string().default("1.225mm"),
|
|
7340
|
+
pw: z63.string().default("0.5mm"),
|
|
7341
|
+
p: z63.string().default("0.95mm"),
|
|
7342
|
+
string: z63.string().optional()
|
|
7205
7343
|
});
|
|
7206
7344
|
var sot323 = (raw_params) => {
|
|
7207
7345
|
const match = raw_params.string?.match(/^sot323_(\d+)/);
|
|
@@ -7289,30 +7427,30 @@ var sot323_3 = (parameters) => {
|
|
|
7289
7427
|
};
|
|
7290
7428
|
|
|
7291
7429
|
// src/fn/smtpad.ts
|
|
7292
|
-
import { z as
|
|
7293
|
-
import { length as
|
|
7430
|
+
import { z as z64 } from "zod";
|
|
7431
|
+
import { length as length49 } from "circuit-json";
|
|
7294
7432
|
import { mm as mm8 } from "@tscircuit/mm";
|
|
7295
7433
|
var smtpad_def = base_def.extend({
|
|
7296
|
-
fn:
|
|
7297
|
-
circle:
|
|
7298
|
-
rect:
|
|
7299
|
-
square:
|
|
7300
|
-
pill:
|
|
7301
|
-
d:
|
|
7302
|
-
pd:
|
|
7303
|
-
diameter:
|
|
7304
|
-
r:
|
|
7305
|
-
pr:
|
|
7306
|
-
radius:
|
|
7307
|
-
w:
|
|
7308
|
-
pw:
|
|
7309
|
-
width:
|
|
7310
|
-
h:
|
|
7311
|
-
ph:
|
|
7312
|
-
height:
|
|
7313
|
-
s:
|
|
7314
|
-
size:
|
|
7315
|
-
string:
|
|
7434
|
+
fn: z64.string(),
|
|
7435
|
+
circle: z64.boolean().optional(),
|
|
7436
|
+
rect: z64.boolean().optional(),
|
|
7437
|
+
square: z64.boolean().optional(),
|
|
7438
|
+
pill: z64.boolean().optional(),
|
|
7439
|
+
d: length49.optional(),
|
|
7440
|
+
pd: length49.optional(),
|
|
7441
|
+
diameter: length49.optional(),
|
|
7442
|
+
r: length49.optional(),
|
|
7443
|
+
pr: length49.optional(),
|
|
7444
|
+
radius: length49.optional(),
|
|
7445
|
+
w: length49.optional(),
|
|
7446
|
+
pw: length49.optional(),
|
|
7447
|
+
width: length49.optional(),
|
|
7448
|
+
h: length49.optional(),
|
|
7449
|
+
ph: length49.optional(),
|
|
7450
|
+
height: length49.optional(),
|
|
7451
|
+
s: length49.optional(),
|
|
7452
|
+
size: length49.optional(),
|
|
7453
|
+
string: z64.string().optional()
|
|
7316
7454
|
}).transform((v) => {
|
|
7317
7455
|
let shape = "rect";
|
|
7318
7456
|
if (v.circle) shape = "circle";
|
|
@@ -7378,18 +7516,18 @@ var smtpad = (raw_params) => {
|
|
|
7378
7516
|
};
|
|
7379
7517
|
|
|
7380
7518
|
// src/fn/platedhole.ts
|
|
7381
|
-
import { z as
|
|
7382
|
-
import { length as
|
|
7519
|
+
import { z as z65 } from "zod";
|
|
7520
|
+
import { length as length50 } from "circuit-json";
|
|
7383
7521
|
import { mm as mm9 } from "@tscircuit/mm";
|
|
7384
7522
|
var platedhole_def = base_def.extend({
|
|
7385
|
-
fn:
|
|
7386
|
-
d:
|
|
7387
|
-
hd:
|
|
7388
|
-
r:
|
|
7389
|
-
hr:
|
|
7390
|
-
pd:
|
|
7391
|
-
pr:
|
|
7392
|
-
squarepad:
|
|
7523
|
+
fn: z65.string(),
|
|
7524
|
+
d: length50.optional(),
|
|
7525
|
+
hd: length50.optional(),
|
|
7526
|
+
r: length50.optional(),
|
|
7527
|
+
hr: length50.optional(),
|
|
7528
|
+
pd: length50.optional(),
|
|
7529
|
+
pr: length50.optional(),
|
|
7530
|
+
squarepad: z65.boolean().optional().default(false)
|
|
7393
7531
|
}).transform((v) => {
|
|
7394
7532
|
let holeD;
|
|
7395
7533
|
if (v.d !== void 0) holeD = mm9(v.d);
|
|
@@ -7421,14 +7559,14 @@ var platedhole2 = (raw_params) => {
|
|
|
7421
7559
|
};
|
|
7422
7560
|
|
|
7423
7561
|
// src/fn/sot.ts
|
|
7424
|
-
import { z as
|
|
7562
|
+
import { z as z66 } from "zod";
|
|
7425
7563
|
var sot_def = base_def.extend({
|
|
7426
|
-
fn:
|
|
7427
|
-
num_pins:
|
|
7428
|
-
h:
|
|
7429
|
-
pl:
|
|
7430
|
-
pw:
|
|
7431
|
-
p:
|
|
7564
|
+
fn: z66.string(),
|
|
7565
|
+
num_pins: z66.literal(6).default(6),
|
|
7566
|
+
h: z66.string().default("1.6mm"),
|
|
7567
|
+
pl: z66.string().default("1mm"),
|
|
7568
|
+
pw: z66.string().default("0.7mm"),
|
|
7569
|
+
p: z66.string().default("0.95mm")
|
|
7432
7570
|
});
|
|
7433
7571
|
var sot = (raw_params) => {
|
|
7434
7572
|
const parameters = sot_def.parse(raw_params);
|
|
@@ -7545,16 +7683,16 @@ var sotWithoutParsing = (parameters) => {
|
|
|
7545
7683
|
};
|
|
7546
7684
|
|
|
7547
7685
|
// src/fn/sot343.ts
|
|
7548
|
-
import { z as
|
|
7686
|
+
import { z as z67 } from "zod";
|
|
7549
7687
|
var sot343_def = base_def.extend({
|
|
7550
|
-
fn:
|
|
7551
|
-
num_pins:
|
|
7552
|
-
w:
|
|
7553
|
-
h:
|
|
7554
|
-
pl:
|
|
7555
|
-
pw:
|
|
7556
|
-
p:
|
|
7557
|
-
string:
|
|
7688
|
+
fn: z67.string(),
|
|
7689
|
+
num_pins: z67.number().default(4),
|
|
7690
|
+
w: z67.string().default("3.2mm"),
|
|
7691
|
+
h: z67.string().default("2.6mm"),
|
|
7692
|
+
pl: z67.string().default("1.35mm"),
|
|
7693
|
+
pw: z67.string().default("0.50mm"),
|
|
7694
|
+
p: z67.string().default("0.6mm"),
|
|
7695
|
+
string: z67.string().optional()
|
|
7558
7696
|
});
|
|
7559
7697
|
var sot343 = (raw_params) => {
|
|
7560
7698
|
const match = raw_params.string?.match(/^sot343_(\d+)/);
|
|
@@ -7649,9 +7787,9 @@ var sot343_4 = (parameters) => {
|
|
|
7649
7787
|
};
|
|
7650
7788
|
|
|
7651
7789
|
// src/fn/m2host.ts
|
|
7652
|
-
import { z as
|
|
7790
|
+
import { z as z68 } from "zod";
|
|
7653
7791
|
var m2host_def = base_def.extend({
|
|
7654
|
-
fn:
|
|
7792
|
+
fn: z68.string()
|
|
7655
7793
|
});
|
|
7656
7794
|
var m2host = (raw_params) => {
|
|
7657
7795
|
const parameters = m2host_def.parse(raw_params);
|
|
@@ -7754,16 +7892,16 @@ var m2host = (raw_params) => {
|
|
|
7754
7892
|
};
|
|
7755
7893
|
|
|
7756
7894
|
// src/fn/to92l.ts
|
|
7757
|
-
import { z as
|
|
7895
|
+
import { z as z69 } from "zod";
|
|
7758
7896
|
var to92l_def = base_def.extend({
|
|
7759
|
-
fn:
|
|
7760
|
-
num_pins:
|
|
7761
|
-
inline:
|
|
7762
|
-
p:
|
|
7763
|
-
id:
|
|
7764
|
-
od:
|
|
7765
|
-
w:
|
|
7766
|
-
h:
|
|
7897
|
+
fn: z69.string(),
|
|
7898
|
+
num_pins: z69.number().default(3),
|
|
7899
|
+
inline: z69.boolean().default(false),
|
|
7900
|
+
p: z69.string().default("1.27mm"),
|
|
7901
|
+
id: z69.string().default("0.75mm"),
|
|
7902
|
+
od: z69.string().default("1.3mm"),
|
|
7903
|
+
w: z69.string().default("4.8mm"),
|
|
7904
|
+
h: z69.string().default("4.0mm")
|
|
7767
7905
|
});
|
|
7768
7906
|
var to92l = (raw_params) => {
|
|
7769
7907
|
const parameters = to92l_def.parse(raw_params);
|