altium-toolkit 1.1.0 → 1.1.2

package/src/core/altium/PcbReviewMetadataBuilder.mjs

@@ -5,6 +5,7 @@
 import { PcbReviewDrillMetadataBuilder } from './PcbReviewDrillMetadataBuilder.mjs'
 import { PcbReviewPolygonRealizationBuilder } from './PcbReviewPolygonRealizationBuilder.mjs'
 import { PcbReviewRouteHighlightProfileBuilder } from './PcbReviewRouteHighlightProfileBuilder.mjs'
+import { NaturalStringComparator } from './NaturalStringComparator.mjs'
 
 /**
  * Builds PCB review metadata for routed-class and board-assembly workflows.
@@ -18,11 +19,15 @@ export class PcbReviewMetadataBuilder {
      * @returns {object}
      */
     static build(pcb = {}) {
+        const routeAnalysis = pcb.routeAnalysis || {}
+        const routeRowsByName =
+            PcbReviewMetadataBuilder.#routeRowsByName(routeAnalysis)
         const routeGroups = PcbReviewMetadataBuilder.#routeGroups(
-            pcb.routeAnalysis || {}
+            routeAnalysis,
+            routeRowsByName
         )
         const routeHighlightProfiles =
-            PcbReviewRouteHighlightProfileBuilder.build(pcb.routeAnalysis || {})
+            PcbReviewRouteHighlightProfileBuilder.build(routeAnalysis)
         const polygonRealizations =
             PcbReviewPolygonRealizationBuilder.build(pcb)
         const drillReview = PcbReviewDrillMetadataBuilder.build(pcb)
@@ -51,7 +56,7 @@ export class PcbReviewMetadataBuilder {
                 polygonRealizations,
                 drillReview,
                 boardAssemblyViews,
-                pcb.routeAnalysis || {}
+                routeAnalysis
             )
         }
     }
@@ -59,21 +64,29 @@ export class PcbReviewMetadataBuilder {
     /**
      * Builds route highlight groups from route analysis.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #routeGroups(routeAnalysis) {
+    static #routeGroups(routeAnalysis, routeRowsByName) {
         return [
-            ...PcbReviewMetadataBuilder.#classGroups(routeAnalysis),
-            ...PcbReviewMetadataBuilder.#differentialPairGroups(routeAnalysis)
+            ...PcbReviewMetadataBuilder.#classGroups(
+                routeAnalysis,
+                routeRowsByName
+            ),
+            ...PcbReviewMetadataBuilder.#differentialPairGroups(
+                routeAnalysis,
+                routeRowsByName
+            )
         ]
     }
 
     /**
      * Builds net-class route groups.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #classGroups(routeAnalysis) {
+    static #classGroups(routeAnalysis, routeRowsByName) {
         return (routeAnalysis.classes || []).map((classRow) =>
             PcbReviewMetadataBuilder.#stripEmpty({
                 key:
@@ -83,11 +96,11 @@ export class PcbReviewMetadataBuilder {
                 name: classRow.name,
                 netNames: classRow.netNames || [],
                 layerKeys: PcbReviewMetadataBuilder.#layerKeysForNets(
-                    routeAnalysis,
+                    routeRowsByName,
                     classRow.netNames || []
                 ),
                 primitiveKeys: PcbReviewMetadataBuilder.#primitiveKeysForNets(
-                    routeAnalysis,
+                    routeRowsByName,
                     classRow.netNames || []
                 ),
                 totalLengthMil: classRow.totalLengthMil
@@ -98,9 +111,10 @@ export class PcbReviewMetadataBuilder {
     /**
      * Builds differential-pair route groups.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #differentialPairGroups(routeAnalysis) {
+    static #differentialPairGroups(routeAnalysis, routeRowsByName) {
         return (routeAnalysis.differentialPairs || []).map((pair) => {
             const netNames = [
                 pair.positiveNetName,
@@ -115,11 +129,11 @@ export class PcbReviewMetadataBuilder {
                 name: pair.name,
                 netNames,
                 layerKeys: PcbReviewMetadataBuilder.#layerKeysForNets(
-                    routeAnalysis,
+                    routeRowsByName,
                     netNames
                 ),
                 primitiveKeys: PcbReviewMetadataBuilder.#primitiveKeysForNets(
-                    routeAnalysis,
+                    routeRowsByName,
                     netNames
                 ),
                 totalLengthMil: PcbReviewMetadataBuilder.#round(
@@ -226,20 +240,20 @@ export class PcbReviewMetadataBuilder {
         }
         return Object.fromEntries(
             Object.entries(entries).sort(([left], [right]) =>
-                left.localeCompare(right, undefined, { numeric: true })
+                NaturalStringComparator.compare(left, right)
             )
         )
     }
 
     /**
      * Returns layer keys participating in a list of nets.
-     * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @param {string[]} netNames Net names.
      * @returns {string[]}
      */
-    static #layerKeysForNets(routeAnalysis, netNames) {
+    static #layerKeysForNets(routeRowsByName, netNames) {
         const nets = PcbReviewMetadataBuilder.#netsByName(
-            routeAnalysis,
+            routeRowsByName,
             netNames
         )
         return PcbReviewMetadataBuilder.#sortedStrings(
@@ -249,13 +263,13 @@ export class PcbReviewMetadataBuilder {
 
     /**
      * Returns primitive keys participating in a list of nets.
-     * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @param {string[]} netNames Net names.
      * @returns {string[]}
      */
-    static #primitiveKeysForNets(routeAnalysis, netNames) {
+    static #primitiveKeysForNets(routeRowsByName, netNames) {
         const nets = PcbReviewMetadataBuilder.#netsByName(
-            routeAnalysis,
+            routeRowsByName,
             netNames
         )
         return PcbReviewMetadataBuilder.#sortedStrings(
@@ -264,15 +278,32 @@ export class PcbReviewMetadataBuilder {
     }
 
     /**
-     * Resolves net route rows by name.
+     * Builds route rows indexed by net name.
      * @param {object} routeAnalysis Route analysis model.
+     * @returns {Map<string, object[]>}
+     */
+    static #routeRowsByName(routeAnalysis) {
+        const rowsByName = new Map()
+        for (const net of routeAnalysis.byNet || []) {
+            const netName = String(net?.netName || '')
+            if (!netName) continue
+            if (!rowsByName.has(netName)) {
+                rowsByName.set(netName, [])
+            }
+            rowsByName.get(netName).push(net)
+        }
+        return rowsByName
+    }
+
+    /**
+     * Resolves net route rows by name.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @param {string[]} netNames Net names.
      * @returns {object[]}
      */
-    static #netsByName(routeAnalysis, netNames) {
-        const wanted = new Set(netNames || [])
-        return (routeAnalysis.byNet || []).filter((net) =>
-            wanted.has(net.netName)
+    static #netsByName(routeRowsByName, netNames) {
+        return (netNames || []).flatMap(
+            (netName) => routeRowsByName.get(netName) || []
         )
     }
 
@@ -323,10 +354,10 @@ export class PcbReviewMetadataBuilder {
      * @returns {string[]}
      */
     static #sortedStrings(values) {
-        return [...new Set((values || []).filter(Boolean))].sort(
-            (left, right) =>
-                left.localeCompare(right, undefined, { numeric: true })
-        )
+        const sortedValues = [...new Set((values || []).filter(Boolean))]
+        return sortedValues.length < 2
+            ? sortedValues
+            : sortedValues.sort(NaturalStringComparator.compare)
     }
 
     /**

package/src/core/altium/PcbReviewRouteHighlightProfileBuilder.mjs

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+import { NaturalStringComparator } from './NaturalStringComparator.mjs'
+
 /**
  * Builds route-highlight profile rows for PCB review metadata.
  */
@@ -12,33 +14,45 @@ export class PcbReviewRouteHighlightProfileBuilder {
      * @returns {object[]}
      */
     static build(routeAnalysis = {}) {
+        const routeRowsByName =
+            PcbReviewRouteHighlightProfileBuilder.#routeRowsByName(
+                routeAnalysis
+            )
         return [
             ...PcbReviewRouteHighlightProfileBuilder.#differentialPairProfiles(
-                routeAnalysis
+                routeAnalysis,
+                routeRowsByName
             ),
             ...PcbReviewRouteHighlightProfileBuilder.#differentialPairClassProfiles(
-                routeAnalysis
+                routeAnalysis,
+                routeRowsByName
             ),
             ...PcbReviewRouteHighlightProfileBuilder.#netClassProfiles(
-                routeAnalysis
+                routeAnalysis,
+                routeRowsByName
             ),
-            ...PcbReviewRouteHighlightProfileBuilder.#netProfiles(routeAnalysis)
+            ...PcbReviewRouteHighlightProfileBuilder.#netProfiles(
+                routeAnalysis,
+                routeRowsByName
+            )
         ]
     }
 
     /**
      * Builds net-class highlight profiles.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #netClassProfiles(routeAnalysis) {
+    static #netClassProfiles(routeAnalysis, routeRowsByName) {
         return (routeAnalysis.classes || []).map((classRow) =>
             PcbReviewRouteHighlightProfileBuilder.#highlightProfile({
                 selectorKind: 'net-class',
                 keyPrefix: 'highlight-net-class-',
                 name: classRow.name,
                 netNames: classRow.netNames || [],
-                routeAnalysis
+                routeAnalysis,
+                routeRowsByName
             })
         )
     }
@@ -46,9 +60,10 @@ export class PcbReviewRouteHighlightProfileBuilder {
     /**
      * Builds differential-pair highlight profiles.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #differentialPairProfiles(routeAnalysis) {
+    static #differentialPairProfiles(routeAnalysis, routeRowsByName) {
         return (routeAnalysis.differentialPairs || []).map((pair) =>
             PcbReviewRouteHighlightProfileBuilder.#highlightProfile({
                 selectorKind: 'differential-pair',
@@ -57,7 +72,8 @@ export class PcbReviewRouteHighlightProfileBuilder {
                 netNames: [pair.positiveNetName, pair.negativeNetName].filter(
                     Boolean
                 ),
-                routeAnalysis
+                routeAnalysis,
+                routeRowsByName
             })
         )
     }
@@ -65,9 +81,10 @@ export class PcbReviewRouteHighlightProfileBuilder {
     /**
      * Builds differential-pair class highlight profiles.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #differentialPairClassProfiles(routeAnalysis) {
+    static #differentialPairClassProfiles(routeAnalysis, routeRowsByName) {
         const classNames = new Map()
         for (const pair of routeAnalysis.differentialPairs || []) {
             for (const className of pair.classes || []) {
@@ -88,7 +105,7 @@ export class PcbReviewRouteHighlightProfileBuilder {
 
         return [...classNames.entries()]
             .sort(([left], [right]) =>
-                left.localeCompare(right, undefined, { numeric: true })
+                NaturalStringComparator.compare(left, right)
             )
             .map(([className, netNames]) =>
                 PcbReviewRouteHighlightProfileBuilder.#highlightProfile({
@@ -96,7 +113,8 @@ export class PcbReviewRouteHighlightProfileBuilder {
                     keyPrefix: 'highlight-diff-pair-class-',
                     name: className,
                     netNames: [...netNames],
-                    routeAnalysis
+                    routeAnalysis,
+                    routeRowsByName
                 })
             )
     }
@@ -104,23 +122,25 @@ export class PcbReviewRouteHighlightProfileBuilder {
     /**
      * Builds scalar net highlight profiles.
      * @param {object} routeAnalysis Route analysis model.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #netProfiles(routeAnalysis) {
+    static #netProfiles(routeAnalysis, routeRowsByName) {
         return (routeAnalysis.byNet || []).map((net) =>
             PcbReviewRouteHighlightProfileBuilder.#highlightProfile({
                 selectorKind: 'net',
                 keyPrefix: 'highlight-net-',
                 name: net.netName,
                 netNames: [net.netName],
-                routeAnalysis
+                routeAnalysis,
+                routeRowsByName
             })
         )
     }
 
     /**
      * Builds one route-highlight profile.
-     * @param {{ selectorKind: string, keyPrefix: string, name: string, netNames: string[], routeAnalysis: object }} options Profile options.
+     * @param {{ selectorKind: string, keyPrefix: string, name: string, netNames: string[], routeAnalysis: object, routeRowsByName: Map<string, object[]> }} options Profile options.
      * @returns {object}
      */
     static #highlightProfile(options) {
@@ -129,7 +149,8 @@ export class PcbReviewRouteHighlightProfileBuilder {
         )
         const layerGroups = PcbReviewRouteHighlightProfileBuilder.#layerGroups(
             options.routeAnalysis,
-            netNames
+            netNames,
+            options.routeRowsByName
         )
 
         return PcbReviewRouteHighlightProfileBuilder.#stripEmpty({
@@ -158,12 +179,13 @@ export class PcbReviewRouteHighlightProfileBuilder {
      * Builds per-layer route-highlight groups.
      * @param {object} routeAnalysis Route analysis model.
      * @param {string[]} netNames Net names.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @returns {object[]}
      */
-    static #layerGroups(routeAnalysis, netNames) {
+    static #layerGroups(routeAnalysis, netNames, routeRowsByName) {
         const groupsByLayer = new Map()
         for (const net of PcbReviewRouteHighlightProfileBuilder.#netsByName(
-            routeAnalysis,
+            routeRowsByName,
             netNames
         )) {
             for (const participation of net.layerParticipation || []) {
@@ -205,22 +227,37 @@ export class PcbReviewRouteHighlightProfileBuilder {
                 )
             }))
             .sort((left, right) =>
-                left.layerKey.localeCompare(right.layerKey, undefined, {
-                    numeric: true
-                })
+                NaturalStringComparator.compare(left.layerKey, right.layerKey)
             )
     }
 
     /**
-     * Resolves net route rows by name.
+     * Builds route rows indexed by net name.
      * @param {object} routeAnalysis Route analysis model.
+     * @returns {Map<string, object[]>}
+     */
+    static #routeRowsByName(routeAnalysis) {
+        const rowsByName = new Map()
+        for (const net of routeAnalysis.byNet || []) {
+            const netName = String(net?.netName || '')
+            if (!netName) continue
+            if (!rowsByName.has(netName)) {
+                rowsByName.set(netName, [])
+            }
+            rowsByName.get(netName).push(net)
+        }
+        return rowsByName
+    }
+
+    /**
+     * Resolves net route rows by name.
+     * @param {Map<string, object[]>} routeRowsByName Route rows by net name.
      * @param {string[]} netNames Net names.
      * @returns {object[]}
      */
-    static #netsByName(routeAnalysis, netNames) {
-        const wanted = new Set(netNames || [])
-        return (routeAnalysis.byNet || []).filter((net) =>
-            wanted.has(net.netName)
+    static #netsByName(routeRowsByName, netNames) {
+        return (netNames || []).flatMap(
+            (netName) => routeRowsByName.get(netName) || []
         )
     }
 
@@ -248,10 +285,10 @@ export class PcbReviewRouteHighlightProfileBuilder {
      * @returns {string[]}
      */
     static #sortedStrings(values) {
-        return [...new Set((values || []).filter(Boolean))].sort(
-            (left, right) =>
-                left.localeCompare(right, undefined, { numeric: true })
-        )
+        const sortedValues = [...new Set((values || []).filter(Boolean))]
+        return sortedValues.length < 2
+            ? sortedValues
+            : sortedValues.sort(NaturalStringComparator.compare)
     }
 
     /**

package/src/core/altium/PcbRouteAnalysisBuilder.mjs

@@ -183,23 +183,30 @@ export class PcbRouteAnalysisBuilder {
      * @returns {object[]}
      */
     static #netRows(pcb, routePrimitives, viaRows) {
+        const primitivesByNet =
+            PcbRouteAnalysisBuilder.#rowsByNet(routePrimitives)
+        const viasByNet = PcbRouteAnalysisBuilder.#rowsByNet(viaRows)
         const netNames = new Set([
             ...(pcb?.nets || []).map((net) => net.name).filter(Boolean),
-            ...routePrimitives.map((primitive) => primitive.netName),
-            ...viaRows.map((via) => via.netName)
+            ...primitivesByNet.keys(),
+            ...viasByNet.keys()
         ])
 
         return [...netNames]
-            .map((netName) =>
-                PcbRouteAnalysisBuilder.#netRow(
+            .map((netName) => {
+                const primitives = primitivesByNet.get(netName) || []
+                const vias = viasByNet.get(netName) || []
+                if (!primitives.length && !vias.length) {
+                    return null
+                }
+
+                return PcbRouteAnalysisBuilder.#netRow(
                     netName,
-                    routePrimitives.filter(
-                        (primitive) => primitive.netName === netName
-                    ),
-                    viaRows.filter((via) => via.netName === netName)
+                    primitives,
+                    vias
                 )
-            )
-            .filter((net) => net.totalLengthMil > 0 || net.viaCount > 0)
+            })
+            .filter(Boolean)
             .sort((left, right) =>
                 left.netName.localeCompare(right.netName, undefined, {
                     numeric: true
@@ -215,12 +222,16 @@ export class PcbRouteAnalysisBuilder {
      * @returns {object}
      */
     static #netRow(netName, primitives, vias) {
-        const trackRows = primitives.filter(
-            (primitive) => primitive.kind === 'track'
-        )
-        const arcRows = primitives.filter(
-            (primitive) => primitive.kind === 'arc'
-        )
+        const trackRows = []
+        const arcRows = []
+
+        for (const primitive of primitives || []) {
+            if (primitive.kind === 'track') {
+                trackRows.push(primitive)
+            } else if (primitive.kind === 'arc') {
+                arcRows.push(primitive)
+            }
+        }
 
         return {
             netName,
@@ -240,6 +251,29 @@ export class PcbRouteAnalysisBuilder {
         }
     }
 
+    /**
+     * Groups route rows by net name.
+     * @param {object[]} rows Route or via rows.
+     * @returns {Map<string, object[]>}
+     */
+    static #rowsByNet(rows) {
+        const rowsByNet = new Map()
+
+        for (const row of rows || []) {
+            const netName = String(row?.netName || '').trim()
+            if (!netName) {
+                continue
+            }
+
+            if (!rowsByNet.has(netName)) {
+                rowsByNet.set(netName, [])
+            }
+            rowsByNet.get(netName).push(row)
+        }
+
+        return rowsByNet
+    }
+
     /**
      * Builds per-net-class length summaries.
      * @param {object} pcb Normalized PCB model.

package/src/core/altium/SchematicDisplayModeCatalogParser.mjs

@@ -18,12 +18,14 @@ export class SchematicDisplayModeCatalogParser {
      * @returns {object | null}
      */
     static parse(records) {
+        const childrenByOwner =
+            SchematicDisplayModeCatalogParser.#ownerChildrenByOwner(records)
         const components = (records || [])
             .filter((record) => getField(record.fields, 'RECORD') === '1')
             .map((record) =>
                 SchematicDisplayModeCatalogParser.#componentCatalog(
                     record,
-                    records
+                    childrenByOwner
                 )
             )
             .filter(Boolean)
@@ -41,17 +43,17 @@ export class SchematicDisplayModeCatalogParser {
     /**
      * Builds one component display-mode catalog row.
      * @param {object} componentRecord Component record.
-     * @param {object[]} records All schematic records.
+     * @param {Map<string, object[]>} childrenByOwner Child records by owner index.
      * @returns {object}
      */
-    static #componentCatalog(componentRecord, records) {
+    static #componentCatalog(componentRecord, childrenByOwner) {
         const indexInSheet = parseNumericField(
             componentRecord.fields,
             'IndexInSheet'
         )
         const ownerIndex = String(indexInSheet ?? componentRecord.recordIndex)
         const children = SchematicDisplayModeCatalogParser.#ownerChildren(
-            records,
+            childrenByOwner,
             ownerIndex
         )
         const declaredPartCount =
@@ -95,16 +97,39 @@ export class SchematicDisplayModeCatalogParser {
 
     /**
      * Returns child records with owner part/display metadata.
-     * @param {object[]} records All schematic records.
+     * @param {Map<string, object[]>} childrenByOwner Child records by owner index.
      * @param {string} ownerIndex Component owner index.
      * @returns {object[]}
      */
-    static #ownerChildren(records, ownerIndex) {
-        return (records || []).filter(
-            (record) =>
-                getField(record.fields, 'OwnerIndex') === ownerIndex &&
-                parseNumericField(record.fields, 'OwnerPartID') !== null
-        )
+    static #ownerChildren(childrenByOwner, ownerIndex) {
+        return childrenByOwner.get(ownerIndex) || []
+    }
+
+    /**
+     * Indexes schematic owner child records once for display-mode cataloguing.
+     * @param {object[]} records Schematic records.
+     * @returns {Map<string, object[]>}
+     */
+    static #ownerChildrenByOwner(records) {
+        const childrenByOwner = new Map()
+
+        for (const record of records || []) {
+            if (parseNumericField(record.fields, 'OwnerPartID') === null) {
+                continue
+            }
+
+            const ownerIndex = getField(record.fields, 'OwnerIndex')
+            if (!ownerIndex) {
+                continue
+            }
+
+            if (!childrenByOwner.has(ownerIndex)) {
+                childrenByOwner.set(ownerIndex, [])
+            }
+            childrenByOwner.get(ownerIndex).push(record)
+        }
+
+        return childrenByOwner
     }
 
     /**