altium-toolkit 1.1.2 → 1.1.22

package/src/ui/SchematicPinSvgRenderer.mjs

@@ -22,6 +22,9 @@ export class SchematicPinSvgRenderer {
      * @param {Set<string>} rotatedVerticalNumberOwners
      * @param {Set<string>} explicitOwnerPinNameLabels
      * @param {Map<string, number>} explicitOwnerPinLabelOffsets
+     * @param {Map<string, 'left' | 'right'>} compactExternalNumberLabelSides
+     * @param {Map<string, { left: number, right: number }>} internalNumberLabelBoxes
+     * @param {Set<string>} overlappingExternalNumberLabelKeys
      * @returns {string}
      */
     static buildMarkup(
@@ -30,7 +33,10 @@ export class SchematicPinSvgRenderer {
         sheet,
         rotatedVerticalNumberOwners,
         explicitOwnerPinNameLabels,
-        explicitOwnerPinLabelOffsets
+        explicitOwnerPinLabelOffsets,
+        compactExternalNumberLabelSides = new Map(),
+        internalNumberLabelBoxes = new Map(),
+        overlappingExternalNumberLabelKeys = new Set()
     ) {
         const geometry =
             SchematicPinSvgRenderer.#projectSchematicPinGeometry(pin)
@@ -49,6 +55,11 @@ export class SchematicPinSvgRenderer {
         const labelMode = pin.labelMode || 'name-and-number'
         const outerMarkerStyle =
             SchematicPinSvgRenderer.#resolveSchematicOuterPinMarkerStyle(pin)
+        const markerStyle =
+            outerMarkerStyle ||
+            SchematicPinSvgRenderer.#resolveSchematicElectricalPinMarkerStyle(
+                pin
+            )
         const rotateTopNumber =
             pin.orientation === 'top' &&
             rotatedVerticalNumberOwners.has(String(pin.ownerIndex || ''))
@@ -60,14 +71,47 @@ export class SchematicPinSvgRenderer {
         const hasExplicitOwnerPinName =
             Boolean(pin.name) &&
             explicitOwnerPinNameLabels.has(ownerPinLabelKey)
+        const compactExternalNumberLabelSide =
+            compactExternalNumberLabelSides.get(String(pin.ownerIndex || '')) ||
+            null
+        const internalNumberLabelBox =
+            internalNumberLabelBoxes.get(String(pin.ownerIndex || '')) || null
+        const shouldRenderExternalNumber =
+            !overlappingExternalNumberLabelKeys.has(
+                SchematicOwnerPinLabelLayout.buildOwnerPinLabelKey(
+                    pin.ownerIndex,
+                    pin.designator
+                )
+            )
 
         if (pin.orientation === 'left') {
             if (labelMode !== 'hidden' && labelMode !== 'name-only') {
+                const internalNumberPlacement =
+                    SchematicPinSvgRenderer.#resolveInternalHorizontalNumberPlacement(
+                        pin,
+                        internalNumberLabelBox
+                    )
+                if (internalNumberPlacement) {
+                    texts.push(
+                        SchematicPinSvgRenderer.#buildPinNameTextMarkup(
+                            'schematic-pin-name',
+                            internalNumberPlacement.x,
+                            projectedY + 3,
+                            pin,
+                            labelColor,
+                            internalNumberPlacement.anchor,
+                            textOptions
+                        )
+                    )
+                }
+
                 const defaultNumberX =
-                    geometry.bodyX -
-                    SchematicPinSvgRenderer.#resolveHorizontalPinNumberClearance(
-                        outerMarkerStyle,
-                        pin
+                    SchematicPinSvgRenderer.#resolveExternalHorizontalNumberX(
+                        pin,
+                        geometry,
+                        markerStyle,
+                        compactExternalNumberLabelSide,
+                        internalNumberLabelBox
                     )
                 const numberX = hasExplicitOwnerPinName
                     ? SchematicOwnerPinLabelLayout.resolveExplicitOwnerPinNumberX(
@@ -76,25 +120,31 @@ export class SchematicPinSvgRenderer {
                           explicitOwnerPinLabelOffsets
                       )
                     : defaultNumberX
-                texts.push(
-                    createSvgText(
-                        'schematic-pin-number',
-                        numberX,
-                        projectedY - 1,
-                        pin.designator,
-                        labelColor,
-                        'end',
-                        textOptions
+                if (shouldRenderExternalNumber) {
+                    texts.push(
+                        createSvgText(
+                            'schematic-pin-number',
+                            numberX,
+                            projectedY - 1,
+                            pin.designator,
+                            labelColor,
+                            SchematicPinSvgRenderer.#resolveExternalHorizontalNumberAnchor(
+                                pin,
+                                markerStyle
+                            ),
+                            textOptions
+                        )
                     )
-                )
+                }
             }
 
             if (
                 labelMode !== 'hidden' &&
                 labelMode !== 'number-only' &&
-                pin.name &&
-                pin.name !== pin.designator &&
-                !hasExplicitOwnerPinName
+                SchematicPinSvgRenderer.#shouldRenderHorizontalPinName(
+                    pin,
+                    hasExplicitOwnerPinName
+                )
             ) {
                 texts.push(
                     SchematicPinSvgRenderer.#buildPinNameTextMarkup(
@@ -116,11 +166,32 @@ export class SchematicPinSvgRenderer {
 
         if (pin.orientation === 'right') {
             if (labelMode !== 'hidden' && labelMode !== 'name-only') {
+                const internalNumberPlacement =
+                    SchematicPinSvgRenderer.#resolveInternalHorizontalNumberPlacement(
+                        pin,
+                        internalNumberLabelBox
+                    )
+                if (internalNumberPlacement) {
+                    texts.push(
+                        SchematicPinSvgRenderer.#buildPinNameTextMarkup(
+                            'schematic-pin-name',
+                            internalNumberPlacement.x,
+                            projectedY + 3,
+                            pin,
+                            labelColor,
+                            internalNumberPlacement.anchor,
+                            textOptions
+                        )
+                    )
+                }
+
                 const defaultNumberX =
-                    geometry.bodyX +
-                    SchematicPinSvgRenderer.#resolveHorizontalPinNumberClearance(
-                        outerMarkerStyle,
-                        pin
+                    SchematicPinSvgRenderer.#resolveExternalHorizontalNumberX(
+                        pin,
+                        geometry,
+                        markerStyle,
+                        compactExternalNumberLabelSide,
+                        internalNumberLabelBox
                     )
                 const numberX = hasExplicitOwnerPinName
                     ? SchematicOwnerPinLabelLayout.resolveExplicitOwnerPinNumberX(
@@ -129,25 +200,31 @@ export class SchematicPinSvgRenderer {
                           explicitOwnerPinLabelOffsets
                       )
                     : defaultNumberX
-                texts.push(
-                    createSvgText(
-                        'schematic-pin-number',
-                        numberX,
-                        projectedY - 1,
-                        pin.designator,
-                        labelColor,
-                        'start',
-                        textOptions
+                if (shouldRenderExternalNumber) {
+                    texts.push(
+                        createSvgText(
+                            'schematic-pin-number',
+                            numberX,
+                            projectedY - 1,
+                            pin.designator,
+                            labelColor,
+                            SchematicPinSvgRenderer.#resolveExternalHorizontalNumberAnchor(
+                                pin,
+                                markerStyle
+                            ),
+                            textOptions
+                        )
                     )
-                )
+                }
             }
 
             if (
                 labelMode !== 'hidden' &&
                 labelMode !== 'number-only' &&
-                pin.name &&
-                pin.name !== pin.designator &&
-                !hasExplicitOwnerPinName
+                SchematicPinSvgRenderer.#shouldRenderHorizontalPinName(
+                    pin,
+                    hasExplicitOwnerPinName
+                )
             ) {
                 texts.push(
                     SchematicPinSvgRenderer.#buildPinNameTextMarkup(
@@ -175,7 +252,12 @@ export class SchematicPinSvgRenderer {
             texts.push(
                 createSvgText(
                     'schematic-pin-number',
-                    geometry.bodyX - 2,
+                    compactExternalNumberLabelSide
+                        ? SchematicPinSvgRenderer.#resolveCompactExternalVerticalNumberX(
+                              geometry,
+                              compactExternalNumberLabelSide
+                          )
+                        : geometry.bodyX - 2,
                     pin.orientation === 'top'
                         ? projectedInnerY - 6
                         : projectedInnerY + 7,
@@ -230,12 +312,7 @@ export class SchematicPinSvgRenderer {
             '" y2="' +
             formatNumber(projectedOuterY) +
             '" stroke="' +
-            escapeHtml(
-                SchematicColorResolver.resolveColor(
-                    pin.color,
-                    '--schematic-accent-ink-color'
-                )
-            ) +
+            escapeHtml(SchematicPinSvgRenderer.#resolvePinStrokeColor(pin)) +
             '" />' +
             markerMarkup +
             texts.join('') +
@@ -262,6 +339,19 @@ export class SchematicPinSvgRenderer {
             )
         }
 
+        const electricalMarkerStyle =
+            SchematicPinSvgRenderer.#resolveSchematicElectricalPinMarkerStyle(
+                pin
+            )
+        if (electricalMarkerStyle) {
+            return SchematicPinSvgRenderer.#buildOuterPinMarkerMarkup(
+                pin,
+                geometry,
+                sheetHeight,
+                electricalMarkerStyle
+            )
+        }
+
         if (Number(pin.electrical || 0) !== 1) {
             return ''
         }
@@ -324,7 +414,7 @@ export class SchematicPinSvgRenderer {
      * @param {{ orientation: 'left' | 'right' | 'top' | 'bottom', labelColor?: string, color: string }} pin
      * @param {{ bodyX: number, bodyY: number }} geometry
      * @param {number} sheetHeight
-     * @param {'single-in' | 'single-out' | 'double'} markerStyle
+     * @param {'single-in' | 'single-out' | 'double' | 'cross'} markerStyle
      * @returns {string}
      */
     static #buildOuterPinMarkerMarkup(pin, geometry, sheetHeight, markerStyle) {
@@ -339,6 +429,15 @@ export class SchematicPinSvgRenderer {
             '--schematic-text-color'
         )
 
+        if (markerStyle === 'cross') {
+            return SchematicPinSvgRenderer.#buildOuterPinCrossMarkerMarkup(
+                geometry.bodyX,
+                projectedY,
+                pin.orientation,
+                strokeColor
+            )
+        }
+
         const polygons = SchematicPinSvgRenderer.#buildOuterPinMarkerPolygons(
             geometry.bodyX,
             projectedY,
@@ -374,22 +473,51 @@ export class SchematicPinSvgRenderer {
 
     /**
      * Returns the horizontal pin-number clearance needed by the pin geometry.
-     * @param {'single-in' | 'single-out' | 'double' | null} markerStyle
-     * @param {{ length?: number }} pin
+     * @param {'single-in' | 'single-out' | 'double' | 'cross' | null} markerStyle
+     * @param {{ length?: number, electrical?: number }} pin
      * @returns {number}
      */
     static #resolveHorizontalPinNumberClearance(markerStyle, pin) {
         switch (markerStyle) {
             case 'double':
-                return 17
+                return 21
+            case 'cross':
+                return 9
             case 'single-in':
             case 'single-out':
                 return 8
             default:
+                if (Number(pin?.electrical || 0) === 1) {
+                    return 16
+                }
+
                 return SchematicPinSvgRenderer.#resolveLongPinInset(pin, 2)
         }
     }
 
+    /**
+     * Returns whether a horizontal pin name should be rendered inside the body.
+     * Numeric name/designator matches are duplicate pin numbers; nonnumeric
+     * matches such as PAD are valid body labels.
+     * @param {{ name?: string, designator?: string }} pin Pin primitive.
+     * @param {boolean} hasExplicitOwnerPinName Whether an explicit owner text already draws the label.
+     * @returns {boolean}
+     */
+    static #shouldRenderHorizontalPinName(pin, hasExplicitOwnerPinName) {
+        const name = String(pin?.name || '').trim()
+        const designator = String(pin?.designator || '').trim()
+
+        if (!name || hasExplicitOwnerPinName) {
+            return false
+        }
+
+        if (name !== designator) {
+            return true
+        }
+
+        return !/^\d+$/u.test(name)
+    }
+
     /**
      * Returns the horizontal pin-name inset used inside the symbol body.
      * @param {{ length?: number }} pin
@@ -401,7 +529,7 @@ export class SchematicPinSvgRenderer {
             return 10
         }
 
-        return SchematicPinSvgRenderer.#resolveLongPinInset(pin, 4)
+        return SchematicPinSvgRenderer.#resolveLongPinInset(pin, 7)
     }
 
     /**
@@ -420,6 +548,192 @@ export class SchematicPinSvgRenderer {
         return fallback === 2 ? 10 : 8
     }
 
+    /**
+     * Places synthetic horizontal pin numbers outside the symbol body. Owner
+     * bodies with internal numeric labels need a stub-side offset so the
+     * outside contact number does not collapse onto the inside duplicate.
+     * @param {{ length?: number, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number }} pin
+     * @param {{ bodyX: number }} geometry
+     * @param {'single-in' | 'single-out' | 'double' | 'cross' | null} markerStyle
+     * @param {'left' | 'right' | null} compactExternalNumberLabelSide
+     * @param {{ left: number, right: number } | null} internalNumberLabelBox
+     * @returns {number}
+     */
+    static #resolveExternalHorizontalNumberX(
+        pin,
+        geometry,
+        markerStyle,
+        compactExternalNumberLabelSide,
+        internalNumberLabelBox
+    ) {
+        const clearance =
+            SchematicPinSvgRenderer.#resolveHorizontalPinNumberClearance(
+                markerStyle,
+                pin
+            )
+        const offset =
+            compactExternalNumberLabelSide || internalNumberLabelBox
+                ? Math.max(
+                      clearance,
+                      SchematicPinSvgRenderer.#resolveCompactExternalHorizontalNumberOffset(
+                          pin
+                      )
+                  )
+                : clearance
+
+        if (pin.orientation === 'left') {
+            return geometry.bodyX - offset
+        }
+
+        if (pin.orientation === 'right') {
+            return geometry.bodyX + offset
+        }
+
+        return geometry.bodyX
+    }
+
+    /**
+     * Resolves the text edge used for external horizontal pin numbers.
+     * Double/electrical marker labels are authored from the route side back
+     * toward the marker, while ordinary pins extend away from the body.
+     * @param {{ orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number }} pin Pin primitive.
+     * @param {'single-in' | 'single-out' | 'double' | 'cross' | null} markerStyle Marker style.
+     * @returns {'start' | 'end'}
+     */
+    static #resolveExternalHorizontalNumberAnchor(pin, markerStyle) {
+        const routeFacing =
+            markerStyle === 'double' ||
+            (!markerStyle && Number(pin?.electrical || 0) === 1)
+
+        if (routeFacing) {
+            return pin.orientation === 'left' ? 'start' : 'end'
+        }
+
+        return pin.orientation === 'left' ? 'end' : 'start'
+    }
+
+    /**
+     * Places numeric-only labels just inside a rectangular owner body.
+     * @param {{ name?: string, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
+     * @param {{ left: number, right: number } | null} box
+     * @returns {{ x: number, anchor: 'middle' } | null}
+     */
+    static #resolveInternalHorizontalNumberPlacement(pin, box) {
+        if (
+            !box ||
+            (pin.orientation !== 'left' && pin.orientation !== 'right') ||
+            !/^\d+$/u.test(String(pin.name || '').trim())
+        ) {
+            return null
+        }
+
+        const left = Number(box.left)
+        const right = Number(box.right)
+
+        if (
+            !Number.isFinite(left) ||
+            !Number.isFinite(right) ||
+            right <= left
+        ) {
+            return null
+        }
+
+        const inset = Math.min(10, Math.max(6, (right - left) / 6))
+
+        return {
+            x: pin.orientation === 'left' ? left + inset : right - inset,
+            anchor: 'middle'
+        }
+    }
+
+    /**
+     * Places compact owner-drawn side pin numbers near the external pin stub.
+     * @param {{ length?: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
+     * @param {{ bodyX: number }} geometry
+     * @returns {number}
+     */
+    static #resolveCompactExternalHorizontalNumberX(pin, geometry) {
+        const offset =
+            SchematicPinSvgRenderer.#resolveCompactExternalHorizontalNumberOffset(
+                pin
+            )
+
+        if (pin.orientation === 'left') {
+            return geometry.bodyX - offset
+        }
+
+        if (pin.orientation === 'right') {
+            return geometry.bodyX + offset
+        }
+
+        return geometry.bodyX
+    }
+
+    /**
+     * Resolves a stub-side offset for compact external horizontal numbers.
+     * @param {{ length?: number }} pin
+     * @returns {number}
+     */
+    static #resolveCompactExternalHorizontalNumberOffset(pin) {
+        const length = Math.abs(Number(pin.length || 0))
+
+        return Math.max(8, Math.min(length - 6, 12))
+    }
+
+    /**
+     * Places compact owner-drawn vertical pin numbers on the same side as the
+     * horizontal terminal contacts.
+     * @param {{ bodyX: number }} geometry
+     * @param {'left' | 'right'} side
+     * @returns {number}
+     */
+    static #resolveCompactExternalVerticalNumberX(geometry, side) {
+        return geometry.bodyX + (side === 'left' ? -10 : 10)
+    }
+
+    /**
+     * Builds an authored outer pin cross marker.
+     * @param {number} bodyX
+     * @param {number} projectedY
+     * @param {'left' | 'right' | 'top' | 'bottom'} orientation
+     * @param {string} strokeColor
+     * @returns {string}
+     */
+    static #buildOuterPinCrossMarkerMarkup(
+        bodyX,
+        projectedY,
+        orientation,
+        strokeColor
+    ) {
+        const direction = orientation === 'left' ? 1 : -1
+        const centerX = bodyX - direction * 8
+        const halfSize = 3
+
+        return (
+            '<g class="schematic-pin-marker"><line x1="' +
+            formatNumber(centerX - halfSize) +
+            '" y1="' +
+            formatNumber(projectedY - halfSize) +
+            '" x2="' +
+            formatNumber(centerX + halfSize) +
+            '" y2="' +
+            formatNumber(projectedY + halfSize) +
+            '" stroke="' +
+            escapeHtml(strokeColor) +
+            '" stroke-width="0.75" vector-effect="non-scaling-stroke" /><line x1="' +
+            formatNumber(centerX - halfSize) +
+            '" y1="' +
+            formatNumber(projectedY + halfSize) +
+            '" x2="' +
+            formatNumber(centerX + halfSize) +
+            '" y2="' +
+            formatNumber(projectedY - halfSize) +
+            '" stroke="' +
+            escapeHtml(strokeColor) +
+            '" stroke-width="0.75" vector-effect="non-scaling-stroke" /></g>'
+        )
+    }
+
     /**
      * Builds one or two authored outer-marker polygons for one horizontal pin.
      * @param {number} bodyX
@@ -469,7 +783,7 @@ export class SchematicPinSvgRenderer {
     /**
      * Resolves one authored outer pin marker style from the stored symbol flag.
      * @param {{ symbolOuter?: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
-     * @returns {'single-in' | 'single-out' | 'double' | null}
+     * @returns {'single-in' | 'single-out' | 'double' | 'cross' | null}
      */
     static #resolveSchematicOuterPinMarkerStyle(pin) {
         if (pin.orientation !== 'left' && pin.orientation !== 'right') {
@@ -483,6 +797,8 @@ export class SchematicPinSvgRenderer {
                 return 'single-out'
             case 2:
                 return 'single-in'
+            case 6:
+                return 'cross'
             case 34:
                 return 'double'
             default:
@@ -490,6 +806,39 @@ export class SchematicPinSvgRenderer {
         }
     }
 
+    /**
+     * Resolves marker styles derived from the pin electrical type. The
+     * bidirectional type keeps its legacy two-triangle geometry path.
+     * @param {{ electrical?: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
+     * @returns {'single-in' | 'single-out' | null}
+     */
+    static #resolveSchematicElectricalPinMarkerStyle(pin) {
+        if (pin.orientation !== 'left' && pin.orientation !== 'right') {
+            return null
+        }
+
+        switch (Number(pin.electrical)) {
+            case 0:
+                return 'single-in'
+            case 2:
+                return 'single-out'
+            default:
+                return null
+        }
+    }
+
+    /**
+     * Resolves the visible stroke for a schematic pin stub.
+     * @param {{ color?: string }} pin
+     * @returns {string}
+     */
+    static #resolvePinStrokeColor(pin) {
+        return SchematicColorResolver.resolveNonTextColor(
+            pin?.color,
+            '--schematic-accent-ink-color'
+        )
+    }
+
     /**
      * Builds one pin-name text element, including overline tspans when needed.
      * @param {string} className