altium-toolkit 1.0.8 → 1.0.10

package/src/ui/PcbTextPrimitiveRenderer.mjs

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+import { PcbBarcodeTextRenderer } from './PcbBarcodeTextRenderer.mjs'
 import { SchematicSvgUtils } from './SchematicSvgUtils.mjs'
 
 /**
@@ -51,12 +52,17 @@ export class PcbTextPrimitiveRenderer {
     /**
      * Renders selected PCB texts into SVG markup.
      * @param {{ text: string, x: number, y: number, height?: number, rotation?: number, layerId?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string }[]} texts
+     * @param {{ semanticContext?: object }} [options] Render options.
      * @returns {string}
      */
-    static render(texts) {
+    static render(texts, options = {}) {
         return (texts || [])
             .map((text, index) =>
-                PcbTextPrimitiveRenderer.#renderText(text, index)
+                PcbTextPrimitiveRenderer.#renderText(
+                    text,
+                    index,
+                    options.semanticContext || {}
+                )
             )
             .join('')
     }
@@ -65,12 +71,29 @@ export class PcbTextPrimitiveRenderer {
      * Renders one PCB text primitive.
      * @param {{ text: string, x: number, y: number, height?: number, rotation?: number, layerId?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string }} text
      * @param {number} index Text index for stable SVG resource ids.
+     * @param {object} semanticContext Semantic lookup context.
      * @returns {string}
      */
-    static #renderText(text, index) {
+    static #renderText(text, index, semanticContext) {
         const fontSize = PcbTextPrimitiveRenderer.#resolveFontSize(text)
         const rotation = Number(text.rotation || 0)
         const lines = PcbTextPrimitiveRenderer.#textLines(text)
+        const semanticAttributes = PcbTextPrimitiveRenderer.#semanticAttributes(
+            text,
+            index,
+            semanticContext
+        )
+
+        if (PcbTextPrimitiveRenderer.#isBarcodeText(text)) {
+            return PcbBarcodeTextRenderer.render(text, {
+                transform: PcbTextPrimitiveRenderer.#renderTextTransform(
+                    text,
+                    rotation
+                ),
+                fontSize,
+                semanticAttributes
+            })
+        }
 
         if (PcbTextPrimitiveRenderer.#isInvertedText(text)) {
             return PcbTextPrimitiveRenderer.#renderInvertedText(
@@ -78,7 +101,8 @@ export class PcbTextPrimitiveRenderer {
                 index,
                 fontSize,
                 rotation,
-                lines
+                lines,
+                semanticAttributes
             )
         }
 
@@ -95,7 +119,9 @@ export class PcbTextPrimitiveRenderer {
             PcbTextPrimitiveRenderer.#formatTextNumber(fontSize) +
             '"' +
             PcbTextPrimitiveRenderer.#renderFontAttributes(text) +
-            ' text-anchor="start" dominant-baseline="alphabetic">' +
+            ' text-anchor="start" dominant-baseline="alphabetic"' +
+            semanticAttributes +
+            '>' +
             content +
             '</text>'
         )
@@ -109,9 +135,17 @@ export class PcbTextPrimitiveRenderer {
      * @param {number} fontSize Text font size in board units.
      * @param {number} rotation Text rotation in degrees.
      * @param {string[]} lines Text lines to render.
+     * @param {string} semanticAttributes SVG semantic attributes.
      * @returns {string}
      */
-    static #renderInvertedText(text, index, fontSize, rotation, lines) {
+    static #renderInvertedText(
+        text,
+        index,
+        fontSize,
+        rotation,
+        lines,
+        semanticAttributes
+    ) {
         const metrics = PcbTextPrimitiveRenderer.#measureLines(
             text,
             lines,
@@ -144,7 +178,9 @@ export class PcbTextPrimitiveRenderer {
             SchematicSvgUtils.escapeHtml(String(Number(text.layerId || 0))) +
             ' pcb-text--inverted" transform="' +
             PcbTextPrimitiveRenderer.#renderTextTransform(text, rotation) +
-            '">' +
+            '"' +
+            semanticAttributes +
+            '>' +
             '<mask id="' +
             SchematicSvgUtils.escapeHtml(maskId) +
             '" maskUnits="userSpaceOnUse" mask-type="luminance" x="' +
@@ -192,6 +228,142 @@ export class PcbTextPrimitiveRenderer {
         )
     }
 
+    /**
+     * Renders semantic data attributes for one text primitive.
+     * @param {object} text Text primitive.
+     * @param {number} fallbackIndex Rendered text index.
+     * @param {object} semanticContext Semantic lookup context.
+     * @returns {string}
+     */
+    static #semanticAttributes(text, fallbackIndex, semanticContext) {
+        const index =
+            semanticContext?.primitiveIndexes?.texts?.get(text) ?? fallbackIndex
+        const layer = PcbTextPrimitiveRenderer.#layerForText(
+            text,
+            semanticContext
+        )
+        const netName = PcbTextPrimitiveRenderer.#netNameForText(
+            text,
+            semanticContext
+        )
+        const component = PcbTextPrimitiveRenderer.#componentForText(
+            text,
+            semanticContext
+        )
+        const netClasses = netName
+            ? semanticContext?.netClassNamesByNetName?.get(netName) || []
+            : []
+
+        return PcbTextPrimitiveRenderer.#renderDataAttributes({
+            'data-primitive': 'text',
+            'data-element-key': 'pcb-text-' + index,
+            'data-layer-key': layer?.layerKey,
+            'data-layer-display-name': layer?.displayName,
+            'data-layer-id': layer?.layerId,
+            'data-net': netName,
+            'data-net-index': text?.netIndex,
+            'data-net-class': netClasses[0],
+            'data-net-classes': netClasses.length > 1 ? netClasses : undefined,
+            'data-component': component?.designator,
+            'data-component-index': component?.componentIndex,
+            'data-text-role':
+                text?.role ||
+                text?.textRole ||
+                (PcbTextPrimitiveRenderer.#isBarcodeText(text)
+                    ? 'barcode'
+                    : ''),
+            'data-barcode-kind': text?.barcode?.kindName,
+            'data-barcode-render-mode': text?.barcode?.renderModeName,
+            'data-barcode-inverted':
+                text?.barcode?.inverted === true ? 'true' : undefined
+        })
+    }
+
+    /**
+     * Resolves layer metadata for one text primitive.
+     * @param {object} text Text primitive.
+     * @param {object} semanticContext Semantic lookup context.
+     * @returns {object | null}
+     */
+    static #layerForText(text, semanticContext) {
+        const layerId = Number(text?.layerId)
+        if (Number.isInteger(layerId)) {
+            return (
+                semanticContext?.layersById?.get(layerId) || {
+                    layerId,
+                    layerKey: 'L' + layerId,
+                    displayName: text?.layerName || 'Layer ' + layerId
+                }
+            )
+        }
+
+        return null
+    }
+
+    /**
+     * Resolves net metadata for one text primitive.
+     * @param {object} text Text primitive.
+     * @param {object} semanticContext Semantic lookup context.
+     * @returns {string}
+     */
+    static #netNameForText(text, semanticContext) {
+        if (text?.netName) {
+            return String(text.netName)
+        }
+
+        const netIndex = Number(text?.netIndex)
+        if (Number.isInteger(netIndex)) {
+            return semanticContext?.netByIndex?.get(netIndex)?.name || ''
+        }
+
+        return ''
+    }
+
+    /**
+     * Resolves component metadata for one text primitive.
+     * @param {object} text Text primitive.
+     * @param {object} semanticContext Semantic lookup context.
+     * @returns {object | null}
+     */
+    static #componentForText(text, semanticContext) {
+        const componentIndex = Number(text?.componentIndex)
+        if (Number.isInteger(componentIndex)) {
+            return (
+                semanticContext?.componentsByIndex?.get(componentIndex) || null
+            )
+        }
+
+        return null
+    }
+
+    /**
+     * Renders a dictionary as SVG data attributes.
+     * @param {Record<string, unknown>} attributes Attribute dictionary.
+     * @returns {string}
+     */
+    static #renderDataAttributes(attributes) {
+        return Object.entries(attributes || {})
+            .filter(([, value]) => {
+                if (Array.isArray(value)) {
+                    return value.length > 0
+                }
+                return value !== null && value !== undefined && value !== ''
+            })
+            .map(([name, value]) => {
+                const renderedValue = Array.isArray(value)
+                    ? value.join(',')
+                    : String(value)
+                return (
+                    ' ' +
+                    name +
+                    '="' +
+                    SchematicSvgUtils.escapeHtml(renderedValue) +
+                    '"'
+                )
+            })
+            .join('')
+    }
+
     /**
      * Renders the local text transform, including authored PCB text mirroring.
      * @param {{ x?: number, y?: number, mirrored?: boolean }} text Text record.
@@ -246,6 +418,20 @@ export class PcbTextPrimitiveRenderer {
         )
     }
 
+    /**
+     * Checks whether a text primitive should render as barcode artwork.
+     * @param {{ fontType?: number | string, fontTypeName?: string, barcode?: object }} text Text record.
+     * @returns {boolean}
+     */
+    static #isBarcodeText(text) {
+        const fontTypeName = String(text?.fontTypeName || '').toUpperCase()
+        return (
+            Boolean(text?.barcode) ||
+            Number(text?.fontType) === 2 ||
+            fontTypeName.includes('BARCODE')
+        )
+    }
+
     /**
      * Resolves the imported TrueType scale used by browser outline fonts.
      * @param {{ trueTypeFontScale?: number, fontMetrics?: { emScaleFromPcbHeight?: number } }} text Text record.

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, fontStyle?: string, 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, lineWidth?: number, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }} text
      * @param {number} sheetHeight
      * @returns {string}
      */
@@ -51,6 +51,7 @@ export class SchematicNoteRenderer {
             '--schematic-note-border-color'
         )
         const noteStroke = text.showBorder ? borderColor : 'none'
+        const noteStrokeWidth = Number(text.lineWidth)
         const noteSourceLines = text.noteLines || []
         const compactSingleLineNote =
             SchematicNoteRenderer.#isCompactSingleLineNote(
@@ -112,7 +113,13 @@ export class SchematicNoteRenderer {
             escapeHtml(noteFill) +
             '" stroke="' +
             escapeHtml(noteStroke) +
-            '" />' +
+            '"' +
+            (Number.isFinite(noteStrokeWidth)
+                ? ' stroke-width="' +
+                  formatNumber(Math.max(noteStrokeWidth, 0.8)) +
+                  '"'
+                : '') +
+            ' />' +
             textMarkup +
             '</g>'
         )

package/src/ui/SchematicOwnerPinLabelLayout.mjs

@@ -7,6 +7,38 @@
  * synthetic pin-number clearance.
  */
 export class SchematicOwnerPinLabelLayout {
+    /**
+     * Resolves one native-facing pin text placement in renderer coordinates
+     * before sheet Y projection. The returned `yOffset` is applied after
+     * projection, matching SVG text baseline behavior.
+     * @param {{ x: number, y: number, length: number, orientation: 'left' | 'right' | 'top' | 'bottom', symbolOuter?: number }} pin
+     * @param {'name' | 'number'} labelKind
+     * @param {{ labelMode?: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', rotateTopNumber?: boolean }} [options]
+     * @returns {{ x: number, yOffset: number, anchor: 'start' | 'middle' | 'end', rotation: number } | null}
+     */
+    static resolveNativePinTextPlacement(pin, labelKind, options = {}) {
+        const labelMode = options.labelMode || 'name-and-number'
+        const markerStyle =
+            SchematicOwnerPinLabelLayout.#resolveOuterPinMarkerStyle(pin)
+
+        if (labelKind === 'number') {
+            return SchematicOwnerPinLabelLayout.#resolveNumberPlacement(
+                pin,
+                markerStyle,
+                options
+            )
+        }
+
+        if (labelKind === 'name') {
+            return SchematicOwnerPinLabelLayout.#resolveNamePlacement(
+                pin,
+                labelMode
+            )
+        }
+
+        return null
+    }
+
     /**
      * Builds one owner/pin label key.
      * @param {string | undefined} ownerIndex
@@ -170,4 +202,178 @@ export class SchematicOwnerPinLabelLayout {
                 return baseX
         }
     }
+
+    /**
+     * Resolves schematic pin-number placement.
+     * @param {{ x: number, length: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
+     * @param {'single-in' | 'single-out' | 'double' | null} markerStyle
+     * @param {{ rotateTopNumber?: boolean }} options
+     * @returns {{ x: number, yOffset: number, anchor: 'start' | 'middle' | 'end', rotation: number } | null}
+     */
+    static #resolveNumberPlacement(pin, markerStyle, options) {
+        switch (pin.orientation) {
+            case 'left':
+                return {
+                    x:
+                        Number(pin.x) -
+                        SchematicOwnerPinLabelLayout.#resolveHorizontalPinNumberClearance(
+                            markerStyle,
+                            pin
+                        ),
+                    yOffset: -1,
+                    anchor: 'end',
+                    rotation: 0
+                }
+            case 'right':
+                return {
+                    x:
+                        Number(pin.x) +
+                        SchematicOwnerPinLabelLayout.#resolveHorizontalPinNumberClearance(
+                            markerStyle,
+                            pin
+                        ),
+                    yOffset: -1,
+                    anchor: 'start',
+                    rotation: 0
+                }
+            case 'top':
+                return {
+                    x: Number(pin.x) - 2,
+                    yOffset: -6,
+                    anchor: 'middle',
+                    rotation: options.rotateTopNumber === false ? 0 : -90
+                }
+            case 'bottom':
+                return {
+                    x: Number(pin.x) - 2,
+                    yOffset: 7,
+                    anchor: 'middle',
+                    rotation: -90
+                }
+            default:
+                return null
+        }
+    }
+
+    /**
+     * Resolves schematic pin-name placement.
+     * @param {{ x: number, length: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
+     * @param {'hidden' | 'number-only' | 'name-only' | 'name-and-number'} labelMode
+     * @returns {{ x: number, yOffset: number, anchor: 'start' | 'middle' | 'end', rotation: number } | null}
+     */
+    static #resolveNamePlacement(pin, labelMode) {
+        switch (pin.orientation) {
+            case 'left':
+                return {
+                    x:
+                        Number(pin.x) +
+                        SchematicOwnerPinLabelLayout.#resolveHorizontalPinNameInset(
+                            pin,
+                            labelMode
+                        ),
+                    yOffset: 3,
+                    anchor: 'start',
+                    rotation: 0
+                }
+            case 'right':
+                return {
+                    x:
+                        Number(pin.x) -
+                        SchematicOwnerPinLabelLayout.#resolveHorizontalPinNameInset(
+                            pin,
+                            labelMode
+                        ),
+                    yOffset: 3,
+                    anchor: 'end',
+                    rotation: 0
+                }
+            case 'top':
+                return {
+                    x: Number(pin.x),
+                    yOffset: 4,
+                    anchor: 'end',
+                    rotation: -90
+                }
+            case 'bottom':
+                return {
+                    x: Number(pin.x) + 4,
+                    yOffset: -4,
+                    anchor: 'start',
+                    rotation: -90
+                }
+            default:
+                return null
+        }
+    }
+
+    /**
+     * 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, pin) {
+        switch (markerStyle) {
+            case 'double':
+                return 17
+            case 'single-in':
+            case 'single-out':
+                return 8
+            default:
+                return SchematicOwnerPinLabelLayout.#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 SchematicOwnerPinLabelLayout.#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
+    }
+
+    /**
+     * 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}
+     */
+    static #resolveOuterPinMarkerStyle(pin) {
+        if (pin.orientation !== 'left' && pin.orientation !== 'right') {
+            return null
+        }
+
+        switch (Number(pin.symbolOuter || 0)) {
+            case 1:
+            case 33:
+                return 'single-out'
+            case 2:
+                return 'single-in'
+            case 34:
+                return 'double'
+            default:
+                return null
+        }
+    }
 }