altium-toolkit 1.1.39 → 1.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "altium-toolkit",
-    "version": "1.1.39",
+    "version": "1.1.41",
     "description": "Altium document parsing and non-interactive rendering utilities",
     "keywords": [
         "altium",

package/src/core/altium/AltiumLayoutParser.mjs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { ParserUtils } from './ParserUtils.mjs'
+import { PcbLayerIdCodec } from './PcbLayerIdCodec.mjs'
 import { SchematicTextParser } from './SchematicTextParser.mjs'
 
 const { getField, parseNumericField } = ParserUtils
@@ -114,14 +115,18 @@ export class AltiumLayoutParser {
             if (!match) continue
 
             const index = Number.parseInt(match[1], 10)
+            const layerId = parseNumericField(
+                fields,
+                'V9_STACK_LAYER' + index + '_LAYERID'
+            )
+            const legacyLayerId =
+                PcbLayerIdCodec.legacyLayerIdFromV7SaveId(layerId) ?? undefined
             layers.push(
                 AltiumLayoutParser.#stripUndefined({
                     index,
                     name: getField(fields, key),
-                    layerId: parseNumericField(
-                        fields,
-                        'V9_STACK_LAYER' + index + '_LAYERID'
-                    ),
+                    layerId,
+                    legacyLayerId,
                     kind: AltiumLayoutParser.#firstLayerStackTextField(
                         fields,
                         index,

package/src/core/altium/PcbLayerStackReadModelBuilder.mjs

@@ -180,6 +180,7 @@ export class PcbLayerStackReadModelBuilder {
                 PcbLayerStackReadModelBuilder.#stripUndefined({
                     index: layer.index,
                     layerId: layer.layerId,
+                    legacyLayerId: layer.legacyLayerId,
                     layerKey: Number.isFinite(layer.layerId)
                         ? 'L' + layer.layerId
                         : undefined,

package/src/core/altium/SchematicPinParser.mjs

@@ -873,11 +873,18 @@ export class SchematicPinParser {
             ownerDrawnInternalPinOwners.has(ownerIndex) &&
             SchematicPinParser.#isCompactNumberedFetTerminalGroup(
                 normalizedPins,
-                semanticNames,
                 orientationCount
             )
         ) {
             labelMode = 'number-only'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isOwnerDrawnAmplifierTerminalGroup(
+                normalizedPins,
+                semanticNames
+            )
+        ) {
+            labelMode = 'number-only'
         } else if (
             SchematicPinParser.#isOwnerDrawnTerminalGlyphGroup(
                 normalizedPins,
@@ -957,32 +964,94 @@ export class SchematicPinParser {
     }
 
     /**
-     * Returns true when a compact owner-drawn FET body uses semantic terminal
-     * names internally but still exposes external numeric contact labels.
+     * Returns true when a compact owner-drawn FET body or pin array uses
+     * semantic terminal names internally but still exposes external numeric
+     * contact labels.
      * @param {{ designator: string, name: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
-     * @param {string[]} semanticNames
      * @param {number} orientationCount
      * @returns {boolean}
      */
-    static #isCompactNumberedFetTerminalGroup(
-        pins,
-        semanticNames,
-        orientationCount
-    ) {
+    static #isCompactNumberedFetTerminalGroup(pins, orientationCount) {
         if (
-            pins.length !== 4 ||
-            orientationCount < 3 ||
+            pins.length < 4 ||
+            pins.length > 12 ||
+            orientationCount < 2 ||
+            !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
+        ) {
+            return false
+        }
+
+        const normalizedNames = pins.map((pin) =>
+            String(pin.name || '')
+                .trim()
+                .toUpperCase()
+        )
+
+        return (
+            new Set(normalizedNames).size >= 2 &&
+            normalizedNames.every((name) =>
+                SchematicPinParser.#isFetTerminalName(name)
+            )
+        )
+    }
+
+    /**
+     * Returns true when an owner-drawn amplifier body already represents its
+     * input, output, and supply terminal names in the drawn symbol artwork.
+     * @param {{ designator: string, name: string }[]} pins
+     * @param {string[]} semanticNames
+     * @returns {boolean}
+     */
+    static #isOwnerDrawnAmplifierTerminalGroup(pins, semanticNames) {
+        if (
+            pins.length < 3 ||
+            pins.length > 8 ||
             semanticNames.length !== pins.length ||
             !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
         ) {
             return false
         }
 
-        return semanticNames.every((name) =>
-            SchematicPinParser.#isFetTerminalName(name)
+        const normalizedNames = semanticNames.map((name) =>
+            SchematicPinParser.#normalizeAmplifierTerminalName(name)
+        )
+
+        return (
+            normalizedNames.every(Boolean) &&
+            normalizedNames.some((name) => name === 'IN+' || name === 'IN-') &&
+            normalizedNames.includes('OUT')
         )
     }
 
+    /**
+     * Normalizes amplifier terminal names that are normally drawn inside the
+     * owner-authored symbol body.
+     * @param {string} name Raw pin name.
+     * @returns {string}
+     */
+    static #normalizeAmplifierTerminalName(name) {
+        const normalized = String(name || '')
+            .trim()
+            .toUpperCase()
+
+        switch (normalized) {
+            case 'IN+':
+            case '+IN':
+            case '+':
+                return 'IN+'
+            case 'IN-':
+            case '-IN':
+            case '-':
+                return 'IN-'
+            case 'OUT':
+            case 'V+':
+            case 'V-':
+                return normalized
+            default:
+                return ''
+        }
+    }
+
     /**
      * Returns true when a compact multi-side owner has transistor-like terminal
      * letters that are part of the drawn symbol body, not external pin labels.

package/src/styles/altium-renderers.css

@@ -142,6 +142,16 @@
     --pcb-via-hole-fill: #0f746c;
     --pcb-footprint-fill: rgba(247, 230, 117, 0.14);
     --pcb-footprint-track-color: rgba(237, 172, 36, 1);
+    --pcb-detail-paste-fill: rgba(146, 146, 146, 0.94);
+    --pcb-detail-paste-stroke: rgba(154, 154, 154, 0.96);
+    --pcb-detail-mask-fill: rgba(137, 34, 132, 0.4);
+    --pcb-detail-mask-stroke: rgba(137, 34, 132, 0.82);
+    --pcb-detail-mechanical-fill: rgba(148, 160, 166, 0.32);
+    --pcb-detail-mechanical-stroke: rgba(96, 110, 118, 0.86);
+    --pcb-detail-drill-fill: rgba(79, 87, 93, 0.46);
+    --pcb-detail-drill-stroke: rgba(42, 50, 56, 0.88);
+    --pcb-detail-fill: rgba(150, 160, 166, 0.38);
+    --pcb-detail-stroke: rgba(80, 92, 100, 0.82);
     --pcb-dimension-color: rgba(39, 88, 111, 0.78);
     --pcb-dimension-text: #22343b;
     --pcb-text-knockout-fill: rgba(248, 246, 239, 0.96);
@@ -200,7 +210,9 @@
 .pcb-track,
 .pcb-arc,
 .pcb-footprint-track,
-.pcb-footprint-arc {
+.pcb-footprint-arc,
+.pcb-detail-track,
+.pcb-detail-arc {
     fill: none;
     stroke-linecap: round;
     stroke-linejoin: round;
@@ -271,6 +283,60 @@
     stroke: var(--pcb-footprint-track-color);
 }
 
+.pcb-detail-fill,
+.pcb-detail-region {
+    fill: var(--pcb-detail-fill);
+}
+
+.pcb-detail-track,
+.pcb-detail-arc {
+    stroke: var(--pcb-detail-stroke);
+}
+
+.pcb-detail-fill--paste,
+.pcb-detail-region--paste {
+    fill: var(--pcb-detail-paste-fill);
+}
+
+.pcb-detail-track--paste,
+.pcb-detail-arc--paste {
+    stroke: var(--pcb-detail-paste-stroke);
+}
+
+.pcb-detail-fill--mask,
+.pcb-detail-region--mask,
+.pcb-detail-fill--solder-mask,
+.pcb-detail-region--solder-mask {
+    fill: var(--pcb-detail-mask-fill);
+}
+
+.pcb-detail-track--mask,
+.pcb-detail-arc--mask,
+.pcb-detail-track--solder-mask,
+.pcb-detail-arc--solder-mask {
+    stroke: var(--pcb-detail-mask-stroke);
+}
+
+.pcb-detail-fill--mechanical,
+.pcb-detail-region--mechanical {
+    fill: var(--pcb-detail-mechanical-fill);
+}
+
+.pcb-detail-track--mechanical,
+.pcb-detail-arc--mechanical {
+    stroke: var(--pcb-detail-mechanical-stroke);
+}
+
+.pcb-detail-fill--drill,
+.pcb-detail-region--drill {
+    fill: var(--pcb-detail-drill-fill);
+}
+
+.pcb-detail-track--drill,
+.pcb-detail-arc--drill {
+    stroke: var(--pcb-detail-drill-stroke);
+}
+
 .pcb-dimensions {
     pointer-events: none;
 }

package/src/ui/PcbInteractionLayerModel.mjs

@@ -56,13 +56,17 @@ export class PcbInteractionLayerModel {
             const key = String(layer?.name || layer?.layer || '').trim()
             if (!key || seen.has(key)) continue
             seen.add(key)
-            layers.push({
+            const row = {
                 key,
                 label: key,
                 layerId: Number.isFinite(Number(layer?.layerId))
                     ? Number(layer.layerId)
                     : null
-            })
+            }
+            if (Number.isFinite(Number(layer?.legacyLayerId))) {
+                row.legacyLayerId = Number(layer.legacyLayerId)
+            }
+            layers.push(row)
         }
 
         return layers

package/src/ui/PcbPadMaskApertureRenderer.mjs

@@ -0,0 +1,288 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { SchematicSvgUtils } from './SchematicSvgUtils.mjs'
+
+/**
+ * Renders pad-derived paste and solder-mask apertures as independent SVG layers.
+ */
+export class PcbPadMaskApertureRenderer {
+    static #PAD_SHAPE_RECTANGULAR = 2
+    static #SPECS = [
+        {
+            flag: 'hasTopPasteMaskOpening',
+            kind: 'paste',
+            primitiveKind: 'pad-paste',
+            side: 'top',
+            layerId: 35,
+            layerName: 'Top Paste',
+            expansionKey: 'effectivePasteMaskExpansion'
+        },
+        {
+            flag: 'hasBottomPasteMaskOpening',
+            kind: 'paste',
+            primitiveKind: 'pad-paste',
+            side: 'bottom',
+            layerId: 36,
+            layerName: 'Bottom Paste',
+            expansionKey: 'effectivePasteMaskExpansion'
+        },
+        {
+            flag: 'hasTopSolderMaskOpening',
+            kind: 'solder-mask',
+            primitiveKind: 'pad-solder-mask',
+            side: 'top',
+            layerId: 37,
+            layerName: 'Top Solder',
+            expansionKey: 'effectiveSolderMaskExpansion'
+        },
+        {
+            flag: 'hasBottomSolderMaskOpening',
+            kind: 'solder-mask',
+            primitiveKind: 'pad-solder-mask',
+            side: 'bottom',
+            layerId: 38,
+            layerName: 'Bottom Solder',
+            expansionKey: 'effectiveSolderMaskExpansion'
+        }
+    ]
+
+    /**
+     * Builds one SVG group containing all derived pad mask apertures.
+     * @param {object[]} pads Normalized pad records.
+     * @param {{ attributes?: (aperture: object) => string, padIndex?: (pad: object, index: number) => number }} [options]
+     * @returns {string}
+     */
+    static render(pads, options = {}) {
+        const apertures = []
+
+        for (const [fallbackIndex, pad] of (pads || []).entries()) {
+            const padIndex = PcbPadMaskApertureRenderer.#padIndex(
+                pad,
+                fallbackIndex,
+                options
+            )
+            for (const [specIndex, spec] of this.#SPECS.entries()) {
+                if (!pad?.[spec.flag]) continue
+                const aperture = this.#apertureForPad(
+                    pad,
+                    padIndex,
+                    specIndex,
+                    spec
+                )
+                if (!aperture) continue
+                apertures.push(
+                    this.#renderAperture(aperture, options.attributes)
+                )
+            }
+        }
+
+        if (!apertures.length) return ''
+
+        return '<g class="pcb-pad-mask-layers">' + apertures.join('') + '</g>'
+    }
+
+    /**
+     * Resolves one stable pad index.
+     * @param {object} pad Pad record.
+     * @param {number} fallbackIndex Array index.
+     * @param {{ padIndex?: (pad: object, index: number) => number }} options
+     * @returns {number}
+     */
+    static #padIndex(pad, fallbackIndex, options) {
+        const resolved = options.padIndex?.(pad, fallbackIndex)
+        return Number.isInteger(resolved) ? resolved : fallbackIndex
+    }
+
+    /**
+     * Builds one normalized aperture descriptor for a pad/spec pair.
+     * @param {object} pad Pad record.
+     * @param {number} padIndex Stable pad index.
+     * @param {number} specIndex Spec index.
+     * @param {object} spec Aperture layer spec.
+     * @returns {object | null}
+     */
+    static #apertureForPad(pad, padIndex, specIndex, spec) {
+        const size = this.#sizeForPad(pad, spec)
+        if (size.width <= 0 || size.height <= 0) return null
+
+        return {
+            pad,
+            padIndex,
+            index: padIndex * this.#SPECS.length + specIndex,
+            spec,
+            size,
+            primitive: {
+                ...pad,
+                layerId: spec.layerId,
+                layerCode: spec.layerId,
+                legacyLayerId: spec.layerId,
+                layerName: spec.layerName
+            }
+        }
+    }
+
+    /**
+     * Resolves aperture dimensions after the parsed mask expansion.
+     * @param {object} pad Pad record.
+     * @param {object} spec Aperture layer spec.
+     * @returns {{ width: number, height: number }}
+     */
+    static #sizeForPad(pad, spec) {
+        const side = spec.side === 'bottom' ? 'Bottom' : 'Top'
+        const width = Number(pad?.['size' + side + 'X'] || pad?.sizeMidX || 0)
+        const height = Number(pad?.['size' + side + 'Y'] || pad?.sizeMidY || 0)
+        const expansion = Number(pad?.[spec.expansionKey] || 0)
+
+        return {
+            width: Math.max(width + expansion * 2, 0),
+            height: Math.max(height + expansion * 2, 0)
+        }
+    }
+
+    /**
+     * Renders one aperture shape.
+     * @param {object} aperture Aperture descriptor.
+     * @param {(aperture: object) => string | undefined} attributes Attribute callback.
+     * @returns {string}
+     */
+    static #renderAperture(aperture, attributes) {
+        const className =
+            'pcb-detail-fill pcb-detail-fill--' +
+            (aperture.spec.kind === 'solder-mask' ? 'mask' : 'paste') +
+            ' pcb-pad-mask-aperture pcb-pad-mask-aperture--' +
+            aperture.spec.kind
+        const renderedAttributes = attributes?.(aperture) || ''
+
+        return PcbPadMaskApertureRenderer.#isRoundAperture(aperture)
+            ? PcbPadMaskApertureRenderer.#renderCircle(
+                  aperture,
+                  className,
+                  renderedAttributes
+              )
+            : PcbPadMaskApertureRenderer.#renderRect(
+                  aperture,
+                  className,
+                  renderedAttributes
+              )
+    }
+
+    /**
+     * Renders one circular aperture.
+     * @param {object} aperture Aperture descriptor.
+     * @param {string} className SVG class list.
+     * @param {string} attributes SVG attributes.
+     * @returns {string}
+     */
+    static #renderCircle(aperture, className, attributes) {
+        const { pad, size } = aperture
+        const radius = Math.max(size.width, size.height) / 2
+
+        return (
+            '<circle class="' +
+            className +
+            '" cx="' +
+            SchematicSvgUtils.formatNumber(Number(pad.x || 0)) +
+            '" cy="' +
+            SchematicSvgUtils.formatNumber(Number(pad.y || 0)) +
+            '" r="' +
+            SchematicSvgUtils.formatNumber(radius) +
+            '"' +
+            attributes +
+            ' />'
+        )
+    }
+
+    /**
+     * Renders one rectangular aperture.
+     * @param {object} aperture Aperture descriptor.
+     * @param {string} className SVG class list.
+     * @param {string} attributes SVG attributes.
+     * @returns {string}
+     */
+    static #renderRect(aperture, className, attributes) {
+        const { pad, size } = aperture
+        const x = Number(pad.x || 0) - size.width / 2
+        const y = Number(pad.y || 0) - size.height / 2
+
+        return (
+            '<rect class="' +
+            className +
+            '" x="' +
+            SchematicSvgUtils.formatNumber(x) +
+            '" y="' +
+            SchematicSvgUtils.formatNumber(y) +
+            '" width="' +
+            SchematicSvgUtils.formatNumber(size.width) +
+            '" height="' +
+            SchematicSvgUtils.formatNumber(size.height) +
+            '" rx="' +
+            SchematicSvgUtils.formatNumber(
+                PcbPadMaskApertureRenderer.#cornerRadius(aperture)
+            ) +
+            '" transform="rotate(' +
+            SchematicSvgUtils.formatNumber(Number(pad.rotation || 0)) +
+            ' ' +
+            SchematicSvgUtils.formatNumber(Number(pad.x || 0)) +
+            ' ' +
+            SchematicSvgUtils.formatNumber(Number(pad.y || 0)) +
+            ')"' +
+            attributes +
+            ' />'
+        )
+    }
+
+    /**
+     * Returns true when one aperture should be rendered as a circle.
+     * @param {object} aperture Aperture descriptor.
+     * @returns {boolean}
+     */
+    static #isRoundAperture(aperture) {
+        const shape = PcbPadMaskApertureRenderer.#shapeForAperture(aperture)
+        return (
+            shape !== PcbPadMaskApertureRenderer.#PAD_SHAPE_RECTANGULAR &&
+            Math.abs(aperture.size.width - aperture.size.height) < 0.001
+        )
+    }
+
+    /**
+     * Resolves the side-specific pad shape code.
+     * @param {object} aperture Aperture descriptor.
+     * @returns {number}
+     */
+    static #shapeForAperture(aperture) {
+        const side = aperture.spec.side === 'bottom' ? 'Bottom' : 'Top'
+        if (
+            side === 'Top' &&
+            aperture.pad?.hasRoundedRect &&
+            Number.isInteger(aperture.pad.roundedRectShapeTop)
+        ) {
+            return Number(aperture.pad.roundedRectShapeTop)
+        }
+        return Number(aperture.pad?.['shape' + side] || 0)
+    }
+
+    /**
+     * Resolves rectangle corner radius for rounded pad shapes.
+     * @param {object} aperture Aperture descriptor.
+     * @returns {number}
+     */
+    static #cornerRadius(aperture) {
+        if (
+            aperture.spec.side === 'top' &&
+            aperture.pad?.hasRoundedRect &&
+            Number.isFinite(aperture.pad.cornerRadiusTop)
+        ) {
+            return (
+                Math.min(aperture.size.width, aperture.size.height) *
+                (Number(aperture.pad.cornerRadiusTop) / 100)
+            )
+        }
+        if (PcbPadMaskApertureRenderer.#shapeForAperture(aperture) === 1) {
+            return Math.min(aperture.size.width, aperture.size.height) / 2
+        }
+
+        return 0
+    }
+}