altium-toolkit 1.1.2 → 1.1.3

package/src/core/altium/SchematicPinParser.mjs

@@ -12,10 +12,15 @@ export class SchematicPinParser {
     /**
      * Normalizes schematic pin records into drawable pin primitives.
      * @param {{ fields: Record<string, string | string[]> }[]} records
+     * @param {{ ownerDrawnInternalPinOwners?: Set<string>, numericEndpointLabelOwners?: Set<string> }} [options]
      * @returns {{ x: number, y: number, length: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color: string, labelColor: string, labelMode: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', ownerIndex: string }[]}
      */
-    static parseSchematicPins(records) {
+    static parseSchematicPins(records, options = {}) {
         const groups = new Map()
+        const ownerDrawnInternalPinOwners =
+            options.ownerDrawnInternalPinOwners || new Set()
+        const numericEndpointLabelOwners =
+            options.numericEndpointLabelOwners || new Set()
 
         for (const record of records) {
             const ownerIndex = ParserUtils.getField(record.fields, 'OwnerIndex')
@@ -81,7 +86,11 @@ export class SchematicPinParser {
         }
 
         return [...groups.values()].flatMap((pins) =>
-            SchematicPinParser.#normalizeSchematicPinGroup(pins)
+            SchematicPinParser.#normalizeSchematicPinGroup(
+                pins,
+                ownerDrawnInternalPinOwners,
+                numericEndpointLabelOwners
+            )
         )
     }
 
@@ -730,9 +739,15 @@ export class SchematicPinParser {
     /**
      * Deduces the visible pins for one schematic symbol owner.
      * @param {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color?: string, labelColor?: string, ownerIndex: string }[]} pins
+     * @param {Set<string>} ownerDrawnInternalPinOwners
+     * @param {Set<string>} numericEndpointLabelOwners
      * @returns {{ x: number, y: number, length: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color: string, labelColor: string, labelMode: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', ownerIndex: string }[]}
      */
-    static #normalizeSchematicPinGroup(pins) {
+    static #normalizeSchematicPinGroup(
+        pins,
+        ownerDrawnInternalPinOwners,
+        numericEndpointLabelOwners
+    ) {
         const deduped = SchematicPinParser.#dedupeSchematicPins(pins)
         const inferredSequentialDesignators =
             SchematicPinDesignatorInferer.inferSequentialCompactFourPinDesignators(
@@ -773,6 +788,7 @@ export class SchematicPinParser {
                     /^\d+$/.test(String(pin.designator || '').trim()) &&
                     (!pin.name || /^\d+$/.test(String(pin.name || '').trim()))
             )
+        const ownerIndex = normalizedPins[0]?.ownerIndex || ''
         let labelMode = 'name-and-number'
 
         if (
@@ -795,12 +811,26 @@ export class SchematicPinParser {
             labelMode = 'number-only'
         }
 
-        if (allPassive && normalizedPins.length <= 2) {
+        if (
+            numericEndpointLabelOwners.has(ownerIndex) &&
+            SchematicPinParser.#isTwoPinNumericEndpointGroup(normalizedPins)
+        ) {
+            labelMode = 'number-only'
+        } else if (allPassive && normalizedPins.length <= 2) {
             labelMode = SchematicPinParser.#isCanonicalPassiveTwoPinGroup(
                 normalizedPins
             )
                 ? 'hidden'
                 : 'number-only'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isCompactNumberedFetTerminalGroup(
+                normalizedPins,
+                semanticNames,
+                orientationCount
+            )
+        ) {
+            labelMode = 'number-only'
         } else if (
             SchematicPinParser.#isOwnerDrawnTerminalGlyphGroup(
                 normalizedPins,
@@ -809,6 +839,24 @@ export class SchematicPinParser {
             )
         ) {
             labelMode = 'hidden'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isCompactInternalTerminalGroup(
+                normalizedPins,
+                names,
+                orientationCount
+            )
+        ) {
+            labelMode = 'hidden'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isCompactTwoPinInternalTerminalGroup(
+                normalizedPins,
+                names,
+                orientationCount
+            )
+        ) {
+            labelMode = 'number-only'
         } else if (!semanticNames.length && orientationCount <= 2) {
             labelMode = 'number-only'
         } else if (
@@ -827,6 +875,33 @@ export class SchematicPinParser {
         }))
     }
 
+    /**
+     * Returns true when a compact owner-drawn FET body 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
+    ) {
+        if (
+            pins.length !== 4 ||
+            orientationCount < 3 ||
+            semanticNames.length !== pins.length ||
+            !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
+        ) {
+            return false
+        }
+
+        return semanticNames.every((name) =>
+            SchematicPinParser.#isFetTerminalName(name)
+        )
+    }
+
     /**
      * 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.
@@ -858,6 +933,60 @@ export class SchematicPinParser {
         )
     }
 
+    /**
+     * Returns true when a compact owner-drawn body carries repeated internal
+     * terminal names that belong to the symbol body, not external labels.
+     * @param {{ designator: string, name: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
+     * @param {string[]} names
+     * @param {number} orientationCount
+     * @returns {boolean}
+     */
+    static #isCompactInternalTerminalGroup(pins, names, orientationCount) {
+        if (
+            pins.length < 3 ||
+            pins.length > 4 ||
+            orientationCount < 3 ||
+            names.length >= pins.length ||
+            !SchematicPinParser.#hasOptionalNumericPinDesignators(pins)
+        ) {
+            return false
+        }
+
+        return (
+            names.length > 0 &&
+            names.every((name) =>
+                SchematicPinParser.#isInternalTerminalName(name)
+            )
+        )
+    }
+
+    /**
+     * Returns true when a compact two-pin owner-drawn symbol stores internal
+     * placeholder terminal names that should not be rendered as labels.
+     * @param {{ designator: string, name: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
+     * @param {string[]} names
+     * @param {number} orientationCount
+     * @returns {boolean}
+     */
+    static #isCompactTwoPinInternalTerminalGroup(
+        pins,
+        names,
+        orientationCount
+    ) {
+        if (
+            pins.length !== 2 ||
+            orientationCount < 2 ||
+            names.length !== pins.length ||
+            !SchematicPinParser.#hasOptionalNumericPinDesignators(pins)
+        ) {
+            return false
+        }
+
+        return names.every((name) =>
+            SchematicPinParser.#isInternalTerminalName(name)
+        )
+    }
+
     /**
      * Returns true when compact owner-drawn terminal glyph pins have either no
      * external designators or ordinary numeric pin numbers.
@@ -881,6 +1010,28 @@ export class SchematicPinParser {
         return /^[BCDEGS]$/i.test(String(name || '').trim())
     }
 
+    /**
+     * Returns true for FET terminal names, including numbered gate/source
+     * variants used by dual-gate symbols.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static #isFetTerminalName(name) {
+        return /^(?:[DS]|[GS]\d*)$/i.test(String(name || '').trim())
+    }
+
+    /**
+     * Returns true for compact internal terminal labels usually drawn inside
+     * owner-authored symbol bodies.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static #isInternalTerminalName(name) {
+        return /^(x|y|gnd|agnd|dgnd|pgnd|vcc|vdd|vee|vss|nc)$/i.test(
+            String(name || '').trim()
+        )
+    }
+
     /**
      * Returns true when one passive two-pin symbol uses the ordinary 1/2 pin
      * numbering that should stay hidden for simple resistor-like parts.
@@ -899,6 +1050,24 @@ export class SchematicPinParser {
         return designators[0] === '1' && designators[1] === '2'
     }
 
+    /**
+     * Returns true when one owner exposes exactly two numeric endpoints.
+     * @param {{ designator: string, name: string }[]} pins
+     * @returns {boolean}
+     */
+    static #isTwoPinNumericEndpointGroup(pins) {
+        if (pins.length !== 2) {
+            return false
+        }
+
+        return pins.every((pin) => {
+            const designator = String(pin.designator || '').trim()
+            const name = String(pin.name || '').trim()
+
+            return /^\d+$/.test(designator) && (!name || /^\d+$/.test(name))
+        })
+    }
+
     /**
      * Returns true when one owner uses the dense two-sided horizontal 48/50
      * pin family whose semantic names belong to the owner-drawn symbol body
@@ -1049,10 +1218,12 @@ export class SchematicPinParser {
     static #inferSchematicPinOrientation(conglomerate) {
         switch (conglomerate) {
             case 34:
+            case 42:
             case 50:
             case 58:
                 return 'left'
             case 32:
+            case 40:
             case 48:
             case 56:
                 return 'right'

package/src/core/altium/SchematicSheetStyleResolver.mjs

@@ -43,4 +43,42 @@ export class SchematicSheetStyleResolver {
 
         return configuredXZones
     }
+
+    /**
+     * Resolves the displayed vertical sheet-zone count after the page size
+     * has been normalized.
+     * @param {{ width: number, height: number, yZones: number, paperSize?: string, sheetStyle?: number }} sheet
+     * @returns {number}
+     */
+    static resolveYZones(sheet) {
+        const configuredYZones = Math.max(Number(sheet?.yZones || 0), 1)
+        const paperSize = String(sheet?.paperSize || '')
+            .trim()
+            .toUpperCase()
+
+        if (Number(sheet?.sheetStyle || 0) !== 1 && !paperSize) {
+            return configuredYZones
+        }
+
+        const width = Number(sheet?.width || 0)
+        const height = Number(sheet?.height || 0)
+        if (height < width) {
+            return configuredYZones
+        }
+
+        if (
+            paperSize === 'A2' ||
+            (width === 1654 && height === 2339) ||
+            paperSize === 'A3' ||
+            (width === 1169 && height === 1654)
+        ) {
+            return 8
+        }
+
+        if (paperSize === 'A4' || (width === 827 && height === 1169)) {
+            return 4
+        }
+
+        return configuredYZones
+    }
 }

package/src/core/altium/SchematicTextParser.mjs

@@ -17,6 +17,10 @@ export class SchematicTextParser {
         const metadata = {}
 
         for (const record of records) {
+            if (ParserUtils.getField(record.fields, 'OwnerIndex')) {
+                continue
+            }
+
             const name = ParserUtils.getField(record.fields, 'Name').trim()
             const value = ParserUtils.getDisplayText(record.fields)
 
@@ -30,6 +34,39 @@ export class SchematicTextParser {
         return metadata
     }
 
+    /**
+     * Extracts owner-local parameter values used by component text templates.
+     * @param {{ fields: Record<string, string | string[]> }[]} records
+     * @returns {Map<string, Record<string, string>>}
+     */
+    static extractSchematicOwnerMetadata(records) {
+        const ownerMetadata = new Map()
+
+        for (const record of records) {
+            const ownerIndex = ParserUtils.getField(record.fields, 'OwnerIndex')
+            const name = ParserUtils.getField(record.fields, 'Name').trim()
+            const value = ParserUtils.getDisplayText(record.fields)
+
+            if (
+                !ownerIndex ||
+                !name ||
+                !value ||
+                value === '*' ||
+                String(value).trim().startsWith('=')
+            ) {
+                continue
+            }
+
+            if (!ownerMetadata.has(ownerIndex)) {
+                ownerMetadata.set(ownerIndex, {})
+            }
+
+            ownerMetadata.get(ownerIndex)[name.toLowerCase()] = value
+        }
+
+        return ownerMetadata
+    }
+
     /**
      * Builds a font table from the sheet header.
      * @param {Record<string, string | string[]> | undefined} fields
@@ -96,18 +133,30 @@ export class SchematicTextParser {
      * @param {Record<string, string>} metadata
      * @param {{ width: number, marginWidth: number, titleBlockOn?: boolean }} sheet
      * @param {Record<string, { size: number, family: string, bold: boolean, italic?: boolean, rotation: number }>} fonts
+     * @param {Map<string, Record<string, string>>} [ownerMetadata]
      * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] } | null}
      */
-    static normalizeSchematicTextRecord(fields, metadata, sheet, fonts) {
+    static normalizeSchematicTextRecord(
+        fields,
+        metadata,
+        sheet,
+        fonts,
+        ownerMetadata = new Map()
+    ) {
         const x = ParserUtils.parseNumericField(fields, 'Location.X')
         const y = ParserUtils.parseNumericField(fields, 'Location.Y')
         const hidden = ParserUtils.parseBoolean(fields.IsHidden)
         const name = ParserUtils.getField(fields, 'Name')
         const rawText = ParserUtils.getDisplayText(fields)
         const recordType = ParserUtils.getField(fields, 'RECORD')
+        const ownerIndex = ParserUtils.getField(fields, 'OwnerIndex')
         const text = SchematicTextParser.#resolveSchematicTemplateText(
             rawText,
-            metadata
+            SchematicTextParser.#resolveSchematicTextMetadata(
+                ownerIndex,
+                metadata,
+                ownerMetadata
+            )
         )
 
         if (hidden || x === null || y === null || !text) {
@@ -149,7 +198,7 @@ export class SchematicTextParser {
             ),
             hidden,
             name,
-            ownerIndex: ParserUtils.getField(fields, 'OwnerIndex') || undefined,
+            ownerIndex: ownerIndex || undefined,
             recordType,
             style: ParserUtils.parseNumericField(fields, 'Style') || 0,
             renderOrder:
@@ -476,6 +525,21 @@ export class SchematicTextParser {
         return replacement ? replacement : normalized
     }
 
+    /**
+     * Chooses the parameter map for one text record.
+     * @param {string} ownerIndex
+     * @param {Record<string, string>} metadata
+     * @param {Map<string, Record<string, string>>} ownerMetadata
+     * @returns {Record<string, string>}
+     */
+    static #resolveSchematicTextMetadata(ownerIndex, metadata, ownerMetadata) {
+        if (!ownerIndex) {
+            return metadata
+        }
+
+        return ownerMetadata.get(ownerIndex) || {}
+    }
+
     /**
      * Returns true when a text record is metadata rather than sheet content.
      * @param {Record<string, string | string[]>} fields
@@ -510,7 +574,6 @@ export class SchematicTextParser {
         if (nonDrawableNames.has(normalizedName)) return true
         if (/uniqueid$/i.test(normalizedName)) return true
         if (!normalizedText || normalizedText === '*') return true
-        if (/^=/.test(normalizedText)) return true
         if (
             sheet.titleBlockOn &&
             SchematicTextParser.isTitleBlockFooterRecord(fields, sheet.width)
@@ -537,10 +600,47 @@ export class SchematicTextParser {
 
         if (recordType === '17') return 'middle'
         if (explicitAnchor) return explicitAnchor
+        if (
+            SchematicTextParser.#shouldCenterSchematicNoteByDefault(
+                fields,
+                recordType,
+                text
+            )
+        ) {
+            return 'middle'
+        }
 
         return 'start'
     }
 
+    /**
+     * Returns true for Altium text frames that encode centered one-line labels
+     * without carrying an explicit justification field.
+     * @param {Record<string, string | string[]>} fields
+     * @param {string} recordType
+     * @param {string} text
+     * @returns {boolean}
+     */
+    static #shouldCenterSchematicNoteByDefault(fields, recordType, text) {
+        if (recordType !== '209' && recordType !== '28') return false
+        if (String(text || '').includes('~1')) return false
+        if (
+            ParserUtils.parseNumericField(fields, 'Corner.X') === null ||
+            ParserUtils.parseNumericField(fields, 'Corner.Y') === null
+        ) {
+            return false
+        }
+
+        if (recordType === '28') {
+            return ParserUtils.parseBoolean(fields.WordWrap)
+        }
+
+        return (
+            ParserUtils.parseBoolean(fields.WordWrap) &&
+            ParserUtils.parseBoolean(fields.ClipToRect)
+        )
+    }
+
     /**
      * Decodes Altium's three-column text justification grid into one
      * horizontal SVG text anchor.
@@ -548,23 +648,37 @@ export class SchematicTextParser {
      * @returns {'start' | 'middle' | 'end' | null}
      */
     static #resolveSchematicTextJustificationAnchor(fields) {
-        const justification = ParserUtils.parseNumericField(
-            fields,
-            'Justification'
-        )
+        const justification =
+            ParserUtils.parseNumericField(fields, 'Justification') ??
+            ParserUtils.parseNumericField(fields, 'Alignment')
 
         if (justification === null) {
             return null
         }
 
+        let anchor = 'start'
         switch (((justification % 3) + 3) % 3) {
             case 1:
-                return 'middle'
+                anchor = 'middle'
+                break
             case 2:
-                return 'end'
+                anchor = 'end'
+                break
             default:
-                return 'start'
+                anchor = 'start'
         }
+
+        if (
+            anchor !== 'middle' &&
+            ParserUtils.getField(fields, 'RECORD') === '4' &&
+            ParserUtils.getField(fields, 'OwnerIndex') &&
+            ParserUtils.parseBoolean(fields.IsMirrored) &&
+            ParserUtils.parseNumericField(fields, 'Orientation') === 2
+        ) {
+            return anchor === 'start' ? 'end' : 'start'
+        }
+
+        return anchor
     }
 
     /**