altium-toolkit 1.0.7 → 1.0.9

package/src/core/altium/PcbRuleParser.mjs

@@ -53,6 +53,46 @@ const RULE_TYPES = new Map([
             displayName: 'Routing Layers'
         }
     ],
+    [
+        'ROUTINGTOPOLOGY',
+        {
+            kind: 'routing-topology',
+            category: 'routing',
+            displayName: 'Routing Topology'
+        }
+    ],
+    [
+        'ROUTINGCORNERS',
+        {
+            kind: 'routing-corners',
+            category: 'routing',
+            displayName: 'Routing Corners'
+        }
+    ],
+    [
+        'ROUTINGCORNERSTYLE',
+        {
+            kind: 'routing-corners',
+            category: 'routing',
+            displayName: 'Routing Corners'
+        }
+    ],
+    [
+        'ROUTINGPRIORITY',
+        {
+            kind: 'routing-priority',
+            category: 'routing',
+            displayName: 'Routing Priority'
+        }
+    ],
+    [
+        'FANOUTCONTROL',
+        {
+            kind: 'fanout-control',
+            category: 'routing',
+            displayName: 'Fanout Control'
+        }
+    ],
     [
         'DIFFERENTIALPAIRROUTING',
         {
@@ -84,6 +124,315 @@ const RULE_TYPES = new Map([
             category: 'manufacturing',
             displayName: 'Silkscreen Over Component Pads'
         }
+    ],
+    [
+        'MINIMUMSOLDERMASKSLIVER',
+        {
+            kind: 'minimum-soldermask-sliver',
+            category: 'manufacturing',
+            displayName: 'Minimum Solder Mask Sliver'
+        }
+    ],
+    [
+        'SILKTOSILKCLEARANCE',
+        {
+            kind: 'silk-to-silk-clearance',
+            category: 'manufacturing',
+            displayName: 'Silkscreen To Silkscreen Clearance'
+        }
+    ],
+    [
+        'SILKTOSOLDERMASKCLEARANCE',
+        {
+            kind: 'silk-to-soldermask-clearance',
+            category: 'manufacturing',
+            displayName: 'Silkscreen To Solder Mask Clearance'
+        }
+    ],
+    [
+        'COMPONENTCLEARANCE',
+        {
+            kind: 'component-clearance',
+            category: 'placement',
+            displayName: 'Component Clearance'
+        }
+    ],
+    ['LENGTH', { kind: 'length', category: 'routing', displayName: 'Length' }],
+    [
+        'MAXMINLENGTH',
+        { kind: 'length', category: 'routing', displayName: 'Length' }
+    ],
+    [
+        'MATCHEDLENGTHS',
+        {
+            kind: 'matched-lengths',
+            category: 'routing',
+            displayName: 'Matched Lengths'
+        }
+    ],
+    [
+        'MATCHEDNLENGTH',
+        {
+            kind: 'matched-lengths',
+            category: 'routing',
+            displayName: 'Matched Lengths'
+        }
+    ],
+    [
+        'MINIMUMANNULARRING',
+        {
+            kind: 'minimum-annular-ring',
+            category: 'manufacturing',
+            displayName: 'Minimum Annular Ring'
+        }
+    ],
+    [
+        'VIASUNDERSMD',
+        {
+            kind: 'vias-under-smd',
+            category: 'manufacturing',
+            displayName: 'Vias Under SMD'
+        }
+    ],
+    [
+        'ASSEMBLYTESTPOINT',
+        {
+            kind: 'assembly-testpoint',
+            category: 'testpoint',
+            displayName: 'Assembly Testpoint'
+        }
+    ],
+    [
+        'ASSYTESTPOINTSTYLE',
+        {
+            kind: 'assembly-testpoint',
+            category: 'testpoint',
+            displayName: 'Assembly Testpoint'
+        }
+    ],
+    [
+        'FABRICATIONTESTPOINT',
+        {
+            kind: 'fabrication-testpoint',
+            category: 'testpoint',
+            displayName: 'Fabrication Testpoint'
+        }
+    ],
+    [
+        'TESTPOINTSTYLE',
+        {
+            kind: 'fabrication-testpoint',
+            category: 'testpoint',
+            displayName: 'Fabrication Testpoint'
+        }
+    ],
+    [
+        'TESTPOINT',
+        {
+            kind: 'testpoint',
+            category: 'testpoint',
+            displayName: 'Testpoint'
+        }
+    ],
+    [
+        'TESTPOINTUSAGE',
+        {
+            kind: 'testpoint-usage',
+            category: 'testpoint',
+            displayName: 'Testpoint Usage'
+        }
+    ],
+    [
+        'FABRICATIONTESTPOINTUSAGE',
+        {
+            kind: 'testpoint-usage',
+            category: 'testpoint',
+            displayName: 'Testpoint Usage'
+        }
+    ],
+    [
+        'ASSYTESTPOINTUSAGE',
+        {
+            kind: 'assembly-testpoint-usage',
+            category: 'testpoint',
+            displayName: 'Assembly Testpoint Usage'
+        }
+    ]
+])
+
+const TYPED_CONSTRAINT_ALIASES = new Map([
+    [
+        'width',
+        {
+            minWidth: ['MINLIMIT', 'MINWIDTH'],
+            preferredWidth: ['PREFEREDWIDTH', 'PREFERREDWIDTH'],
+            maxWidth: ['MAXLIMIT', 'MAXWIDTH']
+        }
+    ],
+    [
+        'clearance',
+        {
+            minClearance: ['GAP', 'MINDISTANCE', 'CLEARANCE'],
+            genericClearance: ['GENERICCLEARANCE']
+        }
+    ],
+    [
+        'fanout-control',
+        {
+            fanoutStyle: ['FANOUTSTYLE'],
+            fanoutDirection: ['FANOUTDIRECTION'],
+            bgaDirection: ['BGADIR'],
+            bgaViaMode: ['BGAVIAMODE'],
+            viaGrid: ['VIAGRID']
+        }
+    ],
+    [
+        'routing-topology',
+        {
+            topology: ['TOPOLOGY']
+        }
+    ],
+    [
+        'routing-corners',
+        {
+            cornerStyle: ['CORNERSTYLE'],
+            minimumSetback: ['MINSETBACK'],
+            maximumSetback: ['MAXSETBACK']
+        }
+    ],
+    [
+        'routing-priority',
+        {
+            routingPriority: ['ROUTINGPRIORITY']
+        }
+    ],
+    [
+        'length',
+        {
+            minimumLength: ['MINLIMIT'],
+            maximumLength: ['MAXLIMIT'],
+            minimumDelay: ['MINDELAY'],
+            maximumDelay: ['MAXDELAY'],
+            useDelayUnits: ['USEDELAYUNITS']
+        }
+    ],
+    [
+        'matched-lengths',
+        {
+            tolerance: ['TOLERANCE'],
+            delayTolerance: ['DELAYTOLERANCE'],
+            targetSourceName: ['TARGETSOURCENAME'],
+            useDelayUnits: ['USEDELAYUNITS'],
+            checkNetsInDiffPair: ['CHECKNETSINDIFFPAIR'],
+            checkDiffPairVsDiffPair: ['CHECKDIFFPAIRVSDIFFPAIR'],
+            checkOthers: ['CHECKOTHERS'],
+            checkXSignals: ['CHECKXSIGNALS']
+        }
+    ],
+    [
+        'minimum-soldermask-sliver',
+        {
+            minimumSolderMaskWidth: ['MINSOLDERMASKWIDTH']
+        }
+    ],
+    [
+        'silk-to-silk-clearance',
+        {
+            silkToSilkClearance: ['SILKTOSILKCLEARANCE']
+        }
+    ],
+    [
+        'silk-to-soldermask-clearance',
+        {
+            minimumSilkscreenToMaskGap: ['MINSILKSCREENTOMASKGAP'],
+            clearanceToExposedCopper: ['CLEARANCETOEXPOSEDCOPPER']
+        }
+    ],
+    [
+        'silkscreen-over-component-pads',
+        {
+            minimumSilkscreenToMaskGap: ['MINSILKSCREENTOMASKGAP']
+        }
+    ],
+    [
+        'component-clearance',
+        {
+            gap: ['GAP'],
+            verticalGap: ['VERTICALGAP'],
+            collisionCheckMode: ['COLLISIONCHECKMODE'],
+            showDistances: ['SHOWDISTANCES'],
+            doNotCheckWithout3dBody: ['DONOTCHECKWITHOUT3DBODY']
+        }
+    ],
+    [
+        'minimum-annular-ring',
+        {
+            minimumRing: ['MINIMUMRING']
+        }
+    ],
+    [
+        'vias-under-smd',
+        {
+            allowed: ['ALLOWED']
+        }
+    ],
+    [
+        'assembly-testpoint',
+        {
+            minimumSize: ['MINSIZE'],
+            preferredSize: ['PREFEREDSIZE', 'PREFERREDSIZE'],
+            maximumSize: ['MAXSIZE'],
+            minimumHoleSize: ['MINHOLESIZE'],
+            preferredHoleSize: ['PREFEREDHOLESIZE', 'PREFERREDHOLESIZE'],
+            maximumHoleSize: ['MAXHOLESIZE'],
+            testpointGrid: ['TESTPOINTGRID'],
+            gridTolerance: ['GRIDTOLERANCE'],
+            useGrid: ['USEGRID'],
+            testpointUnderComponent: ['TESTPOINTUNDERCOMPONENT'],
+            allowSideTop: ['ALLOWSIDETOP'],
+            allowSideBottom: ['ALLOWSIDEBOTTOM']
+        }
+    ],
+    [
+        'fabrication-testpoint',
+        {
+            minimumSize: ['MINSIZE'],
+            preferredSize: ['PREFEREDSIZE', 'PREFERREDSIZE'],
+            maximumSize: ['MAXSIZE'],
+            minimumHoleSize: ['MINHOLESIZE'],
+            preferredHoleSize: ['PREFEREDHOLESIZE', 'PREFERREDHOLESIZE'],
+            maximumHoleSize: ['MAXHOLESIZE'],
+            side: ['SIDE'],
+            testpointGrid: ['TESTPOINTGRID'],
+            gridTolerance: ['GRIDTOLERANCE'],
+            useGrid: ['USEGRID'],
+            testpointUnderComponent: ['TESTPOINTUNDERCOMPONENT'],
+            allowSideTop: ['ALLOWSIDETOP'],
+            allowSideBottom: ['ALLOWSIDEBOTTOM']
+        }
+    ],
+    [
+        'testpoint',
+        {
+            minimumSize: ['MINSIZE'],
+            preferredSize: ['PREFEREDSIZE', 'PREFERREDSIZE'],
+            maximumSize: ['MAXSIZE'],
+            minimumHoleSize: ['MINHOLESIZE'],
+            preferredHoleSize: ['PREFEREDHOLESIZE', 'PREFERREDHOLESIZE'],
+            maximumHoleSize: ['MAXHOLESIZE'],
+            side: ['SIDE'],
+            style: ['STYLE'],
+            order: ['ORDER'],
+            testpointGrid: ['TESTPOINTGRID'],
+            testpointUnderComponent: ['TESTPOINTUNDERCOMPONENT']
+        }
+    ],
+    [
+        'testpoint-usage',
+        {
+            allowMultiple: ['ALLOWMULTIPLE'],
+            valid: ['VALID']
+        }
     ]
 ])
 
@@ -296,7 +645,7 @@ export class PcbRuleParser {
         if (numeric) {
             return numeric
         }
-        if (/^(TRUE|FALSE|T|F)$/iu.test(text)) {
+        if (/^(TRUE|FALSE|T|F|YES|NO|ON|OFF)$/iu.test(text)) {
             return {
                 raw: text,
                 type: 'boolean',
@@ -488,39 +837,11 @@ export class PcbRuleParser {
      * @returns {Record<string, Record<string, unknown>>}
      */
     static #parseTypedConstraints(ruleType, constraintValues) {
-        if (ruleType.kind === 'width') {
-            return PcbRuleParser.#parseWidthConstraints(constraintValues)
-        }
-        if (ruleType.kind === 'clearance') {
-            return PcbRuleParser.#parseClearanceConstraints(constraintValues)
-        }
-
-        return {}
-    }
+        const aliases = TYPED_CONSTRAINT_ALIASES.get(ruleType.kind)
 
-    /**
-     * Builds semantic aliases for width-rule constraints.
-     * @param {Record<string, Record<string, unknown>>} constraintValues
-     * @returns {Record<string, Record<string, unknown>>}
-     */
-    static #parseWidthConstraints(constraintValues) {
-        return PcbRuleParser.#pickTypedConstraints(constraintValues, {
-            minWidth: ['MINLIMIT', 'MINWIDTH'],
-            preferredWidth: ['PREFEREDWIDTH', 'PREFERREDWIDTH'],
-            maxWidth: ['MAXLIMIT', 'MAXWIDTH']
-        })
-    }
-
-    /**
-     * Builds semantic aliases for clearance-rule constraints.
-     * @param {Record<string, Record<string, unknown>>} constraintValues
-     * @returns {Record<string, Record<string, unknown>>}
-     */
-    static #parseClearanceConstraints(constraintValues) {
-        return PcbRuleParser.#pickTypedConstraints(constraintValues, {
-            minClearance: ['GAP', 'MINDISTANCE', 'CLEARANCE'],
-            genericClearance: ['GENERICCLEARANCE']
-        })
+        return aliases
+            ? PcbRuleParser.#pickTypedConstraints(constraintValues, aliases)
+            : {}
     }
 
     /**

package/src/core/altium/PcbSidecarRecordParser.mjs

@@ -0,0 +1,177 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { PrintableTextDecoder } from './PrintableTextDecoder.mjs'
+
+/**
+ * Decodes length-prefixed pipe-delimited PCB sidecar records.
+ */
+export class PcbSidecarRecordParser {
+    /**
+     * Parses one sidecar stream into field records.
+     * @param {Uint8Array | ArrayBuffer | undefined} dataBytes
+     * @param {string} sourceStream
+     * @returns {{ fields: Record<string, string>, sourceStream: string, recordIndex: number }[]}
+     */
+    static parseLengthPrefixedRecords(dataBytes, sourceStream) {
+        const bytes = PcbSidecarRecordParser.toUint8Array(dataBytes)
+        const records = []
+        let offset = 0
+
+        while (offset + 4 <= bytes.byteLength) {
+            const recordLength = PcbSidecarRecordParser.readUint32(
+                bytes,
+                offset
+            )
+            offset += 4
+
+            if (recordLength <= 0 || offset + recordLength > bytes.byteLength) {
+                break
+            }
+
+            const recordBytes = bytes.subarray(offset, offset + recordLength)
+            offset += recordLength
+
+            records.push({
+                fields: PcbSidecarRecordParser.parseRecordFields(recordBytes),
+                sourceStream,
+                recordIndex: records.length
+            })
+        }
+
+        return records
+    }
+
+    /**
+     * Parses one pipe-delimited field record.
+     * @param {Uint8Array} bytes
+     * @returns {Record<string, string>}
+     */
+    static parseRecordFields(bytes) {
+        const text = PrintableTextDecoder.decodeBytes(bytes)
+            .replace(/\u0000/gu, '')
+            .replace(/\r\n?/gu, '\n')
+            .trim()
+        const fields = {}
+
+        for (const line of text.split('\n')) {
+            for (const segment of line.split('|')) {
+                const candidate = segment.trim()
+                const separatorIndex = candidate.indexOf('=')
+
+                if (separatorIndex <= 0) {
+                    continue
+                }
+
+                const key = candidate
+                    .slice(0, separatorIndex)
+                    .trim()
+                    .toUpperCase()
+                if (!key) {
+                    continue
+                }
+
+                fields[key] = candidate.slice(separatorIndex + 1).trim()
+            }
+        }
+
+        return fields
+    }
+
+    /**
+     * Returns one field value using the first matching key.
+     * @param {Record<string, string>} fields
+     * @param {string[]} keys
+     * @returns {string}
+     */
+    static firstField(fields, keys) {
+        for (const key of keys) {
+            const value = fields[String(key).toUpperCase()]
+            if (value !== undefined && value !== '') {
+                return value
+            }
+        }
+
+        return ''
+    }
+
+    /**
+     * Parses one integer-like field value.
+     * @param {string | undefined} value
+     * @returns {number | null}
+     */
+    static parseInteger(value) {
+        const parsed = Number(String(value ?? '').trim())
+        return Number.isInteger(parsed) ? parsed : null
+    }
+
+    /**
+     * Parses one numeric field value, including simple unit suffixes.
+     * @param {string | undefined} value
+     * @returns {number | null}
+     */
+    static parseNumber(value) {
+        const match = String(value ?? '')
+            .trim()
+            .match(/-?\d+(?:\.\d+)?(?:e[+-]?\d+)?/i)
+
+        if (!match) {
+            return null
+        }
+
+        const parsed = Number(match[0])
+        return Number.isFinite(parsed) ? parsed : null
+    }
+
+    /**
+     * Parses an Altium boolean token.
+     * @param {string | undefined} value
+     * @returns {boolean | null}
+     */
+    static parseBoolean(value) {
+        const normalized = String(value ?? '')
+            .trim()
+            .toUpperCase()
+
+        if (['T', 'TRUE', '1', 'YES'].includes(normalized)) {
+            return true
+        }
+        if (['F', 'FALSE', '0', 'NO'].includes(normalized)) {
+            return false
+        }
+
+        return null
+    }
+
+    /**
+     * Reads one little-endian unsigned integer from a byte view.
+     * @param {Uint8Array} bytes
+     * @param {number} offset
+     * @returns {number}
+     */
+    static readUint32(bytes, offset) {
+        return new DataView(
+            bytes.buffer,
+            bytes.byteOffset + offset,
+            4
+        ).getUint32(0, true)
+    }
+
+    /**
+     * Normalizes one byte-like input into a Uint8Array view.
+     * @param {Uint8Array | ArrayBuffer | undefined} bytes
+     * @returns {Uint8Array}
+     */
+    static toUint8Array(bytes) {
+        if (!bytes) {
+            return new Uint8Array(0)
+        }
+
+        if (bytes instanceof Uint8Array) {
+            return bytes
+        }
+
+        return new Uint8Array(bytes)
+    }
+}