altium-toolkit 1.0.10 → 1.1.0

package/src/core/altium/PcbRigidFlexTopologyBuilder.mjs

@@ -0,0 +1,171 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Derives a rigid-flex topology report from the PCB layer-stack read model.
+ */
+export class PcbRigidFlexTopologyBuilder {
+    static SCHEMA_ID = 'altium-toolkit.pcb.rigid-flex-topology.a1'
+
+    /**
+     * Builds a rigid-flex topology sidecar.
+     * @param {object | undefined} layerStackReadModel Layer-stack sidecar.
+     * @returns {object | undefined}
+     */
+    static build(layerStackReadModel) {
+        if (!layerStackReadModel) return undefined
+
+        const substacks = layerStackReadModel.substacks || []
+        const boardRegions = layerStackReadModel.boardRegions || []
+        const substackRegionJoins =
+            PcbRigidFlexTopologyBuilder.#substackRegionJoins(substacks)
+        const branchGraph = PcbRigidFlexTopologyBuilder.#branchGraph(
+            layerStackReadModel.branches || [],
+            substacks
+        )
+        const bendLines = PcbRigidFlexTopologyBuilder.#bendLines(
+            substacks,
+            boardRegions
+        )
+        const diagnostics = PcbRigidFlexTopologyBuilder.#diagnostics({
+            substacks,
+            branchGraph
+        })
+        const summary = {
+            substackCount: substacks.length,
+            flexSubstackCount: substacks.filter((substack) => substack.isFlex)
+                .length,
+            boardRegionCount:
+                layerStackReadModel.summary?.boardRegionCount || 0,
+            branchCount: branchGraph.length,
+            bendLineCount: bendLines.length,
+            diagnosticCount: diagnostics.length
+        }
+
+        return {
+            schema: PcbRigidFlexTopologyBuilder.SCHEMA_ID,
+            summary,
+            substackRegionJoins,
+            branchGraph,
+            bendLines,
+            diagnostics
+        }
+    }
+
+    /**
+     * Builds substack-to-board-region join rows.
+     * @param {object[]} substacks Layer substacks.
+     * @returns {object[]}
+     */
+    static #substackRegionJoins(substacks) {
+        return substacks.map((substack) => ({
+            substackId: substack.id,
+            substackName: substack.name,
+            isFlex: substack.isFlex,
+            layerKeys: substack.layerKeys || [],
+            regionIndexes: substack.boardRegionIndexes || [],
+            regionNames: substack.boardRegionNames || []
+        }))
+    }
+
+    /**
+     * Builds a branch graph with resolved child substack summaries.
+     * @param {object[]} branches Stack branches.
+     * @param {object[]} substacks Layer substacks.
+     * @returns {object[]}
+     */
+    static #branchGraph(branches, substacks) {
+        const substackById = new Map(
+            substacks
+                .filter((substack) => substack.id)
+                .map((substack) => [substack.id, substack])
+        )
+
+        return branches.map((branch) => ({
+            branchId: branch.id,
+            branchName: branch.name,
+            rootStackRef: branch.rootStackRef,
+            stackRefs: branch.stackRefs || [],
+            ...(branch.sections ? { sections: branch.sections } : {}),
+            childSubstacks: (branch.stackRefs || []).flatMap((stackRef) => {
+                const substack = substackById.get(stackRef)
+                if (!substack) return []
+
+                return [
+                    {
+                        id: substack.id,
+                        name: substack.name,
+                        isFlex: substack.isFlex
+                    }
+                ]
+            })
+        }))
+    }
+
+    /**
+     * Builds bend-line summaries.
+     * @param {object[]} substacks Layer substacks.
+     * @param {object[]} boardRegions Board-region summaries.
+     * @returns {object[]}
+     */
+    static #bendLines(substacks, boardRegions) {
+        const regionNameByIndex = new Map(
+            boardRegions.map((region) => [region.regionIndex, region.name])
+        )
+
+        return substacks.flatMap((substack) =>
+            (substack.boardRegionIndexes || []).flatMap((regionIndex) =>
+                Array.from({ length: substack.bendingLineCount || 0 }).map(
+                    (_, lineIndex) =>
+                        PcbRigidFlexTopologyBuilder.#stripUndefined({
+                            substackId: substack.id,
+                            substackName: substack.name,
+                            regionIndex,
+                            regionName: regionNameByIndex.get(regionIndex),
+                            lineIndex
+                        })
+                )
+            )
+        )
+    }
+
+    /**
+     * Builds topology diagnostics.
+     * @param {{ substacks: object[], branchGraph: object[] }} input Topology sections.
+     * @returns {object[]}
+     */
+    static #diagnostics(input) {
+        const diagnostics = []
+        const substackIds = new Set(
+            input.substacks.map((substack) => substack.id).filter(Boolean)
+        )
+
+        for (const branch of input.branchGraph) {
+            for (const stackRef of branch.stackRefs || []) {
+                if (substackIds.has(stackRef)) continue
+                diagnostics.push({
+                    code: 'pcb.rigid-flex.unresolved-branch-substack',
+                    severity: 'warning',
+                    message:
+                        'Rigid-flex branch graph references an unknown substack.',
+                    branchId: branch.branchId,
+                    stackRef
+                })
+            }
+        }
+
+        return diagnostics
+    }
+
+    /**
+     * Removes undefined values from an object.
+     * @param {Record<string, unknown>} object Source object.
+     * @returns {object}
+     */
+    static #stripUndefined(object) {
+        return Object.fromEntries(
+            Object.entries(object).filter(([, value]) => value !== undefined)
+        )
+    }
+}

package/src/core/altium/PrintableTextDecoder.mjs

@@ -12,6 +12,36 @@ export class PrintableTextDecoder {
         0x9c, 0x9e, 0x9f
     ])
 
+    static #WINDOWS_1252_CONTROL_CODE_POINTS = new Map([
+        [0x80, 0x20ac],
+        [0x82, 0x201a],
+        [0x83, 0x0192],
+        [0x84, 0x201e],
+        [0x85, 0x2026],
+        [0x86, 0x2020],
+        [0x87, 0x2021],
+        [0x88, 0x02c6],
+        [0x89, 0x2030],
+        [0x8a, 0x0160],
+        [0x8b, 0x2039],
+        [0x8c, 0x0152],
+        [0x8e, 0x017d],
+        [0x91, 0x2018],
+        [0x92, 0x2019],
+        [0x93, 0x201c],
+        [0x94, 0x201d],
+        [0x95, 0x2022],
+        [0x96, 0x2013],
+        [0x97, 0x2014],
+        [0x98, 0x02dc],
+        [0x99, 0x2122],
+        [0x9a, 0x0161],
+        [0x9b, 0x203a],
+        [0x9c, 0x0153],
+        [0x9e, 0x017e],
+        [0x9f, 0x0178]
+    ])
+
     /**
      * Returns printable ASCII-like runs from a binary buffer.
      * @param {ArrayBuffer} arrayBuffer
@@ -93,7 +123,7 @@ export class PrintableTextDecoder {
             preferredEncoding === 'cp1252'
         ) {
             return (
-                PrintableTextDecoder.#tryDecode(bytes, 'windows-1252') ||
+                PrintableTextDecoder.#tryDecodeWindows1252(bytes) ||
                 new TextDecoder('utf-8').decode(bytes)
             )
         }
@@ -104,10 +134,8 @@ export class PrintableTextDecoder {
         }
 
         if (PrintableTextDecoder.#hasWindows1252PreferredBytes(bytes)) {
-            const windows1252 = PrintableTextDecoder.#tryDecode(
-                bytes,
-                'windows-1252'
-            )
+            const windows1252 =
+                PrintableTextDecoder.#tryDecodeWindows1252(bytes)
             if (windows1252 !== null) {
                 return windows1252
             }
@@ -115,7 +143,7 @@ export class PrintableTextDecoder {
 
         return (
             PrintableTextDecoder.#tryDecode(bytes, 'gb18030') ||
-            PrintableTextDecoder.#tryDecode(bytes, 'windows-1252') ||
+            PrintableTextDecoder.#tryDecodeWindows1252(bytes) ||
             new TextDecoder('utf-8').decode(bytes)
         )
     }
@@ -203,4 +231,40 @@ export class PrintableTextDecoder {
             return null
         }
     }
+
+    /**
+     * Tries a Windows-1252 decode and normalizes runtimes that expose C1 bytes
+     * as control characters instead of punctuation.
+     * @param {Uint8Array} bytes
+     * @returns {string | null}
+     */
+    static #tryDecodeWindows1252(bytes) {
+        const decoded = PrintableTextDecoder.#tryDecode(bytes, 'windows-1252')
+        if (decoded === null) return null
+
+        return PrintableTextDecoder.#normalizeWindows1252Controls(decoded)
+    }
+
+    /**
+     * Maps Windows-1252 control-range punctuation to stable Unicode code
+     * points across Node/ICU builds.
+     * @param {string} text
+     * @returns {string}
+     */
+    static #normalizeWindows1252Controls(text) {
+        let normalized = ''
+
+        for (const character of text) {
+            const codePoint = character.codePointAt(0)
+            const windows1252CodePoint =
+                PrintableTextDecoder.#WINDOWS_1252_CONTROL_CODE_POINTS.get(
+                    codePoint
+                )
+            normalized += String.fromCodePoint(
+                windows1252CodePoint || codePoint
+            )
+        }
+
+        return normalized
+    }
 }

package/src/core/altium/PrjPcbModelParser.mjs

@@ -716,6 +716,10 @@ export class PrjPcbModelParser {
                 ) ||
                 PrjPcbModelParser.#stringField(fields, 'OutputPath' + index) ||
                 ''
+            const configRows = PrjPcbModelParser.#extractOutputConfigRows(
+                fields,
+                index
+            )
             const row = {
                 index,
                 type,
@@ -740,12 +744,53 @@ export class PrjPcbModelParser {
                 )
             }
             if (targetPath) row.targetPath = targetPath
+            if (configRows.length) row.configRows = configRows
             rows.push(row)
         }
 
         return rows
     }
 
+    /**
+     * Extracts output configuration rows associated with one output index.
+     * @param {Record<string, string | string[]>} fields Output group fields.
+     * @param {number} outputIndex Output row index.
+     * @returns {{ key: string, record: string, fields: Record<string, string> }[]}
+     */
+    static #extractOutputConfigRows(fields, outputIndex) {
+        const rows = []
+        const patterns = [
+            new RegExp('^Configuration' + outputIndex + '_Item\\d+$', 'i'),
+            new RegExp(
+                '^OutputConfiguration(?:Parameter)?' +
+                    outputIndex +
+                    '(?:_Item\\d+)?$',
+                'i'
+            )
+        ]
+
+        for (const key of Object.keys(fields || {}).sort((left, right) =>
+            left.localeCompare(right, undefined, { numeric: true })
+        )) {
+            if (!patterns.some((pattern) => pattern.test(key))) continue
+            const values = Array.isArray(fields[key])
+                ? fields[key]
+                : [fields[key]]
+            for (const value of values) {
+                const parsed = PrjPcbModelParser.#parsePipeFields(value)
+                const record = parsed.Record || ''
+                delete parsed.Record
+                rows.push({
+                    key,
+                    record,
+                    fields: parsed
+                })
+            }
+        }
+
+        return rows
+    }
+
     /**
      * Builds model summary counts.
      * @param {string} fileName