altium-toolkit 1.0.2 → 1.0.7

package/src/ui/PcbTextPrimitiveRenderer.mjs

@@ -132,7 +132,7 @@ export class PcbTextPrimitiveRenderer {
             metrics.lineHeight
         )
         const rectX = -layout.anchorX
-        const rectY = layout.anchorY - layout.height
+        const rectY = -layout.anchorY
         const cornerRadius = Math.min(
             padding,
             layout.width / 2,
@@ -360,7 +360,21 @@ export class PcbTextPrimitiveRenderer {
             return null
         }
 
-        context.font = PcbTextPrimitiveRenderer.#buildCanvasFont(text, fontSize)
+        const canvasFont = PcbTextPrimitiveRenderer.#buildCanvasFont(
+            text,
+            fontSize
+        )
+        if (
+            !PcbTextPrimitiveRenderer.#canMeasureCanvasFont(
+                text,
+                canvasFont,
+                fontSize
+            )
+        ) {
+            return null
+        }
+
+        context.font = canvasFont
 
         const measured = lines.map((line) => context.measureText(line || ' '))
         const ascent = PcbTextPrimitiveRenderer.#resolveMeasuredExtent(
@@ -388,6 +402,29 @@ export class PcbTextPrimitiveRenderer {
         }
     }
 
+    /**
+     * Checks whether canvas text metrics can be trusted for the requested
+     * imported font.
+     * @param {{ fontMetrics?: { averageAdvanceWidth?: number, unitsPerEm?: number } }} text Text record.
+     * @param {string} canvasFont Full canvas font shorthand.
+     * @param {number} fontSize Text font size.
+     * @returns {boolean}
+     */
+    static #canMeasureCanvasFont(text, canvasFont, fontSize) {
+        const fonts = globalThis.document?.fonts
+        if (typeof fonts?.check === 'function') {
+            return fonts.check(
+                PcbTextPrimitiveRenderer.#buildPrimaryCanvasFont(text, fontSize)
+            )
+        }
+
+        if (PcbTextPrimitiveRenderer.#fontMetricsAverageWidthRatio(text)) {
+            return false
+        }
+
+        return Boolean(canvasFont)
+    }
+
     /**
      * Resolves a measured text extent with a stable fallback.
      * @param {TextMetrics[]} measured Browser text metrics.
@@ -420,6 +457,25 @@ export class PcbTextPrimitiveRenderer {
         return `${style} ${weight} ${fontSize}px ${family}`
     }
 
+    /**
+     * Builds a single-family font shorthand for readiness checks.
+     * @param {{ fontFamily?: string, fontName?: string, isBold?: boolean, fontWeight?: number, isItalic?: boolean }} text Text record.
+     * @param {number} fontSize Text font size.
+     * @returns {string}
+     */
+    static #buildPrimaryCanvasFont(text, fontSize) {
+        const weight =
+            text?.isBold || Number(text?.fontWeight) >= 600 ? '700' : '400'
+        const style = text?.isItalic ? 'italic' : 'normal'
+        const family = PcbTextPrimitiveRenderer.#quoteFontFamily(
+            PcbTextPrimitiveRenderer.#cleanFontFamily(
+                text?.fontFamily || text?.fontName
+            )
+        )
+
+        return `${style} ${weight} ${fontSize}px ${family}`
+    }
+
     /**
      * Builds a browser font-family stack matching the 3D TrueType path.
      * @param {unknown} family Font family value.

package/src/ui/SchematicContentLayout.mjs

@@ -195,7 +195,7 @@ export class SchematicContentLayout {
             ' ' +
             formatNumber(targetMinY) +
             ') scale(' +
-            formatNumber(scale) +
+            SchematicContentLayout.#formatScale(scale) +
             ') translate(' +
             formatNumber(-bounds.minX) +
             ' ' +
@@ -252,20 +252,28 @@ export class SchematicContentLayout {
             return ''
         }
 
-        const pivotX = margin
-        const pivotY = height - margin
         const topLimit = margin + contentPadding * 0.2
         const bottomLimit = height - margin - footerReserve
         const rightLimit = width - margin
+        const usedWidth = bounds.maxX - bounds.minX
+        const usedHeight = bounds.maxY - bounds.minY
+
+        if (usedWidth <= 0 || usedHeight <= 0) {
+            return ''
+        }
+
         const scale = Math.min(
             targetScale,
-            ...SchematicContentLayout.#resolvePivotScaleLimits(
-                bounds,
-                pivotX,
-                pivotY,
+            SchematicContentLayout.#resolveContentScaleLimit(
+                bounds.minX,
+                bounds.maxX,
                 margin,
+                rightLimit
+            ),
+            SchematicContentLayout.#resolveContentScaleLimit(
+                bounds.minY,
+                bounds.maxY,
                 topLimit,
-                rightLimit,
                 bottomLimit
             )
         )
@@ -274,10 +282,18 @@ export class SchematicContentLayout {
             return ''
         }
 
-        const projectedMinX = pivotX + (bounds.minX - pivotX) * scale
-        const projectedMaxX = pivotX + (bounds.maxX - pivotX) * scale
-        const projectedMinY = pivotY + (bounds.minY - pivotY) * scale
-        const projectedMaxY = pivotY + (bounds.maxY - pivotY) * scale
+        const targetMinX =
+            SchematicContentLayout.#resolveCenteredContentTargetMinX(
+                bounds,
+                scale,
+                margin,
+                rightLimit
+            )
+        const projectedMinX = targetMinX
+        const projectedMaxX = targetMinX + usedWidth * scale
+        const targetMinY = bottomLimit - usedHeight * scale
+        const projectedMinY = targetMinY
+        const projectedMaxY = bottomLimit
 
         if (
             projectedMinX < margin - 0.01 ||
@@ -290,19 +306,73 @@ export class SchematicContentLayout {
 
         return (
             ' transform="translate(' +
-            formatNumber(pivotX) +
+            formatNumber(targetMinX) +
             ' ' +
-            formatNumber(pivotY) +
+            formatNumber(targetMinY) +
             ') scale(' +
-            formatNumber(scale) +
+            SchematicContentLayout.#formatScale(scale) +
             ') translate(' +
-            formatNumber(-pivotX) +
+            formatNumber(-bounds.minX) +
             ' ' +
-            formatNumber(-pivotY) +
+            formatNumber(-bounds.minY) +
             ')"'
         )
     }
 
+    /**
+     * Resolves one scale cap that keeps a horizontally centered content
+     * envelope inside the sheet frame.
+     * @param {number} minCoordinate
+     * @param {number} maxCoordinate
+     * @param {number} minLimit
+     * @param {number} maxLimit
+     * @returns {number}
+     */
+    static #resolveContentScaleLimit(
+        minCoordinate,
+        maxCoordinate,
+        minLimit,
+        maxLimit
+    ) {
+        const usedWidth = maxCoordinate - minCoordinate
+        const availableWidth = maxLimit - minLimit
+
+        return usedWidth > 0 && availableWidth > 0
+            ? availableWidth / usedWidth
+            : Infinity
+    }
+
+    /**
+     * Formats SVG transform scales with enough precision to avoid visible
+     * placement drift on large schematic sheets.
+     * @param {number} value
+     * @returns {string}
+     */
+    static #formatScale(value) {
+        return Number(value).toFixed(4).replace(/0+$/, '').replace(/\.$/, '')
+    }
+
+    /**
+     * Resolves the target SVG x-coordinate for a scaled content envelope.
+     * @param {{ minX: number, maxX: number }} bounds
+     * @param {number} scale
+     * @param {number} leftLimit
+     * @param {number} rightLimit
+     * @returns {number}
+     */
+    static #resolveCenteredContentTargetMinX(
+        bounds,
+        scale,
+        leftLimit,
+        rightLimit
+    ) {
+        const scaledWidth = (bounds.maxX - bounds.minX) * scale
+        const availableWidth = rightLimit - leftLimit
+        const remainingWidth = Math.max(availableWidth - scaledWidth, 0)
+
+        return leftLimit + remainingWidth / 2
+    }
+
     /**
      * Resolves per-edge maximum scale factors for a bottom-left pivot.
      * @param {{ minX: number, minY: number, maxX: number, maxY: number }} bounds
@@ -436,11 +506,43 @@ export class SchematicContentLayout {
         const heightSlackRatio =
             (matchingSheet.height - requiredHeight) / requiredHeight
 
-        return widthSlackRatio <= RELAXED_STANDARD_PAGE_MAX_SLACK_RATIO &&
-            heightSlackRatio <= RELAXED_STANDARD_PAGE_MAX_SLACK_RATIO &&
-            matchingSheet.width < width
-            ? matchingSheet
-            : null
+        if (
+            widthSlackRatio > RELAXED_STANDARD_PAGE_MAX_SLACK_RATIO ||
+            heightSlackRatio > RELAXED_STANDARD_PAGE_MAX_SLACK_RATIO ||
+            matchingSheet.width >= width
+        ) {
+            return null
+        }
+
+        return {
+            ...matchingSheet,
+            width: SchematicContentLayout.#resolveTightVirtualDimension(
+                requiredWidth,
+                matchingSheet.width,
+                margin
+            )
+        }
+    }
+
+    /**
+     * Drops near-zero standard-page rounding slack from the scale axis so
+     * custom sheets that almost fill a standard source size do not render with
+     * a visible artificial gutter.
+     * @param {number} requiredDimension
+     * @param {number} candidateDimension
+     * @param {number} margin
+     * @returns {number}
+     */
+    static #resolveTightVirtualDimension(
+        requiredDimension,
+        candidateDimension,
+        margin
+    ) {
+        const slack = candidateDimension - requiredDimension
+
+        return slack > 0 && slack <= margin
+            ? requiredDimension
+            : candidateDimension
     }
 
     /**

package/src/ui/SchematicJunctionRenderer.mjs

@@ -18,6 +18,7 @@ export class SchematicJunctionRenderer {
      * @param {{ x: number, y: number, width: number, direction?: 'left' | 'right' | 'up' | 'down' }[]} [ports]
      * @param {{ x: number, y: number, style?: number, powerPortDirection?: 'up' | 'down' | 'left' | 'right' }[]} [powerPorts]
      * @param {number} sheetHeight
+     * @param {{ x: number, y: number }[]} [authoredJunctions]
      * @returns {string}
      */
     static buildMarkup(
@@ -25,13 +26,15 @@ export class SchematicJunctionRenderer {
         crosses,
         ports = [],
         powerPorts = [],
-        sheetHeight
+        sheetHeight,
+        authoredJunctions = []
     ) {
         return SchematicJunctionRenderer.#resolveJunctions(
             lines,
             crosses,
             ports,
-            powerPorts
+            powerPorts,
+            authoredJunctions
         )
             .map(
                 (junction) =>
@@ -57,9 +60,16 @@ export class SchematicJunctionRenderer {
      * @param {{ x: number, y: number }[]} crosses
      * @param {{ x: number, y: number, width: number, direction?: 'left' | 'right' | 'up' | 'down' }[]} ports
      * @param {{ x: number, y: number, style?: number, powerPortDirection?: 'up' | 'down' | 'left' | 'right' }[]} powerPorts
+     * @param {{ x: number, y: number }[]} authoredJunctions
      * @returns {{ x: number, y: number, color: string }[]}
      */
-    static #resolveJunctions(lines, crosses, ports, powerPorts) {
+    static #resolveJunctions(
+        lines,
+        crosses,
+        ports,
+        powerPorts,
+        authoredJunctions
+    ) {
         const wireLines = lines.filter((line) =>
             SchematicJunctionRenderer.#isElectricalWireLine(line)
         )
@@ -69,6 +79,11 @@ export class SchematicJunctionRenderer {
         const visiblePowerPorts = powerPorts.filter((powerPort) =>
             SchematicJunctionRenderer.#isDrawablePowerPort(powerPort)
         )
+        const authoredJunctionKeys = new Set(
+            authoredJunctions.map((junction) =>
+                SchematicJunctionRenderer.#pointKey(junction)
+            )
+        )
 
         return SchematicJunctionRenderer.#collectCandidatePoints(
             wireLines,
@@ -77,6 +92,9 @@ export class SchematicJunctionRenderer {
         )
             .filter(
                 (point) =>
+                    !authoredJunctionKeys.has(
+                        SchematicJunctionRenderer.#pointKey(point)
+                    ) &&
                     !SchematicJunctionRenderer.#hasNearbyCross(point, crosses)
             )
             .flatMap((point) => {

package/src/ui/SchematicNoteRenderer.mjs

@@ -15,7 +15,7 @@ const MINIMUM_NOTE_TEXT_SIZE = 4
 export class SchematicNoteRenderer {
     /**
      * Builds one boxed schematic note/callout with wrapped text rows.
-     * @param {{ x: number, y: number, color: string, fontSize?: number, fontFamily?: string, fontWeight?: number, cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }} text
+     * @param {{ x: number, y: number, color: string, fontSize?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string, cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }} text
      * @param {number} sheetHeight
      * @returns {string}
      */
@@ -52,6 +52,18 @@ export class SchematicNoteRenderer {
         )
         const noteStroke = text.showBorder ? borderColor : 'none'
         const noteSourceLines = text.noteLines || []
+        const compactSingleLineNote =
+            SchematicNoteRenderer.#isCompactSingleLineNote(
+                noteSourceLines,
+                height,
+                requestedTextSize
+            )
+        const horizontalTextMargin =
+            SchematicNoteRenderer.#resolveHorizontalTextMargin(
+                textMargin,
+                compactSingleLineNote,
+                text
+            )
         const verticalTextMargin =
             SchematicNoteRenderer.#resolveVerticalTextMargin(
                 textMargin,
@@ -60,14 +72,10 @@ export class SchematicNoteRenderer {
             )
         const layout = SchematicNoteRenderer.#resolveTextLayout(
             noteSourceLines,
-            Math.max(width - textMargin * 2, requestedTextSize),
+            Math.max(width - horizontalTextMargin * 2, requestedTextSize),
             Math.max(height - verticalTextMargin * 2, requestedTextSize),
             requestedTextSize,
-            SchematicNoteRenderer.#isCompactSingleLineNote(
-                noteSourceLines,
-                height,
-                requestedTextSize
-            )
+            compactSingleLineNote
         )
         const noteLines = layout.noteLines
         const textSize = layout.textSize
@@ -80,10 +88,11 @@ export class SchematicNoteRenderer {
                     left,
                     right,
                     top,
-                    textMargin,
+                    horizontalTextMargin,
                     verticalTextMargin,
                     lineHeight,
                     textSize,
+                    compactSingleLineNote,
                     text
                 )
             )
@@ -310,6 +319,25 @@ export class SchematicNoteRenderer {
         return visibleLineCount === 1 && height <= requestedTextSize * 1.5
     }
 
+    /**
+     * Resolves horizontal text padding for one note box.
+     * @param {number} textMargin
+     * @param {boolean} compactSingleLineNote
+     * @param {{ showBorder?: boolean }} text
+     * @returns {number}
+     */
+    static #resolveHorizontalTextMargin(
+        textMargin,
+        compactSingleLineNote,
+        text
+    ) {
+        if (compactSingleLineNote && text.showBorder === false) {
+            return 0
+        }
+
+        return textMargin
+    }
+
     /**
      * Reduces vertical padding for short note rectangles so readable text is
      * centered instead of scaled down to satisfy the default margin.
@@ -426,7 +454,8 @@ export class SchematicNoteRenderer {
      * @param {number} verticalTextMargin
      * @param {number} lineHeight
      * @param {number} textSize
-     * @param {{ color: string, fontFamily?: string, fontWeight?: number }} text
+     * @param {boolean} compactSingleLineNote
+     * @param {{ color: string, fontFamily?: string, fontWeight?: number, fontStyle?: string }} text
      * @returns {string}
      */
     static #buildNoteLineMarkup(
@@ -439,10 +468,18 @@ export class SchematicNoteRenderer {
         verticalTextMargin,
         lineHeight,
         textSize,
+        compactSingleLineNote,
         text
     ) {
         const x = left + horizontalTextMargin
-        const y = top + verticalTextMargin + textSize + index * lineHeight
+        const y =
+            top +
+            verticalTextMargin +
+            SchematicNoteRenderer.#resolveBaselineOffset(
+                textSize,
+                compactSingleLineNote
+            ) +
+            index * lineHeight
 
         if (/^_+$/.test(String(line || '').trim())) {
             return (
@@ -483,9 +520,37 @@ export class SchematicNoteRenderer {
             escapeHtml(text.fontFamily || 'Times New Roman') +
             '" font-weight="' +
             formatNumber(text.fontWeight || 400) +
+            SchematicNoteRenderer.#buildFontStyleAttribute(text.fontStyle) +
             '" xml:space="preserve">' +
             escapeHtml(line) +
             '</text>'
         )
     }
+
+    /**
+     * Builds an optional note font-style attribute.
+     * @param {string | undefined} fontStyle
+     * @returns {string}
+     */
+    static #buildFontStyleAttribute(fontStyle) {
+        if (!fontStyle || fontStyle === 'normal') {
+            return ''
+        }
+
+        return '" font-style="' + escapeHtml(fontStyle)
+    }
+
+    /**
+     * Resolves the text baseline offset for a rendered note line.
+     * @param {number} textSize
+     * @param {boolean} compactSingleLineNote
+     * @returns {number}
+     */
+    static #resolveBaselineOffset(textSize, compactSingleLineNote) {
+        if (compactSingleLineNote) {
+            return textSize * 0.85
+        }
+
+        return textSize
+    }
 }

package/src/ui/SchematicPinSvgRenderer.mjs

@@ -66,7 +66,8 @@ export class SchematicPinSvgRenderer {
                 const defaultNumberX =
                     geometry.bodyX -
                     SchematicPinSvgRenderer.#resolveHorizontalPinNumberClearance(
-                        outerMarkerStyle
+                        outerMarkerStyle,
+                        pin
                     )
                 const numberX = hasExplicitOwnerPinName
                     ? SchematicOwnerPinLabelLayout.resolveExplicitOwnerPinNumberX(
@@ -98,7 +99,11 @@ export class SchematicPinSvgRenderer {
                 texts.push(
                     SchematicPinSvgRenderer.#buildPinNameTextMarkup(
                         'schematic-pin-name',
-                        geometry.bodyX + (labelMode === 'name-only' ? 10 : 4),
+                        geometry.bodyX +
+                            SchematicPinSvgRenderer.#resolveHorizontalPinNameInset(
+                                pin,
+                                labelMode
+                            ),
                         projectedY + 3,
                         pin,
                         labelColor,
@@ -114,7 +119,8 @@ export class SchematicPinSvgRenderer {
                 const defaultNumberX =
                     geometry.bodyX +
                     SchematicPinSvgRenderer.#resolveHorizontalPinNumberClearance(
-                        outerMarkerStyle
+                        outerMarkerStyle,
+                        pin
                     )
                 const numberX = hasExplicitOwnerPinName
                     ? SchematicOwnerPinLabelLayout.resolveExplicitOwnerPinNumberX(
@@ -146,7 +152,11 @@ export class SchematicPinSvgRenderer {
                 texts.push(
                     SchematicPinSvgRenderer.#buildPinNameTextMarkup(
                         'schematic-pin-name',
-                        geometry.bodyX - (labelMode === 'name-only' ? 10 : 4),
+                        geometry.bodyX -
+                            SchematicPinSvgRenderer.#resolveHorizontalPinNameInset(
+                                pin,
+                                labelMode
+                            ),
                         projectedY + 3,
                         pin,
                         labelColor,
@@ -363,11 +373,12 @@ export class SchematicPinSvgRenderer {
     }
 
     /**
-     * Returns the horizontal pin-number clearance needed by an authored marker.
+     * Returns the horizontal pin-number clearance needed by the pin geometry.
      * @param {'single-in' | 'single-out' | 'double' | null} markerStyle
+     * @param {{ length?: number }} pin
      * @returns {number}
      */
-    static #resolveHorizontalPinNumberClearance(markerStyle) {
+    static #resolveHorizontalPinNumberClearance(markerStyle, pin) {
         switch (markerStyle) {
             case 'double':
                 return 17
@@ -375,10 +386,40 @@ export class SchematicPinSvgRenderer {
             case 'single-out':
                 return 8
             default:
-                return 2
+                return SchematicPinSvgRenderer.#resolveLongPinInset(pin, 2)
         }
     }
 
+    /**
+     * Returns the horizontal pin-name inset used inside the symbol body.
+     * @param {{ length?: number }} pin
+     * @param {'hidden' | 'number-only' | 'name-only' | 'name-and-number'} labelMode
+     * @returns {number}
+     */
+    static #resolveHorizontalPinNameInset(pin, labelMode) {
+        if (labelMode === 'name-only') {
+            return 10
+        }
+
+        return SchematicPinSvgRenderer.#resolveLongPinInset(pin, 4)
+    }
+
+    /**
+     * Adds extra text clearance for long connector-style pin stubs.
+     * @param {{ length?: number }} pin
+     * @param {number} fallback
+     * @returns {number}
+     */
+    static #resolveLongPinInset(pin, fallback) {
+        const length = Math.abs(Number(pin?.length || 0))
+
+        if (length < 30) {
+            return fallback
+        }
+
+        return fallback === 2 ? 10 : 8
+    }
+
     /**
      * Builds one or two authored outer-marker polygons for one horizontal pin.
      * @param {number} bodyX