altium-toolkit 1.1.0 → 1.1.2

package/src/core/altium/SchematicImplementationParser.mjs

@@ -21,6 +21,10 @@ export class SchematicImplementationParser {
         const components = SchematicImplementationParser.#componentRows(records)
         const listsByIndex =
             SchematicImplementationParser.#implementationLists(records)
+        const childrenByOwner =
+            SchematicImplementationParser.#implementationChildrenByOwner(
+                records
+            )
         const implementations = (records || [])
             .filter(
                 (record) =>
@@ -32,9 +36,9 @@ export class SchematicImplementationParser {
             .map((record) =>
                 SchematicImplementationParser.#implementation(
                     record,
-                    records,
                     components,
-                    listsByIndex
+                    listsByIndex,
+                    childrenByOwner
                 )
             )
             .filter(Boolean)
@@ -137,12 +141,12 @@ export class SchematicImplementationParser {
     /**
      * Parses one implementation record.
      * @param {object} record Implementation record.
-     * @param {object[]} records All schematic records.
      * @param {object[]} components Component rows.
      * @param {Map<string, object>} listsByIndex Implementation lists.
+     * @param {Map<string, { recordType: string, record: object }[]>} childrenByOwner Implementation child rows by owner index.
      * @returns {object | null}
      */
-    static #implementation(record, records, components, listsByIndex) {
+    static #implementation(record, components, listsByIndex, childrenByOwner) {
         const indexInSheet =
             parseNumericField(record.fields, 'IndexInSheet') ??
             record.recordIndex ??
@@ -184,11 +188,11 @@ export class SchematicImplementationParser {
                 record.fields
             ),
             mapDefiners: SchematicImplementationParser.#mapDefiners(
-                records,
+                childrenByOwner,
                 indexInSheet
             ),
             parameters: SchematicImplementationParser.#parameters(
-                records,
+                childrenByOwner,
                 indexInSheet
             )
         })
@@ -326,23 +330,17 @@ export class SchematicImplementationParser {
 
     /**
      * Parses map-definer child records for one implementation.
-     * @param {object[]} records All schematic records.
+     * @param {Map<string, { recordType: string, record: object }[]>} childrenByOwner Implementation child rows by owner index.
      * @param {number} implementationIndex Implementation index.
      * @returns {object[]}
      */
-    static #mapDefiners(records, implementationIndex) {
-        return (records || [])
-            .filter(
-                (record) =>
-                    SchematicImplementationParser.#field(
-                        record.fields,
-                        'RECORD'
-                    ) === '47' &&
-                    SchematicImplementationParser.#field(
-                        record.fields,
-                        'OwnerIndex'
-                    ) === String(implementationIndex)
-            )
+    static #mapDefiners(childrenByOwner, implementationIndex) {
+        return SchematicImplementationParser.#ownedImplementationChildren(
+            childrenByOwner,
+            implementationIndex
+        )
+            .filter((row) => row.recordType === '47')
+            .map((row) => row.record)
             .map((record) =>
                 SchematicImplementationParser.#stripEmpty({
                     recordKey: SchematicImplementationParser.#recordKey(record),
@@ -360,25 +358,17 @@ export class SchematicImplementationParser {
 
     /**
      * Parses implementation parameter child records.
-     * @param {object[]} records All schematic records.
+     * @param {Map<string, { recordType: string, record: object }[]>} childrenByOwner Implementation child rows by owner index.
      * @param {number} implementationIndex Implementation index.
      * @returns {object[]}
      */
-    static #parameters(records, implementationIndex) {
-        return (records || [])
-            .filter((record) => {
-                const recordType = SchematicImplementationParser.#field(
-                    record.fields,
-                    'RECORD'
-                )
-                return (
-                    (recordType === '48' || recordType === '41') &&
-                    SchematicImplementationParser.#field(
-                        record.fields,
-                        'OwnerIndex'
-                    ) === String(implementationIndex)
-                )
-            })
+    static #parameters(childrenByOwner, implementationIndex) {
+        return SchematicImplementationParser.#ownedImplementationChildren(
+            childrenByOwner,
+            implementationIndex
+        )
+            .filter((row) => row.recordType === '48' || row.recordType === '41')
+            .map((row) => row.record)
             .map((record) =>
                 SchematicImplementationParser.#stripEmpty({
                     recordKey: SchematicImplementationParser.#recordKey(record),
@@ -396,6 +386,55 @@ export class SchematicImplementationParser {
             )
     }
 
+    /**
+     * Indexes implementation child rows by owner index once per parse.
+     * @param {object[]} records Schematic records.
+     * @returns {Map<string, { recordType: string, record: object }[]>}
+     */
+    static #implementationChildrenByOwner(records) {
+        const rowsByOwner = new Map()
+
+        for (const record of records || []) {
+            const recordType = SchematicImplementationParser.#field(
+                record.fields,
+                'RECORD'
+            )
+            if (
+                recordType !== '47' &&
+                recordType !== '48' &&
+                recordType !== '41'
+            ) {
+                continue
+            }
+
+            const ownerIndex = SchematicImplementationParser.#field(
+                record.fields,
+                'OwnerIndex'
+            )
+            if (!ownerIndex) {
+                continue
+            }
+
+            if (!rowsByOwner.has(ownerIndex)) {
+                rowsByOwner.set(ownerIndex, [])
+            }
+
+            rowsByOwner.get(ownerIndex).push({ recordType, record })
+        }
+
+        return rowsByOwner
+    }
+
+    /**
+     * Returns pre-indexed child rows for one implementation.
+     * @param {Map<string, { recordType: string, record: object }[]>} childrenByOwner Implementation child rows by owner index.
+     * @param {number} implementationIndex Implementation index.
+     * @returns {{ recordType: string, record: object }[]}
+     */
+    static #ownedImplementationChildren(childrenByOwner, implementationIndex) {
+        return childrenByOwner.get(String(implementationIndex)) || []
+    }
+
     /**
      * Parses indexed implementation designator fields from a map definer.
      * @param {Record<string, string | string[]>} fields Record fields.

package/src/core/altium/SchematicQaReportBuilder.mjs

@@ -4,8 +4,7 @@
 
 import { ParserUtils } from './ParserUtils.mjs'
 
-const { getDisplayText, getField, parseBoolean, parseNumericField, toColor } =
-    ParserUtils
+const { parseBoolean, parseNumericField, toColor } = ParserUtils
 
 /**
  * Builds deterministic read-only QA summaries for schematic documents.
@@ -25,12 +24,17 @@ export class SchematicQaReportBuilder {
         const lineWidths = SchematicQaReportBuilder.#lineWidths(records)
         const unresolvedParameters =
             SchematicQaReportBuilder.#unresolvedParameters(records)
+        const titleBlockResidue =
+            SchematicQaReportBuilder.#titleBlockResidue(records)
         const findings = [
             ...SchematicQaReportBuilder.#fontFindings(fonts),
             ...SchematicQaReportBuilder.#unresolvedFindings(
                 unresolvedParameters
             ),
-            ...SchematicQaReportBuilder.#titleBlockFindings(records)
+            ...SchematicQaReportBuilder.#titleBlockFindings(
+                records,
+                titleBlockResidue
+            )
         ]
 
         return {
@@ -47,8 +51,7 @@ export class SchematicQaReportBuilder {
             colors,
             lineWidths,
             unresolvedParameters,
-            titleBlockResidue:
-                SchematicQaReportBuilder.#titleBlockResidue(records),
+            titleBlockResidue,
             geometryFallbacks: SchematicQaReportBuilder.#geometryFallbacks(
                 input?.texts
             ),
@@ -138,26 +141,15 @@ export class SchematicQaReportBuilder {
      * @returns {string[]}
      */
     static #unresolvedParameters(records) {
-        const metadata = new Set(
-            (records || [])
-                .filter((record) => getField(record.fields, 'RECORD') === '41')
-                .map((record) => getField(record.fields, 'Name'))
-                .filter(Boolean)
-        )
         const unresolved = []
 
         for (const record of records || []) {
-            const text = getDisplayText(record.fields)
+            const text = SchematicQaReportBuilder.#displayText(record.fields)
             const match = text.match(/^=([A-Za-z_][\w.]*)$/)
             if (!match) {
                 continue
             }
-            if (
-                !metadata.has(match[1]) ||
-                text === getDisplayText(record.fields)
-            ) {
-                unresolved.push(match[1])
-            }
+            unresolved.push(match[1])
         }
 
         return [...new Set(unresolved)].sort()
@@ -200,23 +192,25 @@ export class SchematicQaReportBuilder {
     /**
      * Builds title-block findings.
      * @param {object[]} records Schematic records.
+     * @param {object[]} titleBlockResidue Hidden title-block residue rows.
      * @returns {object[]}
      */
-    static #titleBlockFindings(records) {
+    static #titleBlockFindings(records, titleBlockResidue) {
         const sheet = (records || []).find(
-            (record) => getField(record.fields, 'RECORD') === '31'
+            (record) =>
+                SchematicQaReportBuilder.#field(record.fields, 'RECORD') ===
+                '31'
         )
         if (!sheet || parseBoolean(sheet.fields.TitleBlockOn)) {
             return []
         }
 
-        const residue = SchematicQaReportBuilder.#titleBlockResidue(records)
-        return residue.length
+        return titleBlockResidue.length
             ? [
                   {
                       code: 'schematic.title-block.hidden-residue',
                       severity: 'info',
-                      count: residue.length,
+                      count: titleBlockResidue.length,
                       message:
                           'Hidden title-block parameter records remain while the title block is disabled.'
                   }
@@ -240,22 +234,32 @@ export class SchematicQaReportBuilder {
             'drawnby'
         ])
 
-        return (records || [])
-            .filter(
-                (record) =>
-                    getField(record.fields, 'RECORD') === '41' &&
-                    parseBoolean(record.fields.IsHidden) &&
-                    titleBlockNames.has(
-                        getField(record.fields, 'Name')
-                            .replace(/\s+/g, '')
-                            .toLowerCase()
-                    )
-            )
-            .map((record) => ({
+        const residue = []
+
+        for (const record of records || []) {
+            const fields = record.fields || {}
+            if (
+                SchematicQaReportBuilder.#field(fields, 'RECORD') !== '41' ||
+                !parseBoolean(
+                    SchematicQaReportBuilder.#rawField(fields, 'IsHidden')
+                )
+            ) {
+                continue
+            }
+
+            const name = SchematicQaReportBuilder.#field(fields, 'Name')
+            if (!titleBlockNames.has(name.replace(/\s+/g, '').toLowerCase())) {
+                continue
+            }
+
+            residue.push({
                 recordKey: SchematicQaReportBuilder.#recordKey(record),
-                name: getField(record.fields, 'Name'),
-                value: getDisplayText(record.fields)
-            }))
+                name,
+                value: SchematicQaReportBuilder.#displayText(fields)
+            })
+        }
+
+        return residue
     }
 
     /**
@@ -281,4 +285,77 @@ export class SchematicQaReportBuilder {
     static #recordKey(record) {
         return 'schematic-record-' + String(record?.recordIndex ?? 0)
     }
+
+    /**
+     * Reads one common field without invoking generic field-cache bookkeeping.
+     * @param {Record<string, string | string[]> | undefined} fields Record fields.
+     * @param {string} key Requested key.
+     * @returns {string}
+     */
+    static #field(fields, key) {
+        return SchematicQaReportBuilder.#pickFieldValue(
+            SchematicQaReportBuilder.#rawField(fields, key),
+            false
+        )
+    }
+
+    /**
+     * Returns the best schematic display text without shared field-cache overhead.
+     * @param {Record<string, string | string[]> | undefined} fields Record fields.
+     * @returns {string}
+     */
+    static #displayText(fields) {
+        return (
+            SchematicQaReportBuilder.#pickFieldValue(
+                SchematicQaReportBuilder.#rawField(fields, 'UTF8:Text'),
+                true
+            ) ||
+            SchematicQaReportBuilder.#pickFieldValue(
+                SchematicQaReportBuilder.#rawField(fields, 'Text'),
+                true
+            )
+        )
+    }
+
+    /**
+     * Reads one raw field from parsed records or simple fixture objects.
+     * @param {Record<string, string | string[]> | undefined} fields Record fields.
+     * @param {string} key Requested key.
+     * @returns {string | string[] | undefined}
+     */
+    static #rawField(fields, key) {
+        if (!fields || typeof fields !== 'object') {
+            return undefined
+        }
+
+        const direct = fields[key]
+        if (direct !== undefined) {
+            return direct
+        }
+
+        const upperKey = key.toUpperCase()
+        return upperKey === key ? undefined : fields[upperKey]
+    }
+
+    /**
+     * Returns the last meaningful value from one field payload.
+     * @param {string | string[] | undefined} raw Raw field payload.
+     * @param {boolean} skipAsterisk Whether placeholder asterisks are ignored.
+     * @returns {string}
+     */
+    static #pickFieldValue(raw, skipAsterisk) {
+        if (!Array.isArray(raw)) {
+            const value = String(raw || '').trim()
+            return value && (!skipAsterisk || value !== '*') ? value : ''
+        }
+
+        for (let index = raw.length - 1; index >= 0; index -= 1) {
+            const value = String(raw[index] || '').trim()
+            if (value && (!skipAsterisk || value !== '*')) {
+                return value
+            }
+        }
+
+        return ''
+    }
 }

package/src/ui/PcbEdgeFacingGlyphNormalizer.mjs

@@ -14,6 +14,8 @@ export class PcbEdgeFacingGlyphNormalizer {
     static #EDGE_GLYPH_CENTER_TOLERANCE = 1.5
     static #EDGE_GLYPH_PROXIMITY_RATIO = 0.2
     static #MARKER_PROXIMITY_MULTIPLIER = 3
+    static #SPATIAL_INDEX_MIN_CELL_SIZE = 32
+    static #SPATIAL_INDEX_MAX_CELLS_PER_ITEM = 256
 
     /**
      * Normalizes repeated edge-facing documentation glyphs so their opening
@@ -107,6 +109,8 @@ export class PcbEdgeFacingGlyphNormalizer {
                 )
         ]
         const visited = new Array(items.length).fill(false)
+        const spatialIndex =
+            PcbEdgeFacingGlyphNormalizer.#buildSpatialIndex(items)
         const groups = []
 
         for (let index = 0; index < items.length; index += 1) {
@@ -137,11 +141,10 @@ export class PcbEdgeFacingGlyphNormalizer {
                     arcIndexes.push(currentItem.arcIndex)
                 }
 
-                for (
-                    let nextIndex = 0;
-                    nextIndex < items.length;
-                    nextIndex += 1
-                ) {
+                for (const nextIndex of PcbEdgeFacingGlyphNormalizer.#collectCandidateIndexes(
+                    currentItem.bounds,
+                    spatialIndex
+                )) {
                     if (visited[nextIndex]) {
                         continue
                     }
@@ -171,6 +174,153 @@ export class PcbEdgeFacingGlyphNormalizer {
         return groups
     }
 
+    /**
+     * Builds a spatial lookup for candidate bounds intersections.
+     * @param {{ bounds: { minX: number, maxX: number, minY: number, maxY: number } }[]} items
+     * @returns {{ cellSize: number, cells: Map<string, number[]>, overflowIndexes: number[], marks: Uint32Array, mark: number }}
+     */
+    static #buildSpatialIndex(items) {
+        const cellSize =
+            PcbEdgeFacingGlyphNormalizer.#resolveSpatialCellSize(items)
+        const cells = new Map()
+        const overflowIndexes = []
+
+        items.forEach((item, index) => {
+            const range = PcbEdgeFacingGlyphNormalizer.#resolveCellRange(
+                item.bounds,
+                cellSize
+            )
+            const cellCount =
+                (range.maxX - range.minX + 1) * (range.maxY - range.minY + 1)
+
+            if (
+                cellCount >
+                PcbEdgeFacingGlyphNormalizer.#SPATIAL_INDEX_MAX_CELLS_PER_ITEM
+            ) {
+                overflowIndexes.push(index)
+                return
+            }
+
+            for (let cellX = range.minX; cellX <= range.maxX; cellX += 1) {
+                for (let cellY = range.minY; cellY <= range.maxY; cellY += 1) {
+                    const key = PcbEdgeFacingGlyphNormalizer.#cellKey(
+                        cellX,
+                        cellY
+                    )
+                    const bucket = cells.get(key)
+
+                    if (bucket) {
+                        bucket.push(index)
+                    } else {
+                        cells.set(key, [index])
+                    }
+                }
+            }
+        })
+
+        return {
+            cellSize,
+            cells,
+            overflowIndexes,
+            marks: new Uint32Array(items.length),
+            mark: 0
+        }
+    }
+
+    /**
+     * Collects unique candidate item indexes that could intersect one bounds box.
+     * @param {{ minX: number, maxX: number, minY: number, maxY: number }} bounds
+     * @param {{ cellSize: number, cells: Map<string, number[]>, overflowIndexes: number[], marks: Uint32Array, mark: number }} spatialIndex
+     * @returns {number[]}
+     */
+    static #collectCandidateIndexes(bounds, spatialIndex) {
+        const candidates = []
+        const range = PcbEdgeFacingGlyphNormalizer.#resolveCellRange(
+            bounds,
+            spatialIndex.cellSize
+        )
+
+        spatialIndex.mark += 1
+        if (spatialIndex.mark >= 0xffffffff) {
+            spatialIndex.marks.fill(0)
+            spatialIndex.mark = 1
+        }
+
+        const appendCandidate = (index) => {
+            if (spatialIndex.marks[index] === spatialIndex.mark) {
+                return
+            }
+
+            spatialIndex.marks[index] = spatialIndex.mark
+            candidates.push(index)
+        }
+
+        for (let cellX = range.minX; cellX <= range.maxX; cellX += 1) {
+            for (let cellY = range.minY; cellY <= range.maxY; cellY += 1) {
+                const bucket = spatialIndex.cells.get(
+                    PcbEdgeFacingGlyphNormalizer.#cellKey(cellX, cellY)
+                )
+
+                if (bucket) {
+                    bucket.forEach(appendCandidate)
+                }
+            }
+        }
+
+        spatialIndex.overflowIndexes.forEach(appendCandidate)
+        return candidates
+    }
+
+    /**
+     * Resolves a spatial cell size from typical primitive bounds spans.
+     * @param {{ bounds: { minX: number, maxX: number, minY: number, maxY: number } }[]} items
+     * @returns {number}
+     */
+    static #resolveSpatialCellSize(items) {
+        const spans = items
+            .map((item) =>
+                Math.max(
+                    Number(item.bounds.maxX) - Number(item.bounds.minX),
+                    Number(item.bounds.maxY) - Number(item.bounds.minY),
+                    0
+                )
+            )
+            .filter((span) => Number.isFinite(span))
+            .sort((left, right) => left - right)
+        const medianSpan = spans[Math.floor(spans.length / 2)] || 0
+
+        return Math.max(
+            medianSpan * 4,
+            PcbEdgeFacingGlyphNormalizer.#EDGE_GLYPH_CONNECTION_TOLERANCE * 8,
+            PcbEdgeFacingGlyphNormalizer.#SPATIAL_INDEX_MIN_CELL_SIZE
+        )
+    }
+
+    /**
+     * Resolves the inclusive grid-cell range for one bounds box.
+     * @param {{ minX: number, maxX: number, minY: number, maxY: number }} bounds
+     * @param {number} cellSize
+     * @returns {{ minX: number, maxX: number, minY: number, maxY: number }}
+     */
+    static #resolveCellRange(bounds, cellSize) {
+        return {
+            minX: Math.floor(Number(bounds.minX) / cellSize),
+            maxX: Math.floor(Number(bounds.maxX) / cellSize),
+            minY: Math.floor(Number(bounds.minY) / cellSize),
+            maxY: Math.floor(Number(bounds.maxY) / cellSize)
+        }
+    }
+
+    /**
+     * Builds one deterministic spatial index key.
+     * @param {number} cellX
+     * @param {number} cellY
+     * @returns {string}
+     */
+    static #cellKey(cellX, cellY) {
+        return `${cellX}:${cellY}`
+    }
+
     /**
      * Resolves whether one connected screw glyph needs its semicircular head
      * moved onto the same side as the screw tip while keeping the authored

package/src/ui/PcbInteractionIndex.mjs

@@ -52,7 +52,22 @@ export class PcbInteractionIndex {
      * @returns {object[]}
      */
     static hitTest(documentModel, point, options = {}) {
-        return PcbInteractionIndex.build(documentModel)
+        return PcbInteractionIndex.hitTestItems(
+            PcbInteractionIndex.build(documentModel),
+            point,
+            options
+        )
+    }
+
+    /**
+     * Returns hit candidates from an already-built interaction item list.
+     * @param {object[]} items Built interaction items.
+     * @param {{ x?: unknown, y?: unknown }} point Hit-test point.
+     * @param {object} [options] Hit-test options.
+     * @returns {object[]}
+     */
+    static hitTestItems(items, point, options = {}) {
+        return (Array.isArray(items) ? items : [])
             .filter((item) =>
                 PcbInteractionIndex.#isVisibleCandidate(item, options)
             )