altium-toolkit 1.1.3 → 1.1.23

package/src/core/altium/SchematicPinParser.mjs

@@ -3,7 +3,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { ParserUtils } from './ParserUtils.mjs'
+import { SchematicNoErcSymbolResolver } from './SchematicNoErcSymbolResolver.mjs'
 import { SchematicPinDesignatorInferer } from './SchematicPinDesignatorInferer.mjs'
+import { SchematicTextRunParser } from './SchematicTextRunParser.mjs'
 
 /**
  * Helpers for normalized schematic pins, ports, and crosses.
@@ -66,11 +68,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,
@@ -94,6 +94,30 @@ export class SchematicPinParser {
         )
     }
 
+    /**
+     * 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
+    }
+
     /**
      * Normalizes schematic port records into drawable port boxes.
      * @param {{ fields: Record<string, string | string[]> }[]} records
@@ -386,24 +410,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)
     }
 
@@ -445,7 +481,7 @@ export class SchematicPinParser {
                         options.recordType
                     )
                 ),
-                width: ParserUtils.parseNumericField(fields, 'LineWidth') || 1,
+                width: ParserUtils.parseSchematicLineWidth(fields),
                 lineStyle,
                 isBus: options.isBus === true ? true : undefined,
                 recordType: options.recordType || undefined,
@@ -489,7 +525,7 @@ export class SchematicPinParser {
                     fields.Color,
                     SchematicPinParser.#resolveDefaultPolylineColor(fields, '7')
                 ),
-                width: ParserUtils.parseNumericField(fields, 'LineWidth') || 1,
+                width: ParserUtils.parseSchematicLineWidth(fields),
                 lineStyle
             })
         }
@@ -506,7 +542,7 @@ export class SchematicPinParser {
                 fields.Color,
                 SchematicPinParser.#resolveDefaultPolylineColor(fields, '7')
             ),
-            width: ParserUtils.parseNumericField(fields, 'LineWidth') || 1,
+            width: ParserUtils.parseSchematicLineWidth(fields),
             lineStyle
         })
 
@@ -609,8 +645,12 @@ export class SchematicPinParser {
             case 2:
                 return 'filled-arrow'
             case 3:
-                return 'circle'
+                return 'tail'
             case 4:
+                return 'filled-tail'
+            case 5:
+                return 'circle'
+            case 6:
                 return 'square'
             default:
                 return 'marker-' + shape
@@ -816,6 +856,13 @@ export class SchematicPinParser {
             SchematicPinParser.#isTwoPinNumericEndpointGroup(normalizedPins)
         ) {
             labelMode = 'number-only'
+        } else if (
+            SchematicPinParser.#isCompactSinglePinMarkerGroup(
+                normalizedPins,
+                names
+            )
+        ) {
+            labelMode = 'hidden'
         } else if (allPassive && normalizedPins.length <= 2) {
             labelMode = SchematicPinParser.#isCanonicalPassiveTwoPinGroup(
                 normalizedPins
@@ -875,6 +922,31 @@ 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.
@@ -1142,49 +1214,11 @@ export class SchematicPinParser {
      * @returns {{ name: string, nameSegments?: { text: string, overline: boolean }[] }}
      */
     static #parseSchematicPinName(name) {
-        const characters = []
-
-        for (const character of String(name || '').trim()) {
-            if (character === '\\') {
-                const previousCharacter = characters.at(-1)
-                if (previousCharacter) {
-                    previousCharacter.overline = true
-                }
-                continue
-            }
-
-            characters.push({
-                text: character,
-                overline: false
-            })
-        }
-
-        const normalizedName = characters
-            .map((character) => character.text)
-            .join('')
-        const nameSegments = []
-
-        for (const character of characters) {
-            const previousSegment = nameSegments.at(-1)
-            if (
-                previousSegment &&
-                previousSegment.overline === character.overline
-            ) {
-                previousSegment.text += character.text
-                continue
-            }
-
-            nameSegments.push({
-                text: character.text,
-                overline: character.overline
-            })
-        }
+        const parsed = SchematicTextRunParser.parseOptionalOverlineRuns(name)
 
         return {
-            name: normalizedName,
-            nameSegments: nameSegments.some((segment) => segment.overline)
-                ? nameSegments
-                : undefined
+            name: parsed.text,
+            nameSegments: parsed.segments
         }
     }
 

package/src/core/altium/SchematicPrimitiveParser.mjs

@@ -9,6 +9,7 @@ const {
     parseBoolean,
     parseNumericField,
     parseNumericFieldWithFraction,
+    parseSchematicLineWidth,
     toColor
 } = ParserUtils
 
@@ -98,6 +99,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
@@ -122,8 +135,7 @@ export class SchematicPrimitiveParser {
                     fill: toColor(record.fields.AreaColor, color),
                     isSolid: parseBoolean(record.fields.IsSolid),
                     transparent: parseBoolean(record.fields.Transparent),
-                    lineWidth:
-                        parseNumericField(record.fields, 'LineWidth') || 1,
+                    lineWidth: parseSchematicLineWidth(record.fields),
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -157,7 +169,7 @@ export class SchematicPrimitiveParser {
                     points,
                     segments,
                     color: toColor(record.fields.Color, '#000000'),
-                    width: parseNumericField(record.fields, 'LineWidth') || 1,
+                    width: parseSchematicLineWidth(record.fields),
                     lineStyle:
                         parseNumericField(record.fields, 'LineStyle') || 0,
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
@@ -221,8 +233,7 @@ export class SchematicPrimitiveParser {
                     fill: toColor(record.fields.AreaColor, '#ffffff'),
                     isSolid: parseBoolean(record.fields.IsSolid),
                     transparent: parseBoolean(record.fields.Transparent),
-                    lineWidth:
-                        parseNumericField(record.fields, 'LineWidth') || 1,
+                    lineWidth: parseSchematicLineWidth(record.fields),
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -268,8 +279,7 @@ export class SchematicPrimitiveParser {
                     fill: toColor(record.fields.AreaColor, '#ffffff'),
                     isSolid: parseBoolean(record.fields.IsSolid),
                     transparent: parseBoolean(record.fields.Transparent),
-                    lineWidth:
-                        parseNumericField(record.fields, 'LineWidth') || 1,
+                    lineWidth: parseSchematicLineWidth(record.fields),
                     lineStyle:
                         parseNumericField(record.fields, 'LineStyle') || 0,
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
@@ -327,8 +337,7 @@ export class SchematicPrimitiveParser {
                         1
                     ),
                     color: toColor(record.fields.Color, '#000000'),
-                    lineWidth:
-                        parseNumericField(record.fields, 'LineWidth') || 1,
+                    lineWidth: parseSchematicLineWidth(record.fields),
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -352,16 +361,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,
@@ -400,11 +425,16 @@ export class SchematicPrimitiveParser {
                     transparent: usesFrameFallback
                         ? false
                         : parseBoolean(record.fields.Transparent),
-                    lineWidth:
-                        parseNumericField(record.fields, 'LineWidth') || 1,
-                    lineStyle: usesFrameFallback
-                        ? 1
-                        : parseNumericField(record.fields, 'LineStyle') || 0,
+                    lineWidth: parseSchematicLineWidth(record.fields),
+                    lineStyle:
+                        usesFrameFallback ||
+                        SchematicPrimitiveParser.#shouldDefaultBlanketDash(
+                            record.fields,
+                            pointListedBounds
+                        )
+                            ? 1
+                            : parseNumericField(record.fields, 'LineStyle') ||
+                              0,
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -570,7 +600,7 @@ export class SchematicPrimitiveParser {
                     startAngle: startAngle === null ? 0 : startAngle,
                     endAngle: endAngle === null ? 360 : endAngle,
                     color: toColor(record.fields.Color, '#a44a1b'),
-                    width: parseNumericField(record.fields, 'LineWidth') || 1,
+                    width: parseSchematicLineWidth(record.fields),
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -627,8 +657,7 @@ export class SchematicPrimitiveParser {
                     fill: toColor(record.fields.AreaColor, '#ffffff'),
                     isSolid: parseBoolean(record.fields.IsSolid),
                     transparent: parseBoolean(record.fields.Transparent),
-                    lineWidth:
-                        parseNumericField(record.fields, 'LineWidth') || 1,
+                    lineWidth: parseSchematicLineWidth(record.fields),
                     renderOrder: SchematicPrimitiveParser.#resolveRenderOrder(
                         record.fields,
                         index
@@ -989,6 +1018,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/SchematicQaReportBuilder.mjs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { ParserUtils } from './ParserUtils.mjs'
+import { SchematicFieldCoverageReportBuilder } from './SchematicFieldCoverageReportBuilder.mjs'
 
 const { parseBoolean, parseNumericField, toColor } = ParserUtils
 
@@ -55,6 +56,7 @@ export class SchematicQaReportBuilder {
             geometryFallbacks: SchematicQaReportBuilder.#geometryFallbacks(
                 input?.texts
             ),
+            fieldCoverage: SchematicFieldCoverageReportBuilder.build(records),
             findings
         }
     }

package/src/core/altium/SchematicRecordStreamParser.mjs

@@ -0,0 +1,183 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { AsciiRecordParser } from './AsciiRecordParser.mjs'
+
+/**
+ * Parses schematic stream records from native framed streams or printable runs.
+ */
+export class SchematicRecordStreamParser {
+    /**
+     * Parses one schematic stream into record objects.
+     * @param {ArrayBuffer} arrayBuffer Stream bytes.
+     * @returns {{ raw: string, fields: Record<string, string | string[]> }[]}
+     */
+    static parse(arrayBuffer) {
+        return SchematicRecordStreamParser.parseWithOpaqueRecords(arrayBuffer)
+            .records
+    }
+
+    /**
+     * Parses one schematic stream and preserves unmodelled native frames.
+     * @param {ArrayBuffer} arrayBuffer Stream bytes.
+     * @param {{ source?: string, sourceStorage?: string, sourceStream?: string }} [options]
+     * @returns {{ records: { raw: string, fields: Record<string, string | string[]> }[], opaqueRecords: object[] }}
+     */
+    static parseWithOpaqueRecords(arrayBuffer, options = {}) {
+        const framedRecords = SchematicRecordStreamParser.#parseFramedRecords(
+            arrayBuffer,
+            options
+        )
+
+        if (framedRecords) {
+            return framedRecords
+        }
+
+        return {
+            records: AsciiRecordParser.parse(arrayBuffer),
+            opaqueRecords: []
+        }
+    }
+
+    /**
+     * Parses length-prefixed native records when the full stream validates as
+     * framed schematic data.
+     * @param {ArrayBuffer} arrayBuffer Stream bytes.
+     * @param {{ source?: string, sourceStorage?: string, sourceStream?: string }} options Parser metadata.
+     * @returns {{ records: { raw: string, fields: Record<string, string | string[]> }[], opaqueRecords: object[] } | null}
+     */
+    static #parseFramedRecords(arrayBuffer, options) {
+        const bytes = new Uint8Array(arrayBuffer)
+        const records = []
+        const opaqueRecords = []
+        let offset = 0
+        let recordIndex = 0
+
+        while (offset < bytes.byteLength) {
+            if (offset + 4 > bytes.byteLength) {
+                return null
+            }
+
+            const payloadLength = bytes[offset] | (bytes[offset + 1] << 8)
+            const separatorByte = bytes[offset + 2]
+            const recordType = bytes[offset + 3]
+            const payloadStart = offset + 4
+            const payloadEnd = payloadStart + payloadLength
+
+            if (
+                payloadLength <= 0 ||
+                separatorByte !== 0 ||
+                payloadEnd > bytes.byteLength
+            ) {
+                return null
+            }
+
+            if (recordType === 0) {
+                if (bytes[payloadEnd - 1] !== 0) {
+                    return null
+                }
+
+                const raw = SchematicRecordStreamParser.#bytesToBinaryString(
+                    bytes.subarray(payloadStart, payloadEnd - 1)
+                )
+
+                if (raw.trim()) {
+                    records.push(AsciiRecordParser.parseRecord(raw))
+                }
+            } else {
+                opaqueRecords.push(
+                    SchematicRecordStreamParser.#opaqueRecord(
+                        bytes.subarray(payloadStart, payloadEnd),
+                        recordType,
+                        recordIndex,
+                        options
+                    )
+                )
+            }
+
+            offset = payloadEnd
+            recordIndex += 1
+        }
+
+        return records.length || opaqueRecords.length
+            ? { records, opaqueRecords }
+            : null
+    }
+
+    /**
+     * Builds one opaque framed-record metadata row.
+     * @param {Uint8Array} bytes Raw payload bytes.
+     * @param {number} frameType Native frame type byte.
+     * @param {number} recordIndex Zero-based frame index.
+     * @param {{ source?: string, sourceStorage?: string, sourceStream?: string }} options Parser metadata.
+     * @returns {object}
+     */
+    static #opaqueRecord(bytes, frameType, recordIndex, options) {
+        return SchematicRecordStreamParser.#stripUndefined({
+            source: options.source || 'schdoc',
+            sourceStorage: options.sourceStorage,
+            sourceStream: options.sourceStream,
+            frameType,
+            recordIndex,
+            byteLength: bytes.byteLength,
+            rawBase64: SchematicRecordStreamParser.#bytesToBase64(bytes)
+        })
+    }
+
+    /**
+     * Converts bytes into a byte-preserving string.
+     * @param {Uint8Array} bytes Source bytes.
+     * @returns {string}
+     */
+    static #bytesToBinaryString(bytes) {
+        let value = ''
+
+        for (const byte of bytes) {
+            value += String.fromCharCode(byte)
+        }
+
+        return value
+    }
+
+    /**
+     * Encodes bytes as base64 without depending on Node globals.
+     * @param {Uint8Array} bytes Source bytes.
+     * @returns {string}
+     */
+    static #bytesToBase64(bytes) {
+        const alphabet =
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+        let output = ''
+
+        for (let index = 0; index < bytes.byteLength; index += 3) {
+            const first = bytes[index]
+            const second = bytes[index + 1]
+            const third = bytes[index + 2]
+            const hasSecond = index + 1 < bytes.byteLength
+            const hasThird = index + 2 < bytes.byteLength
+            const value =
+                (first << 16) |
+                ((hasSecond ? second : 0) << 8) |
+                (hasThird ? third : 0)
+
+            output += alphabet[(value >> 18) & 0x3f]
+            output += alphabet[(value >> 12) & 0x3f]
+            output += hasSecond ? alphabet[(value >> 6) & 0x3f] : '='
+            output += hasThird ? alphabet[value & 0x3f] : '='
+        }
+
+        return output
+    }
+
+    /**
+     * Removes undefined values from an object.
+     * @param {object} row Row to strip.
+     * @returns {object}
+     */
+    static #stripUndefined(row) {
+        return Object.fromEntries(
+            Object.entries(row).filter(([, value]) => value !== undefined)
+        )
+    }
+}