altium-toolkit 1.1.2 → 1.1.22

package/src/core/altium/SchematicPinParser.mjs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { ParserUtils } from './ParserUtils.mjs'
+import { SchematicNoErcSymbolResolver } from './SchematicNoErcSymbolResolver.mjs'
 import { SchematicPinDesignatorInferer } from './SchematicPinDesignatorInferer.mjs'
 
 /**
@@ -12,10 +13,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')
@@ -61,11 +67,9 @@ export class SchematicPinParser {
                 ),
                 designator: ParserUtils.getField(record.fields, 'Designator'),
                 orientation,
-                electrical:
-                    ParserUtils.parseNumericField(
-                        record.fields,
-                        'Electrical'
-                    ) || undefined,
+                electrical: SchematicPinParser.#parseSchematicPinElectrical(
+                    record.fields
+                ),
                 symbolOuter:
                     ParserUtils.parseNumericField(
                         record.fields,
@@ -81,8 +85,36 @@ export class SchematicPinParser {
         }
 
         return [...groups.values()].flatMap((pins) =>
-            SchematicPinParser.#normalizeSchematicPinGroup(pins)
+            SchematicPinParser.#normalizeSchematicPinGroup(
+                pins,
+                ownerDrawnInternalPinOwners,
+                numericEndpointLabelOwners
+            )
+        )
+    }
+
+    /**
+     * Parses Altium's pin electrical type, including its omitted-field default.
+     * Formal schematic pin records omit Electrical for input pins and serialize
+     * passive pins explicitly as Electrical=4.
+     * @param {Record<string, string | string[]>} fields Pin record fields.
+     * @returns {number | undefined}
+     */
+    static #parseSchematicPinElectrical(fields) {
+        const explicitElectrical = ParserUtils.parseNumericField(
+            fields,
+            'Electrical'
         )
+
+        if (explicitElectrical !== null) {
+            return explicitElectrical
+        }
+
+        if (ParserUtils.parseNumericField(fields, 'FormalType') !== null) {
+            return 0
+        }
+
+        return undefined
     }
 
     /**
@@ -377,24 +409,36 @@ export class SchematicPinParser {
     /**
      * Normalizes no-connect crosses from schematic records.
      * @param {{ fields: Record<string, string | string[]> }[]} records
-     * @returns {{ x: number, y: number, size: number, color: string }[]}
+     * @returns {{ x: number, y: number, size: number, color: string, symbol: number | null, symbolName: string }[]}
      */
     static parseSchematicCrosses(records) {
         return records
-            .map((record) => ({
-                x:
-                    ParserUtils.parseNumericField(
-                        record.fields,
-                        'Location.X'
-                    ) || 0,
-                y:
-                    ParserUtils.parseNumericField(
-                        record.fields,
-                        'Location.Y'
-                    ) || 0,
-                size: 6,
-                color: ParserUtils.toColor(record.fields.Color, '#ff0000')
-            }))
+            .map((record) => {
+                const rawSymbol = ParserUtils.getField(record.fields, 'Symbol')
+                const symbol = ParserUtils.parseNumericField(
+                    record.fields,
+                    'Symbol'
+                )
+
+                return {
+                    x:
+                        ParserUtils.parseNumericField(
+                            record.fields,
+                            'Location.X'
+                        ) || 0,
+                    y:
+                        ParserUtils.parseNumericField(
+                            record.fields,
+                            'Location.Y'
+                        ) || 0,
+                    size: 6,
+                    color: ParserUtils.toColor(record.fields.Color, '#ff0000'),
+                    symbol,
+                    symbolName: SchematicNoErcSymbolResolver.resolveSymbolName(
+                        rawSymbol || symbol
+                    )
+                }
+            })
             .filter((cross) => cross.x || cross.y)
     }
 
@@ -730,9 +774,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 +823,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 +846,33 @@ export class SchematicPinParser {
             labelMode = 'number-only'
         }
 
-        if (allPassive && normalizedPins.length <= 2) {
+        if (
+            numericEndpointLabelOwners.has(ownerIndex) &&
+            SchematicPinParser.#isTwoPinNumericEndpointGroup(normalizedPins)
+        ) {
+            labelMode = 'number-only'
+        } else if (
+            SchematicPinParser.#isCompactSinglePinMarkerGroup(
+                normalizedPins,
+                names
+            )
+        ) {
+            labelMode = 'hidden'
+        } 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 +881,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 +917,58 @@ export class SchematicPinParser {
         }))
     }
 
+    /**
+     * Returns true when a single owner pin belongs to compact marker artwork
+     * rather than to a visibly numbered electrical contact.
+     * @param {{ designator: string, name: string, length: number, electrical?: number }[]} pins
+     * @param {string[]} names
+     * @returns {boolean}
+     */
+    static #isCompactSinglePinMarkerGroup(pins, names) {
+        if (pins.length !== 1 || names.length !== 0) {
+            return false
+        }
+
+        const pin = pins[0]
+        const designator = String(pin.designator || '').trim()
+        const length = Math.abs(Number(pin.length || 0))
+        const electrical = Number(pin.electrical)
+
+        return (
+            /^\d+$/.test(designator) &&
+            length > 0 &&
+            length <= 15 &&
+            (!Number.isFinite(electrical) || electrical === 4)
+        )
+    }
+
+    /**
+     * 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 +1000,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 +1077,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 +1117,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 +1285,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/SchematicPrimitiveParser.mjs

@@ -98,6 +98,18 @@ export class SchematicPrimitiveParser {
         )
     }
 
+    /**
+     * Returns true when one point-listed record carries only an axis-aligned
+     * rectangular point list without authored `Location` and `Corner` fields.
+     * @param {Record<string, string | string[]>} fields
+     * @returns {boolean}
+     */
+    static isPointListedRectangleRecord(fields) {
+        return Boolean(
+            SchematicPrimitiveParser.#pointListedRectangleBounds(fields)
+        )
+    }
+
     /**
      * Normalizes record-7 polygon primitives into fill-capable polygons.
      * @param {{ fields: Record<string, string | string[]> }[]} records
@@ -352,16 +364,32 @@ export class SchematicPrimitiveParser {
     static parseSchematicRectangles(records) {
         return records
             .map((record, index) => {
-                const x1 = parseNumericField(record.fields, 'Location.X')
-                const y1 = parseNumericField(record.fields, 'Location.Y')
-                const x2 = parseNumericField(record.fields, 'Corner.X')
-                const y2 = parseNumericField(record.fields, 'Corner.Y')
+                const pointListedBounds =
+                    SchematicPrimitiveParser.#pointListedRectangleBounds(
+                        record.fields
+                    )
+                const x1 =
+                    parseNumericField(record.fields, 'Location.X') ??
+                    pointListedBounds?.minX ??
+                    null
+                const y1 =
+                    parseNumericField(record.fields, 'Location.Y') ??
+                    pointListedBounds?.minY ??
+                    null
+                const x2 =
+                    parseNumericField(record.fields, 'Corner.X') ??
+                    pointListedBounds?.maxX ??
+                    null
+                const y2 =
+                    parseNumericField(record.fields, 'Corner.Y') ??
+                    pointListedBounds?.maxY ??
+                    null
                 const isRectangleRecord =
                     SchematicPrimitiveParser.isRectangleRecord(record.fields)
                 const isListedRectangle =
                     SchematicPrimitiveParser.isListedRectangleRecord(
                         record.fields
-                    )
+                    ) || Boolean(pointListedBounds)
                 const usesFrameFallback =
                     SchematicPrimitiveParser.#shouldUseFrameFallback(
                         record.fields,
@@ -402,9 +430,15 @@ export class SchematicPrimitiveParser {
                         : parseBoolean(record.fields.Transparent),
                     lineWidth:
                         parseNumericField(record.fields, 'LineWidth') || 1,
-                    lineStyle: usesFrameFallback
-                        ? 1
-                        : parseNumericField(record.fields, 'LineStyle') || 0,
+                    lineStyle:
+                        usesFrameFallback ||
+                        SchematicPrimitiveParser.#shouldDefaultBlanketDash(
+                            record.fields,
+                            pointListedBounds
+                        )
+                            ? 1
+                            : parseNumericField(record.fields, 'LineStyle') ||
+                              0,
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -989,6 +1023,80 @@ export class SchematicPrimitiveParser {
         )
     }
 
+    /**
+     * Returns true when a point-listed blanket should use Altium's dashed frame
+     * style even when the printable record omits `LineStyle`.
+     * @param {Record<string, string | string[]>} fields Record fields.
+     * @param {{ minX: number, minY: number, maxX: number, maxY: number } | null} pointListedBounds Point-listed bounds.
+     * @returns {boolean}
+     */
+    static #shouldDefaultBlanketDash(fields, pointListedBounds) {
+        return (
+            Boolean(pointListedBounds) &&
+            getField(fields, 'RECORD') === '225' &&
+            getField(fields, 'LineStyle') === ''
+        )
+    }
+
+    /**
+     * Resolves rectangle bounds from a point-listed axis-aligned frame.
+     * @param {Record<string, string | string[]>} fields Record fields.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #pointListedRectangleBounds(fields) {
+        const points = SchematicPrimitiveParser.#normalizeClosedPointList(
+            SchematicPrimitiveParser.#collectPolygonPoints(fields)
+        )
+
+        if (points.length !== 4) {
+            return null
+        }
+
+        const xs = [...new Set(points.map((point) => point.x))]
+        const ys = [...new Set(points.map((point) => point.y))]
+
+        if (xs.length !== 2 || ys.length !== 2) {
+            return null
+        }
+
+        const minX = Math.min(...xs)
+        const maxX = Math.max(...xs)
+        const minY = Math.min(...ys)
+        const maxY = Math.max(...ys)
+        const corners = new Set([
+            minX + ':' + minY,
+            minX + ':' + maxY,
+            maxX + ':' + minY,
+            maxX + ':' + maxY
+        ])
+
+        if (!points.every((point) => corners.has(point.x + ':' + point.y))) {
+            return null
+        }
+
+        return { minX, minY, maxX, maxY }
+    }
+
+    /**
+     * Removes an optional repeated closing point from one source point list.
+     * @param {{ x: number, y: number }[]} points Source points.
+     * @returns {{ x: number, y: number }[]}
+     */
+    static #normalizeClosedPointList(points) {
+        if (points.length < 2) {
+            return points
+        }
+
+        const first = points[0]
+        const last = points.at(-1)
+
+        if (first.x === last.x && first.y === last.y) {
+            return points.slice(0, -1)
+        }
+
+        return points
+    }
+
     /**
      * Collects one record-7 polygon point list in source order.
      * @param {Record<string, string | string[]>} fields

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
+    }
 }