jscad-electronics 0.0.154 → 0.0.156

package/dist/vanilla.js

@@ -181,6 +181,7 @@ var ExtrudedPads = ({
 
 // lib/Footprinter3d.tsx
 import { fp as fp5 } from "@tscircuit/footprinter";
+import { mp } from "@tscircuit/modelprinter";
 
 // lib/ChipBody.tsx
 var ChipBody = ({
@@ -854,7 +855,6 @@ var PinHeader = ({
   bodyLength: bodyLength10 = 2.54,
   bodyWidth = 2.54,
   flipZ,
-  faceup,
   smd,
   rightangle
 }) => {
@@ -867,7 +867,7 @@ var PinHeader = ({
         center: [x, y, flipZ(bodyHeight / 2)]
       }
     ) }),
-    !faceup && /* @__PURE__ */ jsx(Colorize, { color: PIN_METAL_COLOR, children: smd ? /* @__PURE__ */ jsx(
+    /* @__PURE__ */ jsx(Colorize, { color: PIN_METAL_COLOR, children: smd ? /* @__PURE__ */ jsx(
       SmdChipLead,
       {
         rotation: -Math.PI / 2,
@@ -935,7 +935,6 @@ var PinRow = ({
   pitch = 2.54,
   longSidePinLength = 6,
   invert,
-  faceup,
   rows = 1,
   smd,
   rightangle
@@ -946,8 +945,9 @@ var PinRow = ({
   const rowSpacing = 2.54;
   const shortSidePinLength = 3;
   const xoff = -((pinsPerRow - 1) / 2) * pitch;
-  const zOffset = !smd && !rightangle ? -bodyHeight - 1.6 : 0;
-  const flipZ = (z) => (invert || faceup ? -z + bodyHeight : z) + zOffset;
+  const throughHole = !smd && !rightangle;
+  const flipped = throughHole ? !invert : Boolean(invert);
+  const flipZ = (z) => flipped ? -z + bodyHeight : z;
   return /* @__PURE__ */ jsx(Fragment2, { children: Array.from({ length: numberOfPins }, (_, i) => {
     const row = Math.floor(i / pinsPerRow);
     const col = i % pinsPerRow;
@@ -963,7 +963,6 @@ var PinRow = ({
         longSidePinLength,
         bodyHeight,
         flipZ,
-        faceup,
         smd,
         rightangle
       },
@@ -6459,8 +6458,559 @@ var BGA = ({
   ] });
 };
 
+// lib/FlexScreen.tsx
+var DEFAULT_ASPECT_RATIO = 16 / 9;
+var DEFAULT_DIAGONAL = 40;
+var EPSILON = 1e-6;
+var assertPositive = (name, value) => {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${name} must be a finite number greater than zero`);
+  }
+};
+var resolveAspectRatio = (value) => {
+  if (value === void 0) return DEFAULT_ASPECT_RATIO;
+  if (typeof value === "number") {
+    assertPositive("aspectRatio", value);
+    return value;
+  }
+  if (typeof value !== "string") {
+    const [ratioWidth2, ratioHeight2] = value;
+    assertPositive("aspectRatio width", ratioWidth2);
+    assertPositive("aspectRatio height", ratioHeight2);
+    return ratioWidth2 / ratioHeight2;
+  }
+  const parts = value.split(":");
+  if (parts.length !== 2) {
+    throw new Error('aspectRatio must look like "16:9"');
+  }
+  const ratioWidth = Number(parts[0]);
+  const ratioHeight = Number(parts[1]);
+  assertPositive("aspectRatio width", ratioWidth);
+  assertPositive("aspectRatio height", ratioHeight);
+  return ratioWidth / ratioHeight;
+};
+var resolveFlexScreenSize = ({
+  width: width10,
+  height: height10,
+  diagonal,
+  aspectRatio,
+  ratio,
+  defaultDiagonal = DEFAULT_DIAGONAL
+}) => {
+  const resolvedRatio = resolveAspectRatio(aspectRatio ?? ratio);
+  if (width10 !== void 0) assertPositive("width", width10);
+  if (height10 !== void 0) assertPositive("height", height10);
+  if (diagonal !== void 0) assertPositive("diagonal", diagonal);
+  assertPositive("defaultDiagonal", defaultDiagonal);
+  let resolvedWidth;
+  let resolvedHeight;
+  if (width10 !== void 0 && height10 !== void 0) {
+    resolvedWidth = width10;
+    resolvedHeight = height10;
+  } else if (diagonal !== void 0 && width10 !== void 0) {
+    if (width10 >= diagonal) {
+      throw new Error("width must be smaller than diagonal");
+    }
+    resolvedWidth = width10;
+    resolvedHeight = Math.sqrt(diagonal ** 2 - width10 ** 2);
+  } else if (diagonal !== void 0 && height10 !== void 0) {
+    if (height10 >= diagonal) {
+      throw new Error("height must be smaller than diagonal");
+    }
+    resolvedWidth = Math.sqrt(diagonal ** 2 - height10 ** 2);
+    resolvedHeight = height10;
+  } else if (width10 !== void 0) {
+    resolvedWidth = width10;
+    resolvedHeight = width10 / resolvedRatio;
+  } else if (height10 !== void 0) {
+    resolvedWidth = height10 * resolvedRatio;
+    resolvedHeight = height10;
+  } else {
+    const resolvedDiagonal = diagonal ?? defaultDiagonal;
+    resolvedHeight = resolvedDiagonal / Math.sqrt(resolvedRatio ** 2 + 1);
+    resolvedWidth = resolvedHeight * resolvedRatio;
+  }
+  return {
+    width: resolvedWidth,
+    height: resolvedHeight,
+    diagonal: Math.hypot(resolvedWidth, resolvedHeight),
+    aspectRatio: resolvedWidth / resolvedHeight
+  };
+};
+var resolveOrientation = (props) => {
+  const shortcuts = [
+    ["sitsFlat", props.sitsFlat],
+    ["sitsFlatBelowBoard", props.sitsFlatBelowBoard],
+    ["foldedToFaceAboveBoard", props.foldedToFaceAboveBoard],
+    ["foldedToFaceBelowBoard", props.foldedToFaceBelowBoard],
+    ["foldedToFaceAboveBoard", props.foldsAboveBoard],
+    ["foldedToFaceBelowBoard", props.foldsBelowBoard],
+    ["foldedToRightAngleAboveBoard", props.foldedToRightAngleAboveBoard],
+    ["foldedToRightAngleBelowBoard", props.foldedToRightAngleBelowBoard]
+  ].filter((entry) => entry[1]);
+  if (shortcuts.length > 1) {
+    throw new Error(
+      "Only one FlexScreen boolean orientation shortcut can be true"
+    );
+  }
+  return shortcuts[0]?.[0] ?? props.orientation ?? "sitsFlat";
+};
+var distance = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+var interpolate = (a, b, progress) => [
+  a[0] + (b[0] - a[0]) * progress,
+  a[1] + (b[1] - a[1]) * progress,
+  a[2] + (b[2] - a[2]) * progress
+];
+var getPathDistances = (points) => {
+  const distances = [0];
+  for (let index = 1; index < points.length; index += 1) {
+    distances.push(
+      distances[index - 1] + distance(points[index - 1], points[index])
+    );
+  }
+  return distances;
+};
+var pointAtDistance = (points, distances, targetDistance) => {
+  if (targetDistance <= 0) return points[0];
+  const totalLength = distances.at(-1);
+  if (targetDistance >= totalLength) return points.at(-1);
+  for (let index = 1; index < points.length; index += 1) {
+    if (distances[index] >= targetDistance) {
+      const segmentStart = distances[index - 1];
+      const segmentLength = distances[index] - segmentStart;
+      return interpolate(
+        points[index - 1],
+        points[index],
+        (targetDistance - segmentStart) / segmentLength
+      );
+    }
+  }
+  return points.at(-1);
+};
+var slicePath = (points, startDistance, endDistance) => {
+  const distances = getPathDistances(points);
+  const totalLength = distances.at(-1);
+  const safeStart = Math.max(0, Math.min(startDistance, totalLength));
+  const safeEnd = Math.max(safeStart, Math.min(endDistance, totalLength));
+  const result = [pointAtDistance(points, distances, safeStart)];
+  for (let index = 1; index < points.length - 1; index += 1) {
+    if (distances[index] > safeStart && distances[index] < safeEnd) {
+      result.push(points[index]);
+    }
+  }
+  result.push(pointAtDistance(points, distances, safeEnd));
+  return result;
+};
+var createFlatPath = (start, flexCableLength) => [
+  start,
+  [start[0], start[1] + flexCableLength, start[2]]
+];
+var createFoldedPath = ({
+  start,
+  endZ,
+  flexCableLength,
+  foldDistanceFromConnector,
+  foldOutset,
+  foldSegments
+}) => {
+  const points = [start];
+  const foldStart = [
+    start[0],
+    start[1] + foldDistanceFromConnector,
+    start[2]
+  ];
+  if (foldDistanceFromConnector > EPSILON) points.push(foldStart);
+  for (let index = 1; index <= foldSegments; index += 1) {
+    const angle = Math.PI * index / foldSegments;
+    points.push([
+      start[0],
+      foldStart[1] + foldOutset * Math.sin(angle),
+      start[2] + (endZ - start[2]) * (1 - Math.cos(angle)) / 2
+    ]);
+  }
+  const minimumLength = getPathDistances(points).at(-1);
+  if (minimumLength > flexCableLength + EPSILON) {
+    throw new Error(
+      `flexCableLength must be at least ${minimumLength.toFixed(2)} for this 180-degree fold`
+    );
+  }
+  const tailLength = Math.max(0, flexCableLength - minimumLength);
+  if (tailLength > EPSILON) {
+    const foldEnd = points.at(-1);
+    points.push([foldEnd[0], foldEnd[1] - tailLength, foldEnd[2]]);
+  }
+  return points;
+};
+var createRightAnglePath = ({
+  start,
+  flexCableLength,
+  bendRadius,
+  bendSegments,
+  verticalLead,
+  direction
+}) => {
+  const bendLengthPerRadius = 2 * bendSegments * Math.sin(Math.PI / (4 * bendSegments));
+  const resolvedRadius = Math.min(
+    bendRadius,
+    flexCableLength / bendLengthPerRadius
+  );
+  const bendLength = resolvedRadius * bendLengthPerRadius;
+  const remainingLength = Math.max(0, flexCableLength - bendLength);
+  const resolvedVerticalLead = Math.min(verticalLead, remainingLength * 0.45);
+  const horizontalLength = remainingLength - resolvedVerticalLead;
+  const points = [start];
+  if (horizontalLength > EPSILON) {
+    points.push([start[0], start[1] + horizontalLength, start[2]]);
+  }
+  for (let index = 1; index <= bendSegments; index += 1) {
+    const angle = Math.PI / 2 * index / bendSegments;
+    points.push([
+      start[0],
+      start[1] + horizontalLength + resolvedRadius * Math.sin(angle),
+      start[2] + direction * resolvedRadius * (1 - Math.cos(angle))
+    ]);
+  }
+  if (resolvedVerticalLead > EPSILON) {
+    const arcEnd = points.at(-1);
+    points.push([
+      arcEnd[0],
+      arcEnd[1],
+      arcEnd[2] + direction * resolvedVerticalLead
+    ]);
+  }
+  return points;
+};
+var CableStrip = ({
+  points,
+  width: width10,
+  thickness,
+  color,
+  acrossOffset = 0,
+  normalOffset = 0,
+  overlap = 0.03
+}) => /* @__PURE__ */ jsx(Colorize, { color, children: points.slice(1).map((point, index) => {
+  const previous = points[index];
+  const dx = point[0] - previous[0];
+  const dy = point[1] - previous[1];
+  const dz = point[2] - previous[2];
+  const segmentLength = Math.hypot(dx, dy, dz);
+  if (segmentLength < EPSILON) return null;
+  const pitch = Math.asin(dz / segmentLength);
+  const yaw = Math.atan2(-dx, dy);
+  const midpoint = [
+    (previous[0] + point[0]) / 2,
+    (previous[1] + point[1]) / 2,
+    (previous[2] + point[2]) / 2
+  ];
+  const roundRadius = Math.max(
+    1e-3,
+    Math.min(width10, thickness, segmentLength) / 2 - 1e-3
+  );
+  return /* @__PURE__ */ jsx(Translate, { offset: midpoint, children: /* @__PURE__ */ jsx(Rotate, { rotation: [pitch, 0, yaw], children: /* @__PURE__ */ jsx(
+    RoundedCuboid,
+    {
+      size: [width10, segmentLength + overlap, thickness],
+      center: [acrossOffset, 0, normalOffset],
+      roundRadius
+    }
+  ) }) }, `${index}:${midpoint.join(":")}`);
+}) });
+var FlexScreen = (props) => {
+  const {
+    width: width10,
+    height: height10,
+    diagonal,
+    aspectRatio,
+    ratio,
+    defaultDiagonal,
+    screenThickness = 1.2,
+    bezelInset = 2,
+    bezelDepth = 0.65,
+    activeAreaWidth,
+    activeAreaHeight,
+    screenColor = "#071b24",
+    bezelColor = "#15181d",
+    showScreen = true,
+    flexCableLength = 28,
+    flexCableThickness = 0.18,
+    flexCableColor = "#d79528",
+    conductorCount = 8,
+    conductorPitch,
+    conductorWidth,
+    conductorThickness = 0.035,
+    conductorColor = "#8c4a18",
+    cableEdgeMargin = 0.6,
+    exposedContactLength = 2.4,
+    showConductors = true,
+    showFlexCable = true,
+    showStiffeners = true,
+    stiffenerLength = 3,
+    stiffenerThickness = 0.16,
+    stiffenerColor = "#416bb3",
+    bendRadius = 3,
+    bendSegments = 10,
+    rightAngleVerticalLead = 3,
+    distanceAboveBoard = 7,
+    distanceBelowBoard = 7,
+    foldDistanceFromConnector = 7,
+    foldOutset = 4,
+    foldSegments = 18,
+    screenGap = 0.08,
+    boardTopZ = 0,
+    boardThickness = 1.6,
+    boardClearance = 0.15,
+    cableStartX = 0,
+    cableStartY = 0,
+    cableStartZ,
+    cableLateralOffset = 0,
+    screenOffset,
+    screenRotation,
+    rotation = [0, 0, 0],
+    offset
+  } = props;
+  const size = resolveFlexScreenSize({
+    width: width10,
+    height: height10,
+    diagonal,
+    aspectRatio,
+    ratio,
+    defaultDiagonal
+  });
+  const orientation = resolveOrientation(props);
+  const belowBoard = orientation === "sitsFlatBelowBoard" || orientation === "foldedToFaceBelowBoard" || orientation === "foldedToRightAngleBelowBoard";
+  const foldedFace = orientation === "foldedToFaceAboveBoard" || orientation === "foldedToFaceBelowBoard";
+  const rightAngle = orientation === "foldedToRightAngleAboveBoard" || orientation === "foldedToRightAngleBelowBoard";
+  assertPositive("screenThickness", screenThickness);
+  assertPositive("flexCableLength", flexCableLength);
+  assertPositive("flexCableThickness", flexCableThickness);
+  assertPositive("conductorThickness", conductorThickness);
+  assertPositive("bendRadius", bendRadius);
+  assertPositive("foldOutset", foldOutset);
+  assertPositive("boardThickness", boardThickness);
+  if (showStiffeners) assertPositive("stiffenerThickness", stiffenerThickness);
+  if (!Number.isInteger(conductorCount) || conductorCount < 1) {
+    throw new Error("conductorCount must be a positive integer");
+  }
+  if (!Number.isInteger(bendSegments) || bendSegments < 2) {
+    throw new Error("bendSegments must be an integer of at least 2");
+  }
+  if (!Number.isInteger(foldSegments) || foldSegments < 4) {
+    throw new Error("foldSegments must be an integer of at least 4");
+  }
+  if (boardClearance < 0 || screenGap < 0 || cableEdgeMargin < 0 || exposedContactLength < 0 || stiffenerLength < 0 || rightAngleVerticalLead < 0 || distanceAboveBoard < 0 || distanceBelowBoard < 0 || foldDistanceFromConnector < 0) {
+    throw new Error(
+      "clearances, margins, contact lengths, and lead lengths cannot be negative"
+    );
+  }
+  const resolvedCableWidth = props.flexCableWidth ?? Math.min(12, Math.max(5, size.width * 0.3));
+  assertPositive("flexCableWidth", resolvedCableWidth);
+  const usableCableWidth = resolvedCableWidth - cableEdgeMargin * 2;
+  if (usableCableWidth <= 0) {
+    throw new Error("cableEdgeMargin leaves no usable flex cable width");
+  }
+  const resolvedConductorPitch = conductorPitch ?? (conductorCount === 1 ? 0 : usableCableWidth / conductorCount);
+  if (conductorCount > 1 && (!Number.isFinite(resolvedConductorPitch) || resolvedConductorPitch <= 0)) {
+    throw new Error("conductorPitch must be greater than zero");
+  }
+  const resolvedConductorWidth = conductorWidth ?? (conductorCount === 1 ? Math.min(usableCableWidth, resolvedCableWidth * 0.45) : resolvedConductorPitch * 0.48);
+  assertPositive("conductorWidth", resolvedConductorWidth);
+  const conductorSpan = (conductorCount - 1) * resolvedConductorPitch + resolvedConductorWidth;
+  if (conductorSpan > usableCableWidth + EPSILON) {
+    throw new Error(
+      "conductorPitch and conductorWidth do not fit inside the flex cable margins"
+    );
+  }
+  const cableStartsBelowBoard = belowBoard && !foldedFace;
+  const defaultCableZ = cableStartsBelowBoard ? boardTopZ - boardThickness - boardClearance - flexCableThickness / 2 : boardTopZ + boardClearance + flexCableThickness / 2;
+  const start = [
+    cableStartX + cableLateralOffset,
+    cableStartY,
+    cableStartZ ?? defaultCableZ
+  ];
+  const direction = belowBoard ? -1 : 1;
+  const foldedScreenBackZ = orientation === "foldedToFaceAboveBoard" ? boardTopZ + distanceAboveBoard : boardTopZ - boardThickness - distanceBelowBoard;
+  const foldedCableEndZ = orientation === "foldedToFaceAboveBoard" ? foldedScreenBackZ - screenGap - flexCableThickness / 2 : foldedScreenBackZ + screenGap + flexCableThickness / 2;
+  const path = foldedFace ? createFoldedPath({
+    start,
+    endZ: foldedCableEndZ,
+    flexCableLength,
+    foldDistanceFromConnector,
+    foldOutset,
+    foldSegments
+  }) : rightAngle ? createRightAnglePath({
+    start,
+    flexCableLength,
+    bendRadius,
+    bendSegments,
+    verticalLead: rightAngleVerticalLead,
+    direction
+  }) : createFlatPath(start, flexCableLength);
+  const totalCableLength = getPathDistances(path).at(-1);
+  const contactLength = Math.min(
+    Math.max(0, exposedContactLength),
+    totalCableLength / 2
+  );
+  const resolvedStiffenerLength = Math.min(
+    Math.max(0, stiffenerLength),
+    totalCableLength / 2
+  );
+  const startContacts = slicePath(path, 0, contactLength);
+  const endContacts = slicePath(
+    path,
+    totalCableLength - contactLength,
+    totalCableLength
+  );
+  const startStiffener = slicePath(path, 0, resolvedStiffenerLength);
+  const endStiffener = slicePath(
+    path,
+    totalCableLength - resolvedStiffenerLength,
+    totalCableLength
+  );
+  const pathEnd = path.at(-1);
+  let presetScreenRotation;
+  let screenCenter;
+  if (orientation === "sitsFlat") {
+    presetScreenRotation = [0, 0, 0];
+    screenCenter = [
+      pathEnd[0],
+      pathEnd[1] + size.height / 2,
+      pathEnd[2] + flexCableThickness / 2 + screenGap
+    ];
+  } else if (orientation === "sitsFlatBelowBoard") {
+    presetScreenRotation = [0, Math.PI, 0];
+    screenCenter = [
+      pathEnd[0],
+      pathEnd[1] + size.height / 2,
+      pathEnd[2] - flexCableThickness / 2 - screenGap
+    ];
+  } else if (orientation === "foldedToFaceAboveBoard") {
+    presetScreenRotation = [0, 0, 0];
+    screenCenter = [pathEnd[0], pathEnd[1] - size.height / 2, foldedScreenBackZ];
+  } else if (orientation === "foldedToFaceBelowBoard") {
+    presetScreenRotation = [0, Math.PI, 0];
+    screenCenter = [pathEnd[0], pathEnd[1] - size.height / 2, foldedScreenBackZ];
+  } else if (orientation === "foldedToRightAngleAboveBoard") {
+    presetScreenRotation = [Math.PI / 2, 0, 0];
+    screenCenter = [
+      pathEnd[0],
+      pathEnd[1] - flexCableThickness / 2 - screenGap,
+      pathEnd[2] + size.height / 2
+    ];
+  } else {
+    presetScreenRotation = [-Math.PI / 2, 0, 0];
+    screenCenter = [
+      pathEnd[0],
+      pathEnd[1] + flexCableThickness / 2 + screenGap,
+      pathEnd[2] - size.height / 2
+    ];
+  }
+  screenCenter = [
+    screenCenter[0] + (screenOffset?.x ?? 0),
+    screenCenter[1] + (screenOffset?.y ?? 0),
+    screenCenter[2] + (screenOffset?.z ?? 0)
+  ];
+  const conductorOffsets = Array.from(
+    { length: conductorCount },
+    (_, index) => conductorCount === 1 ? 0 : (index - (conductorCount - 1) / 2) * resolvedConductorPitch
+  );
+  const conductorNormalOffset = (flexCableThickness + conductorThickness) / 2;
+  const stiffenerNormalOffset = -(flexCableThickness + stiffenerThickness) / 2;
+  const assembly = /* @__PURE__ */ jsxs(Fragment2, { children: [
+    showFlexCable && /* @__PURE__ */ jsx(
+      CableStrip,
+      {
+        points: path,
+        width: resolvedCableWidth,
+        thickness: flexCableThickness,
+        color: flexCableColor
+      }
+    ),
+    showFlexCable && showStiffeners && resolvedStiffenerLength > EPSILON && /* @__PURE__ */ jsxs(Fragment2, { children: [
+      /* @__PURE__ */ jsx(
+        CableStrip,
+        {
+          points: startStiffener,
+          width: resolvedCableWidth,
+          thickness: stiffenerThickness,
+          color: stiffenerColor,
+          normalOffset: stiffenerNormalOffset
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CableStrip,
+        {
+          points: endStiffener,
+          width: resolvedCableWidth,
+          thickness: stiffenerThickness,
+          color: stiffenerColor,
+          normalOffset: stiffenerNormalOffset
+        }
+      )
+    ] }),
+    showFlexCable && showConductors && contactLength > EPSILON && conductorOffsets.map((acrossOffset, index) => /* @__PURE__ */ jsxs(Fragment2, { children: [
+      /* @__PURE__ */ jsx(
+        CableStrip,
+        {
+          points: startContacts,
+          width: resolvedConductorWidth,
+          thickness: conductorThickness,
+          color: conductorColor,
+          acrossOffset,
+          normalOffset: conductorNormalOffset
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CableStrip,
+        {
+          points: endContacts,
+          width: resolvedConductorWidth,
+          thickness: conductorThickness,
+          color: conductorColor,
+          acrossOffset,
+          normalOffset: conductorNormalOffset
+        }
+      )
+    ] }, `conductor:${index}`)),
+    showScreen && /* @__PURE__ */ jsx(Translate, { offset: screenCenter, children: /* @__PURE__ */ jsx(Rotate, { rotation: screenRotation ?? presetScreenRotation, children: /* @__PURE__ */ jsx(
+      Screen,
+      {
+        width: size.width,
+        height: size.height,
+        thickness: screenThickness,
+        bezelInset,
+        bezelDepth,
+        screenWidth: activeAreaWidth,
+        screenHeight: activeAreaHeight,
+        screenColor,
+        bezelColor
+      }
+    ) }) })
+  ] });
+  return /* @__PURE__ */ jsx(
+    Translate,
+    {
+      offset: {
+        x: offset?.x ?? 0,
+        y: offset?.y ?? 0,
+        z: offset?.z ?? 0
+      },
+      children: /* @__PURE__ */ jsx(Translate, { offset: start, children: /* @__PURE__ */ jsx(Rotate, { rotation, children: /* @__PURE__ */ jsx(Translate, { offset: [-start[0], -start[1], -start[2]], children: assembly }) }) })
+    }
+  );
+};
+
 // lib/Footprinter3d.tsx
 var Footprinter3d = ({ footprint }) => {
+  const modelFn = mp.string(footprint.split("_", 1)[0]).params().fn;
+  if (mp.getModelNames().includes(modelFn)) {
+    const model = mp.string(footprint).json();
+    switch (model.fn) {
+      case "flexscreen": {
+        const { fn: _, ...flexScreenProps } = model;
+        return /* @__PURE__ */ jsx(FlexScreen, { ...flexScreenProps });
+      }
+    }
+  }
   let normalizedFootprint = footprint;
   if (footprint.startsWith("jstzh1_5mm")) {
     const pinMatch = footprint.match(/jstzh1_5mm(\d+)?/);
@@ -6589,7 +7139,6 @@ var Footprinter3d = ({ footprint }) => {
             numberOfPins: fpJson.num_pins,
             pitch: fpJson.p,
             invert: fpJson.invert,
-            faceup: fpJson.faceup,
             rows,
             smd: fpJson.smd || fpJson.surface_mount,
             rightangle: fpJson.rightangle