@tscircuit/pcb-viewer 1.11.279 → 1.11.280

package/dist/index.js

@@ -7074,7 +7074,7 @@ function getExpandedStroke(strokeInput, defaultWidth) {
 }
 
 // src/lib/convert-element-to-primitive.ts
-import { distance } from "circuit-json";
+import { distance as distance2 } from "circuit-json";
 
 // src/lib/element-to-primitive-converters/convert-smtpad-rect.ts
 var convertSmtpadRect = (element, metadata) => {
@@ -7271,12 +7271,49 @@ var convertSmtpadRotatedPill = (element, metadata) => {
   return primitives;
 };
 
+// src/lib/element-to-primitive/convert-pcb-copper-text-to-primitive.ts
+import { distance } from "circuit-json";
+var convertPcbCopperTextToPrimitive = (element, metadata) => {
+  const { _parent_pcb_component, _parent_source_component } = metadata;
+  const copperText = element;
+  const fontSize = typeof copperText.font_size === "string" ? distance.parse(copperText.font_size) : copperText.font_size ?? 0.2;
+  let knockoutPadding;
+  if (copperText.knockout_padding) {
+    knockoutPadding = {
+      left: typeof copperText.knockout_padding.left === "string" ? distance.parse(copperText.knockout_padding.left) : copperText.knockout_padding.left,
+      top: typeof copperText.knockout_padding.top === "string" ? distance.parse(copperText.knockout_padding.top) : copperText.knockout_padding.top,
+      bottom: typeof copperText.knockout_padding.bottom === "string" ? distance.parse(copperText.knockout_padding.bottom) : copperText.knockout_padding.bottom,
+      right: typeof copperText.knockout_padding.right === "string" ? distance.parse(copperText.knockout_padding.right) : copperText.knockout_padding.right
+    };
+  }
+  return [
+    {
+      _pcb_drawing_object_id: getNewPcbDrawingObjectId("text"),
+      pcb_drawing_type: "text",
+      x: copperText.anchor_position.x,
+      y: copperText.anchor_position.y,
+      layer: copperText.layer,
+      // "top", "bottom", or inner layers
+      align: copperText.anchor_alignment ?? "center",
+      text: copperText.text,
+      size: fontSize,
+      ccw_rotation: copperText.ccw_rotation,
+      is_mirrored: copperText.is_mirrored,
+      is_knockout: copperText.is_knockout,
+      knockout_padding: knockoutPadding,
+      _element: element,
+      _parent_pcb_component,
+      _parent_source_component
+    }
+  ];
+};
+
 // src/lib/convert-element-to-primitive.ts
 var globalPcbDrawingObjectCount = 0;
 var getNewPcbDrawingObjectId = (prefix) => `${prefix}_${globalPcbDrawingObjectCount++}`;
 var normalizePolygonPoints = (points) => (points ?? []).map((point) => ({
-  x: distance.parse(point.x),
-  y: distance.parse(point.y)
+  x: distance2.parse(point.x),
+  y: distance2.parse(point.y)
 }));
 var convertElementToPrimitives = (element, allElements) => {
   const _parent_pcb_component = "pcb_component_id" in element ? allElements.find(
@@ -7803,10 +7840,10 @@ var convertElementToPrimitives = (element, allElements) => {
           hole_height,
           layers
         } = element;
-        const hole_offset_x = distance.parse(
+        const hole_offset_x = distance2.parse(
           element.hole_offset_x ?? 0
         );
-        const hole_offset_y = distance.parse(
+        const hole_offset_y = distance2.parse(
           element.hole_offset_y ?? 0
         );
         const pcb_outline = pad_outline;
@@ -8189,6 +8226,12 @@ var convertElementToPrimitives = (element, allElements) => {
         }
       ];
     }
+    case "pcb_copper_text": {
+      return convertPcbCopperTextToPrimitive(element, {
+        _parent_pcb_component,
+        _parent_source_component
+      });
+    }
     case "pcb_copper_pour": {
       const pour = element;
       switch (pour.shape) {
@@ -9480,6 +9523,7 @@ var getTextGeometry = (text) => {
   return {
     text_lines,
     line_count,
+    line_widths,
     target_height,
     target_width_char,
     space_between_chars,
@@ -9502,17 +9546,21 @@ var convertTextToLines = (text) => {
   const {
     text_lines,
     line_count,
+    line_widths,
     target_height,
     target_width_char,
     space_between_chars,
-    space_between_lines
+    space_between_lines,
+    width: maxWidth
   } = getTextGeometry(text);
   if (target_height <= 0 || line_count === 0) return [];
   const strokeWidth = target_height / 12;
   const lines = [];
   for (let lineIndex = 0; lineIndex < line_count; lineIndex++) {
-    const lineYOffset = lineIndex * (target_height + space_between_lines);
-    let current_x_origin_for_char_box = text.x;
+    const lineYOffset = -lineIndex * (target_height + space_between_lines);
+    const lineWidth = line_widths[lineIndex];
+    const lineXOffset = (maxWidth - lineWidth) / 2;
+    let current_x_origin_for_char_box = text.x + lineXOffset;
     for (let letterIndex = 0; letterIndex < text_lines[lineIndex].length; letterIndex++) {
       const letter = text_lines[lineIndex][letterIndex];
       const letterLines = lineAlphabet[letter] ?? lineAlphabet[letter.toUpperCase()];
@@ -9572,56 +9620,44 @@ var drawLine = (drawer, line) => {
   drawer.moveTo(line.x1, line.y1);
   drawer.lineTo(line.x2, line.y2);
 };
-var drawText = (drawer, text) => {
-  drawer.equip({
-    fontSize: text.size,
-    color: getColor(text),
-    layer: text.layer
-  });
-  let alignOffset = { x: 0, y: 0 };
-  const { width: textWidth, height: textHeight } = getTextMetrics(text);
-  switch (text.align) {
+var getAlignOffset = (textWidth, textHeight, align) => {
+  switch (align) {
     case "top_left":
-      alignOffset.x = 0;
-      alignOffset.y = -textHeight;
-      break;
+      return { x: 0, y: -textHeight };
     case "top_center":
-      alignOffset.x = -textWidth / 2;
-      alignOffset.y = -textHeight;
-      break;
+      return { x: -textWidth / 2, y: -textHeight };
     case "top_right":
-      alignOffset.x = -textWidth;
-      alignOffset.y = -textHeight;
-      break;
+      return { x: -textWidth, y: -textHeight };
     case "center_left":
-      alignOffset.x = 0;
-      alignOffset.y = -textHeight / 2;
-      break;
+      return { x: 0, y: -textHeight / 2 };
     case "center":
-      alignOffset.x = -textWidth / 2;
-      alignOffset.y = -textHeight / 2;
-      break;
+      return { x: -textWidth / 2, y: -textHeight / 2 };
     case "center_right":
-      alignOffset.x = -textWidth;
-      alignOffset.y = -textHeight / 2;
-      break;
+      return { x: -textWidth, y: -textHeight / 2 };
     case "bottom_left":
-      alignOffset.x = 0;
-      alignOffset.y = 0;
-      break;
+      return { x: 0, y: 0 };
     case "bottom_center":
-      alignOffset.x = -textWidth / 2;
-      alignOffset.y = 0;
-      break;
+      return { x: -textWidth / 2, y: 0 };
     case "bottom_right":
-      alignOffset.x = -textWidth;
-      alignOffset.y = 0;
-      break;
+      return { x: -textWidth, y: 0 };
     default:
-      alignOffset.x = 0;
-      alignOffset.y = 0;
-      break;
+      return { x: 0, y: 0 };
+  }
+};
+var shouldMirrorText = (text) => {
+  if (text.layer === "bottom_silkscreen" || text.layer === "bottom") {
+    return text.is_mirrored !== false;
   }
+  return text.is_mirrored === true;
+};
+var drawText = (drawer, text) => {
+  drawer.equip({
+    fontSize: text.size,
+    color: getColor(text),
+    layer: text.layer
+  });
+  const { width: textWidth, height: textHeight } = getTextMetrics(text);
+  const alignOffset = getAlignOffset(textWidth, textHeight, text.align);
   text.x ??= 0;
   text.y ??= 0;
   const rotationAnchor = {
@@ -9633,7 +9669,7 @@ var drawText = (drawer, text) => {
     x: text.x + alignOffset.x,
     y: text.y + alignOffset.y
   });
-  if (text.layer === "bottom_silkscreen") {
+  if (shouldMirrorText(text)) {
     text_lines = text_lines.map((line) => ({
       ...line,
       x1: 2 * text.x - line.x1,
@@ -9652,6 +9688,80 @@ var drawText = (drawer, text) => {
     drawLine(drawer, line);
   }
 };
+var drawKnockoutText = (drawer, text) => {
+  const {
+    width: textWidth,
+    height: textHeight,
+    lineHeight
+  } = getTextMetrics(text);
+  text.x ??= 0;
+  text.y ??= 0;
+  const padding = text.knockout_padding ?? {
+    left: text.size * 0.5,
+    right: text.size * 0.5,
+    top: text.size * 0.3,
+    bottom: text.size * 0.3
+  };
+  const rectWidth = textWidth + padding.left + padding.right;
+  const rectHeight = textHeight + padding.top + padding.bottom;
+  const textCenterXAtOrigin = textWidth / 2;
+  const textCenterYAtOrigin = lineHeight - textHeight / 2;
+  const textDrawX = text.x - textCenterXAtOrigin;
+  const textDrawY = text.y - textCenterYAtOrigin;
+  const rotationAnchor = {
+    x: text.x,
+    y: text.y
+  };
+  const rect = {
+    _pcb_drawing_object_id: `knockout_rect_${text._pcb_drawing_object_id}`,
+    pcb_drawing_type: "rect",
+    x: text.x,
+    y: text.y,
+    w: rectWidth,
+    h: rectHeight,
+    layer: text.layer,
+    ccw_rotation: text.ccw_rotation
+  };
+  if (text.ccw_rotation) {
+    drawRotatedRect(drawer, rect);
+  } else {
+    drawRect(drawer, rect);
+  }
+  let text_lines = convertTextToLines({
+    ...text,
+    x: textDrawX,
+    y: textDrawY
+  });
+  if (shouldMirrorText(text)) {
+    text_lines = text_lines.map((line) => ({
+      ...line,
+      x1: 2 * text.x - line.x1,
+      x2: 2 * text.x - line.x2
+    }));
+  }
+  if (text.ccw_rotation) {
+    const rotateTextParams = {
+      lines: text_lines,
+      anchorPoint: rotationAnchor,
+      ccwRotation: text.ccw_rotation
+    };
+    text_lines = rotateText(rotateTextParams);
+  }
+  for (const line of text_lines) {
+    drawer.equip({
+      size: line.width,
+      shape: "circle",
+      color: "black",
+      layer: text.layer,
+      mode: "subtract"
+    });
+    drawer.moveTo(line.x1, line.y1);
+    drawer.lineTo(line.x2, line.y2);
+  }
+  drawer.equip({
+    mode: "add"
+  });
+};
 var drawRect = (drawer, rect) => {
   drawer.equip({
     color: getColor(rect),
@@ -9733,6 +9843,9 @@ var drawPrimitive = (drawer, primitive) => {
     case "line":
       return drawLine(drawer, primitive);
     case "text":
+      if (primitive.is_knockout) {
+        return drawKnockoutText(drawer, primitive);
+      }
       return drawText(drawer, primitive);
     case "rect": {
       if (primitive.ccw_rotation) {
@@ -10492,7 +10605,7 @@ function calculateDiagonalLabel(params) {
   } = params;
   const deltaX = dimensionEnd.x - dimensionStart.x;
   const deltaY = dimensionEnd.y - dimensionStart.y;
-  const distance3 = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+  const distance4 = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
   const screenDeltaX = screenDimensionEnd.x - screenDimensionStart.x;
   const screenDeltaY = screenDimensionEnd.y - screenDimensionStart.y;
   const screenDistance = Math.sqrt(
@@ -10534,11 +10647,11 @@ function calculateDiagonalLabel(params) {
   const x = midX + offsetX;
   const y = midY + offsetY;
   return {
-    distance: distance3,
+    distance: distance4,
     screenDistance,
     x,
     y,
-    show: distance3 > 0.01 && screenDistance > 30 && isDiagonal
+    show: distance4 > 0.01 && screenDistance > 30 && isDiagonal
   };
 }
 
@@ -10832,11 +10945,11 @@ var DimensionOverlay = ({
       for (const snap of snappingPointsWithScreen) {
         const dx = snap.screenPoint.x - screenPoint.x;
         const dy = snap.screenPoint.y - screenPoint.y;
-        const distance3 = Math.hypot(dx, dy);
-        if (distance3 > SNAP_THRESHOLD_PX) continue;
-        if (!bestMatch || distance3 < bestMatch.distance) {
+        const distance4 = Math.hypot(dx, dy);
+        if (distance4 > SNAP_THRESHOLD_PX) continue;
+        if (!bestMatch || distance4 < bestMatch.distance) {
           bestMatch = {
-            distance: distance3,
+            distance: distance4,
             id: snap.id,
             point: snap.point
           };
@@ -11435,10 +11548,10 @@ var isInsideOfSmtpad = (elm, point, padding = 0) => {
 };
 var isInsideOfPlatedHole = (hole, point, padding = 0) => {
   if (hole.shape === "circle") {
-    const distance3 = Math.sqrt(
+    const distance4 = Math.sqrt(
       (point.x - hole.x) ** 2 + (point.y - hole.y) ** 2
     );
-    return distance3 <= hole.outer_diameter / 2 + padding;
+    return distance4 <= hole.outer_diameter / 2 + padding;
   } else if (hole.shape === "circular_hole_with_rect_pad") {
     const dx = Math.abs(point.x - hole.x);
     const dy = Math.abs(point.y - hole.y);
@@ -12266,7 +12379,7 @@ var ErrorOverlay = ({
 
 // src/components/MouseElementTracker.tsx
 import { pointToSegmentDistance } from "@tscircuit/math-utils";
-import { distance as distance2 } from "circuit-json";
+import { distance as distance3 } from "circuit-json";
 
 // src/lib/util/if-sets-match-exactly.ts
 function ifSetsMatchExactly(set1, set2) {
@@ -12816,22 +12929,22 @@ var getPrimitivesUnderPoint = (primitives, rwPoint, transform) => {
   for (const primitive of primitives) {
     if (!primitive._element) continue;
     if ("x1" in primitive && primitive._element?.type === "pcb_trace") {
-      const distance3 = pointToSegmentDistance(
+      const distance4 = pointToSegmentDistance(
         { x: rwPoint.x, y: rwPoint.y },
         { x: primitive.x1, y: primitive.y1 },
         { x: primitive.x2, y: primitive.y2 }
       );
       const lineWidth = primitive.width || 0.5;
       const detectionThreshold = Math.max(lineWidth * 25, 2) / transform.a;
-      if (distance3 < detectionThreshold) {
+      if (distance4 < detectionThreshold) {
         newMousedPrimitives.push(primitive);
       }
       continue;
     }
     if (primitive.pcb_drawing_type === "polygon") {
       const points = primitive.points.map((point) => ({
-        x: distance2.parse(point.x),
-        y: distance2.parse(point.y)
+        x: distance3.parse(point.x),
+        y: distance3.parse(point.y)
       }));
       const boundingBox = getPolygonBoundingBox(points);
       if (!boundingBox) continue;
@@ -12845,8 +12958,8 @@ var getPrimitivesUnderPoint = (primitives, rwPoint, transform) => {
     }
     if (primitive.pcb_drawing_type === "polygon_with_arcs") {
       const points = primitive.brep_shape.outer_ring.vertices.map((v) => ({
-        x: distance2.parse(v.x),
-        y: distance2.parse(v.y)
+        x: distance3.parse(v.x),
+        y: distance3.parse(v.y)
       }));
       const boundingBox = getPolygonBoundingBox(points);
       if (!boundingBox) continue;
@@ -13288,11 +13401,11 @@ var RatsNestOverlay = ({ transform, soup, children }) => {
       connectedIds.forEach((id) => {
         const pos = getElementPosition(id);
         if (pos) {
-          const distance3 = Math.sqrt(
+          const distance4 = Math.sqrt(
             (sourcePoint.x - pos.x) ** 2 + (sourcePoint.y - pos.y) ** 2
           );
-          if (distance3 < minDistance && distance3 > 0) {
-            minDistance = distance3;
+          if (distance4 < minDistance && distance4 > 0) {
+            minDistance = distance4;
             nearestPoint = pos;
           }
         }
@@ -13372,7 +13485,7 @@ import { css as css3 } from "@emotion/css";
 // package.json
 var package_default = {
   name: "@tscircuit/pcb-viewer",
-  version: "1.11.278",
+  version: "1.11.279",
   main: "dist/index.js",
   type: "module",
   repository: "tscircuit/pcb-viewer",