circuit-to-svg 0.0.164 → 0.0.165

package/dist/index.js

@@ -2987,69 +2987,6 @@ function drawSchematicLabeledPoints(params) {
   };
 }
 
-// lib/utils/get-unit-vector-from-outside-to-edge.ts
-var getUnitVectorFromOutsideToEdge = (side) => {
-  switch (side) {
-    case "top":
-      return { x: 0, y: -1 };
-    case "bottom":
-      return { x: 0, y: 1 };
-    case "left":
-      return { x: 1, y: 0 };
-    case "right":
-      return { x: -1, y: 0 };
-  }
-  throw new Error(`Invalid side: ${side}`);
-};
-
-// lib/utils/net-label-utils.ts
-import "transformation-matrix";
-import "schematic-symbols";
-var ARROW_POINT_WIDTH_FSR = 0.3;
-var END_PADDING_FSR = 0.3;
-var END_PADDING_EXTRA_PER_CHARACTER_FSR = 0.06;
-var ninePointAnchorToTextAnchor = {
-  top_left: "start",
-  top_right: "end",
-  middle_left: "start",
-  middle_right: "end",
-  bottom_left: "start",
-  bottom_right: "end",
-  center: "middle",
-  middle_top: "middle",
-  middle_bottom: "middle"
-};
-var ninePointAnchorToDominantBaseline = {
-  top_left: "hanging",
-  top_right: "hanging",
-  bottom_left: "ideographic",
-  bottom_right: "ideographic",
-  center: "middle",
-  middle_left: "middle",
-  middle_right: "middle",
-  middle_top: "hanging",
-  middle_bottom: "ideographic"
-};
-function getPathRotation(anchorSide) {
-  const rotationMap = {
-    left: 180,
-    top: 90,
-    bottom: -90,
-    right: 0
-  };
-  return rotationMap[anchorSide] ?? 0;
-}
-function calculateAnchorPosition(schNetLabel, fontSizeMm, textWidthFSR) {
-  const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR * schNetLabel.text.length + END_PADDING_FSR;
-  const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
-    schNetLabel.anchor_side
-  );
-  return schNetLabel.anchor_position ?? {
-    x: schNetLabel.center.x - realTextGrowthVec.x * fullWidthFsr * fontSizeMm / 2,
-    y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
-  };
-}
-
 // lib/sch/arial-text-metrics.ts
 var arialTextMetrics = {
   "0": {
@@ -3829,6 +3766,149 @@ var estimateTextWidth = (text) => {
   return totalWidth / 27;
 };
 
+// lib/sch/get-table-dimensions.ts
+var getTableDimensions = (schematicTable, circuitJson) => {
+  if (schematicTable.column_widths && schematicTable.column_widths.length > 0 && schematicTable.row_heights && schematicTable.row_heights.length > 0) {
+    const unitToMm = (v) => {
+      if (typeof v === "number") return v;
+      if (v.endsWith("mm")) return parseFloat(v);
+      if (v.endsWith("in")) return parseFloat(v) * 25.4;
+      return parseFloat(v);
+    };
+    return {
+      column_widths: schematicTable.column_widths.map(unitToMm),
+      row_heights: schematicTable.row_heights.map(unitToMm)
+    };
+  }
+  const cells = circuitJson.filter(
+    (elm) => elm.type === "schematic_table_cell" && elm.schematic_table_id === schematicTable.schematic_table_id
+  );
+  if (cells.length === 0) {
+    return { column_widths: [], row_heights: [] };
+  }
+  const numColumns = cells.reduce((max, c) => Math.max(max, c.end_column_index), -1) + 1;
+  const numRows = cells.reduce((max, c) => Math.max(max, c.end_row_index), -1) + 1;
+  const { cell_padding = 0.2 } = schematicTable;
+  const column_widths = new Array(numColumns).fill(0);
+  const row_heights = new Array(numRows).fill(0);
+  const cell_widths = {};
+  const cell_heights = {};
+  for (const cell of cells) {
+    const fontSizeMm = getSchMmFontSize("reference_designator", cell.font_size);
+    const textWidthMm = estimateTextWidth(cell.text ?? "") * fontSizeMm;
+    const requiredWidth = textWidthMm + 2 * cell_padding;
+    const requiredHeight = fontSizeMm * 1.2 + 2 * cell_padding;
+    const key = `${cell.start_row_index}-${cell.start_column_index}`;
+    cell_widths[key] = requiredWidth;
+    cell_heights[key] = requiredHeight;
+  }
+  for (let i = 0; i < numRows; i++) {
+    for (let j = 0; j < numColumns; j++) {
+      const key = `${i}-${j}`;
+      if (cell_widths[key] && cell_widths[key] > column_widths[j]) {
+        column_widths[j] = cell_widths[key];
+      }
+      if (cell_heights[key] && cell_heights[key] > row_heights[i]) {
+        row_heights[i] = cell_heights[key];
+      }
+    }
+  }
+  for (const cell of cells) {
+    if (cell.start_column_index === cell.end_column_index && cell.start_row_index === cell.end_row_index)
+      continue;
+    const key = `${cell.start_row_index}-${cell.start_column_index}`;
+    const requiredWidth = cell_widths[key];
+    const requiredHeight = cell_heights[key];
+    if (requiredWidth === void 0 || requiredHeight === void 0) continue;
+    let currentWidth = 0;
+    for (let i = cell.start_column_index; i <= cell.end_column_index; i++) {
+      currentWidth += column_widths[i];
+    }
+    if (requiredWidth > currentWidth) {
+      const diff = requiredWidth - currentWidth;
+      const extraPerColumn = diff / (cell.end_column_index - cell.start_column_index + 1);
+      for (let i = cell.start_column_index; i <= cell.end_column_index; i++) {
+        column_widths[i] += extraPerColumn;
+      }
+    }
+    let currentHeight = 0;
+    for (let i = cell.start_row_index; i <= cell.end_row_index; i++) {
+      currentHeight += row_heights[i];
+    }
+    if (requiredHeight > currentHeight) {
+      const diff = requiredHeight - currentHeight;
+      const extraPerRow = diff / (cell.end_row_index - cell.start_row_index + 1);
+      for (let i = cell.start_row_index; i <= cell.end_row_index; i++) {
+        row_heights[i] += extraPerRow;
+      }
+    }
+  }
+  return { column_widths, row_heights };
+};
+
+// lib/utils/get-unit-vector-from-outside-to-edge.ts
+var getUnitVectorFromOutsideToEdge = (side) => {
+  switch (side) {
+    case "top":
+      return { x: 0, y: -1 };
+    case "bottom":
+      return { x: 0, y: 1 };
+    case "left":
+      return { x: 1, y: 0 };
+    case "right":
+      return { x: -1, y: 0 };
+  }
+  throw new Error(`Invalid side: ${side}`);
+};
+
+// lib/utils/net-label-utils.ts
+import "transformation-matrix";
+import "schematic-symbols";
+var ARROW_POINT_WIDTH_FSR = 0.3;
+var END_PADDING_FSR = 0.3;
+var END_PADDING_EXTRA_PER_CHARACTER_FSR = 0.06;
+var ninePointAnchorToTextAnchor = {
+  top_left: "start",
+  top_right: "end",
+  middle_left: "start",
+  middle_right: "end",
+  bottom_left: "start",
+  bottom_right: "end",
+  center: "middle",
+  middle_top: "middle",
+  middle_bottom: "middle"
+};
+var ninePointAnchorToDominantBaseline = {
+  top_left: "hanging",
+  top_right: "hanging",
+  bottom_left: "ideographic",
+  bottom_right: "ideographic",
+  center: "middle",
+  middle_left: "middle",
+  middle_right: "middle",
+  middle_top: "hanging",
+  middle_bottom: "ideographic"
+};
+function getPathRotation(anchorSide) {
+  const rotationMap = {
+    left: 180,
+    top: 90,
+    bottom: -90,
+    right: 0
+  };
+  return rotationMap[anchorSide] ?? 0;
+}
+function calculateAnchorPosition(schNetLabel, fontSizeMm, textWidthFSR) {
+  const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR * schNetLabel.text.length + END_PADDING_FSR;
+  const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
+    schNetLabel.anchor_side
+  );
+  return schNetLabel.anchor_position ?? {
+    x: schNetLabel.center.x - realTextGrowthVec.x * fullWidthFsr * fontSizeMm / 2,
+    y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
+  };
+}
+
 // lib/sch/get-schematic-bounds-from-circuit-json.ts
 function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
   let minX = Number.POSITIVE_INFINITY;
@@ -3889,6 +3969,30 @@ function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
         { width: item.width, height: item.height },
         0
       );
+    } else if (item.type === "schematic_table") {
+      const { column_widths, row_heights } = getTableDimensions(item, soup);
+      const totalWidth = column_widths.reduce((a, b) => a + b, 0);
+      const totalHeight = row_heights.reduce((a, b) => a + b, 0);
+      const anchor = item.anchor ?? "center";
+      let topLeftX = item.anchor_position.x;
+      let topLeftY = item.anchor_position.y;
+      if (anchor.includes("center")) {
+        topLeftX -= totalWidth / 2;
+      } else if (anchor.includes("right")) {
+        topLeftX -= totalWidth;
+      }
+      if (anchor.includes("center")) {
+        topLeftY += totalHeight / 2;
+      } else if (anchor.includes("bottom")) {
+        topLeftY += totalHeight;
+      }
+      const centerX = topLeftX + totalWidth / 2;
+      const centerY = topLeftY - totalHeight / 2;
+      updateBounds(
+        { x: centerX, y: centerY },
+        { width: totalWidth, height: totalHeight },
+        0
+      );
     }
   }
   minX -= padding;
@@ -5412,6 +5516,206 @@ var createSvgObjectsFromSchematicBox = ({
   ];
 };
 
+// lib/sch/svg-object-fns/create-svg-objects-from-sch-table.ts
+import { applyToPoint as applyToPoint42 } from "transformation-matrix";
+var createSvgObjectsFromSchematicTable = ({
+  schematicTable,
+  transform,
+  colorMap: colorMap2,
+  circuitJson
+}) => {
+  const {
+    anchor_position,
+    border_width = 0.05,
+    anchor = "center"
+  } = schematicTable;
+  const { column_widths, row_heights } = getTableDimensions(
+    schematicTable,
+    circuitJson
+  );
+  const totalWidth = column_widths.reduce((a, b) => a + b, 0);
+  const totalHeight = row_heights.reduce((a, b) => a + b, 0);
+  let topLeftX = anchor_position.x;
+  let topLeftY = anchor_position.y;
+  if (anchor.includes("center")) {
+    topLeftX -= totalWidth / 2;
+  } else if (anchor.includes("right")) {
+    topLeftX -= totalWidth;
+  }
+  if (anchor.includes("center")) {
+    topLeftY += totalHeight / 2;
+  } else if (anchor.includes("bottom")) {
+    topLeftY += totalHeight;
+  }
+  const svgObjects = [];
+  const borderStrokeWidth = border_width * Math.abs(transform.a);
+  const gridStrokeWidth = getSchStrokeSize(transform);
+  const [screenTopLeftX, screenTopLeftY] = applyToPoint42(transform, [
+    topLeftX,
+    topLeftY
+  ]);
+  const [screenBottomRightX, screenBottomRightY] = applyToPoint42(transform, [
+    topLeftX + totalWidth,
+    topLeftY - totalHeight
+  ]);
+  svgObjects.push({
+    name: "rect",
+    type: "element",
+    attributes: {
+      x: screenTopLeftX.toString(),
+      y: screenTopLeftY.toString(),
+      width: (screenBottomRightX - screenTopLeftX).toString(),
+      height: (screenBottomRightY - screenTopLeftY).toString(),
+      fill: "none",
+      stroke: "#666",
+      "stroke-width": borderStrokeWidth.toString()
+    },
+    children: [],
+    value: ""
+  });
+  const cells = circuitJson.filter(
+    (elm) => elm.type === "schematic_table_cell" && elm.schematic_table_id === schematicTable.schematic_table_id
+  );
+  let currentX = topLeftX;
+  for (let i = 0; i < column_widths.length - 1; i++) {
+    currentX += column_widths[i];
+    let segmentStartY = topLeftY;
+    for (let j = 0; j < row_heights.length; j++) {
+      const segmentEndY = segmentStartY - row_heights[j];
+      const isMerged = cells.some(
+        (cell) => cell.start_column_index <= i && cell.end_column_index > i && cell.start_row_index <= j && cell.end_row_index >= j
+      );
+      if (!isMerged) {
+        const start = applyToPoint42(transform, { x: currentX, y: segmentStartY });
+        const end = applyToPoint42(transform, { x: currentX, y: segmentEndY });
+        svgObjects.push({
+          name: "line",
+          type: "element",
+          attributes: {
+            x1: start.x.toString(),
+            y1: start.y.toString(),
+            x2: end.x.toString(),
+            y2: end.y.toString(),
+            stroke: "#666",
+            "stroke-width": gridStrokeWidth.toString()
+          },
+          children: [],
+          value: ""
+        });
+      }
+      segmentStartY = segmentEndY;
+    }
+  }
+  let currentY = topLeftY;
+  for (let i = 0; i < row_heights.length - 1; i++) {
+    currentY -= row_heights[i];
+    let segmentStartX = topLeftX;
+    for (let j = 0; j < column_widths.length; j++) {
+      const segmentEndX = segmentStartX + column_widths[j];
+      const isMerged = cells.some(
+        (cell) => cell.start_row_index <= i && cell.end_row_index > i && cell.start_column_index <= j && cell.end_column_index >= j
+      );
+      if (!isMerged) {
+        const start = applyToPoint42(transform, {
+          x: segmentStartX,
+          y: currentY
+        });
+        const end = applyToPoint42(transform, { x: segmentEndX, y: currentY });
+        svgObjects.push({
+          name: "line",
+          type: "element",
+          attributes: {
+            x1: start.x.toString(),
+            y1: start.y.toString(),
+            x2: end.x.toString(),
+            y2: end.y.toString(),
+            stroke: "#666",
+            "stroke-width": gridStrokeWidth.toString()
+          },
+          children: [],
+          value: ""
+        });
+      }
+      segmentStartX = segmentEndX;
+    }
+  }
+  for (const cell of cells) {
+    if (cell.text) {
+      const cellWidth = column_widths.slice(cell.start_column_index, cell.end_column_index + 1).reduce((a, b) => a + b, 0);
+      const cellHeight = row_heights.slice(cell.start_row_index, cell.end_row_index + 1).reduce((a, b) => a + b, 0);
+      const cellTopLeftX = topLeftX + column_widths.slice(0, cell.start_column_index).reduce((a, b) => a + b, 0);
+      const cellTopLeftY = topLeftY - row_heights.slice(0, cell.start_row_index).reduce((a, b) => a + b, 0);
+      const { cell_padding = 0.2 } = schematicTable;
+      const horizontal_align = cell.horizontal_align ?? "center";
+      const vertical_align = cell.vertical_align ?? "middle";
+      let realTextAnchorPos = {
+        x: cellTopLeftX + cellWidth / 2,
+        y: cellTopLeftY - cellHeight / 2
+      };
+      if (horizontal_align === "left") {
+        realTextAnchorPos.x = cellTopLeftX + cell_padding;
+      } else if (horizontal_align === "right") {
+        realTextAnchorPos.x = cellTopLeftX + cellWidth - cell_padding;
+      }
+      if (vertical_align === "top") {
+        realTextAnchorPos.y = cellTopLeftY - cell_padding;
+      } else if (vertical_align === "bottom") {
+        realTextAnchorPos.y = cellTopLeftY - cellHeight + cell_padding;
+      }
+      const screenTextAnchorPos = applyToPoint42(transform, realTextAnchorPos);
+      const fontSize = getSchScreenFontSize(
+        transform,
+        "reference_designator",
+        cell.font_size
+      );
+      const textAnchorMap = {
+        left: "start",
+        center: "middle",
+        right: "end"
+      };
+      const dominantBaselineMap = {
+        top: "hanging",
+        middle: "middle",
+        bottom: "ideographic"
+      };
+      svgObjects.push({
+        name: "text",
+        type: "element",
+        attributes: {
+          x: screenTextAnchorPos.x.toString(),
+          y: screenTextAnchorPos.y.toString(),
+          "font-size": `${fontSize}px`,
+          "text-anchor": textAnchorMap[horizontal_align],
+          "dominant-baseline": dominantBaselineMap[vertical_align],
+          fill: colorMap2.schematic.sheet_label,
+          "font-family": "sans-serif"
+        },
+        children: [
+          {
+            type: "text",
+            value: cell.text,
+            name: "",
+            attributes: {},
+            children: []
+          }
+        ],
+        value: ""
+      });
+    }
+  }
+  return [
+    {
+      name: "g",
+      type: "element",
+      attributes: {
+        "data-schematic-table-id": schematicTable.schematic_table_id
+      },
+      children: svgObjects,
+      value: ""
+    }
+  ];
+};
+
 // lib/sch/convert-circuit-json-to-schematic-svg.ts
 function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const realBounds = getSchematicBoundsFromCircuitJson(circuitJson);
@@ -5482,6 +5786,7 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
   const schText = [];
   const voltageProbeSvgs = [];
   const schBoxSvgs = [];
+  const schTableSvgs = [];
   for (const elm of circuitJson) {
     if (elm.type === "schematic_debug_object") {
       schDebugObjectSvgs.push(
@@ -5539,6 +5844,15 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
           colorMap: colorMap2
         })
       );
+    } else if (elm.type === "schematic_table") {
+      schTableSvgs.push(
+        ...createSvgObjectsFromSchematicTable({
+          schematicTable: elm,
+          transform,
+          colorMap: colorMap2,
+          circuitJson
+        })
+      );
     }
   }
   svgChildren.push(
@@ -5548,7 +5862,8 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     ...schNetLabel,
     ...schText,
     ...schBoxSvgs,
-    ...voltageProbeSvgs
+    ...voltageProbeSvgs,
+    ...schTableSvgs
   );
   if (options?.labeledPoints) {
     svgChildren.push(
@@ -5621,18 +5936,18 @@ var circuitJsonToSchematicSvg = convertCircuitJsonToSchematicSvg;
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
 import { stringify as stringify4 } from "svgson";
 import {
-  applyToPoint as applyToPoint44,
+  applyToPoint as applyToPoint45,
   compose as compose11,
   scale as scale8,
   translate as translate11
 } from "transformation-matrix";
 
 // lib/pcb/svg-object-fns/convert-circuit-json-to-solder-paste-mask.ts
-import { applyToPoint as applyToPoint43 } from "transformation-matrix";
+import { applyToPoint as applyToPoint44 } from "transformation-matrix";
 function createSvgObjectsFromSolderPaste(solderPaste, ctx) {
   const { transform, layer: layerFilter } = ctx;
   if (layerFilter && solderPaste.layer !== layerFilter) return [];
-  const [x, y] = applyToPoint43(transform, [solderPaste.x, solderPaste.y]);
+  const [x, y] = applyToPoint44(transform, [solderPaste.x, solderPaste.y]);
   if (solderPaste.shape === "rect" || solderPaste.shape === "rotated_rect") {
     const width = solderPaste.width * Math.abs(transform.a);
     const height = solderPaste.height * Math.abs(transform.d);
@@ -5831,8 +6146,8 @@ function createSvgObjects3({ elm, ctx }) {
   }
 }
 function createSvgObjectFromPcbBoundary2(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint44(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint44(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint45(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint45(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);