altium-toolkit 1.1.1 → 1.1.3

package/src/core/altium/PcbEmbeddedFontExtractor.mjs

@@ -2,13 +2,16 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-import { unzlibSync } from 'fflate'
+import { Unzlib } from 'fflate'
 import { PcbFontMetricsParser } from './PcbFontMetricsParser.mjs'
 
 /**
  * Extracts zlib-compressed embedded font payloads from PCB compound streams.
  */
 export class PcbEmbeddedFontExtractor {
+    static #BASE64_ALPHABET =
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
     static #CANDIDATE_STREAM_NAMES = [
         'EmbeddedFonts6/Data',
         'EmbeddedFonts/Data',
@@ -114,16 +117,19 @@ export class PcbEmbeddedFontExtractor {
             return null
         }
 
-        const compressedEnd = PcbEmbeddedFontExtractor.#findCompressedEnd(
+        const payload = PcbEmbeddedFontExtractor.#inflateZlibPayloadAt(
             bytes,
             zlibOffset
         )
-        if (compressedEnd <= zlibOffset) {
+        if (!payload) {
             return null
         }
 
-        const compressedBytes = bytes.subarray(zlibOffset, compressedEnd)
-        const payloadBytes = unzlibSync(compressedBytes)
+        const compressedBytes = bytes.subarray(
+            zlibOffset,
+            payload.compressedEnd
+        )
+        const payloadBytes = payload.bytes
         const metadata = PcbEmbeddedFontExtractor.#normalizeFontMetadata(
             familyField.text,
             alternateField.text,
@@ -151,7 +157,7 @@ export class PcbEmbeddedFontExtractor {
                     PcbEmbeddedFontExtractor.#bytesToBase64(payloadBytes),
                 metrics
             },
-            nextOffset: compressedEnd
+            nextOffset: payload.compressedEnd
         }
     }
 
@@ -224,48 +230,146 @@ export class PcbEmbeddedFontExtractor {
     }
 
     /**
-     * Finds the smallest trailing offset that fully contains a zlib payload.
+     * Inflates one zlib payload and returns its exact stream boundary.
      * @param {Uint8Array} bytes
      * @param {number} zlibOffset
+     * @returns {{ bytes: Uint8Array, compressedEnd: number } | null}
+     */
+    static #inflateZlibPayloadAt(bytes, zlibOffset) {
+        const input = bytes.subarray(zlibOffset)
+        const chunks = []
+        let inflater
+
+        try {
+            inflater = new Unzlib((chunk) => {
+                chunks.push(chunk)
+            })
+            inflater.push(input, false)
+        } catch {
+            return null
+        }
+
+        if (!Number(inflater?.s?.f || 0)) {
+            return null
+        }
+
+        const payloadBytes = PcbEmbeddedFontExtractor.#concatBytes(chunks)
+        const compressedByteCount =
+            PcbEmbeddedFontExtractor.#resolveCompressedByteCount(
+                input,
+                inflater,
+                payloadBytes
+            )
+
+        if (compressedByteCount <= 2) {
+            return null
+        }
+
+        return {
+            bytes: payloadBytes,
+            compressedEnd: zlibOffset + compressedByteCount
+        }
+    }
+
+    /**
+     * Resolves the zlib stream length from fflate's remaining input buffer.
+     * @param {Uint8Array} input
+     * @param {Unzlib} inflater
+     * @param {Uint8Array} payloadBytes
      * @returns {number}
      */
-    static #findCompressedEnd(bytes, zlibOffset) {
-        let low = zlibOffset + 2
-        let high = bytes.byteLength
+    static #resolveCompressedByteCount(input, inflater, payloadBytes) {
+        const remainingByteCount = Number(inflater?.p?.byteLength || 0)
+        if (remainingByteCount < 4) {
+            return -1
+        }
+
+        const baseByteCount = input.byteLength - remainingByteCount + 4
+        const checksum = PcbEmbeddedFontExtractor.#adler32(payloadBytes)
 
-        while (low < high) {
-            const midpoint = Math.floor((low + high) / 2)
+        // fflate can leave the final consumed deflate byte in `p` when the
+        // stream ends mid-byte, so validate both adjacent boundary candidates.
+        for (const compressedByteCount of [baseByteCount, baseByteCount + 1]) {
             if (
-                PcbEmbeddedFontExtractor.#canInflate(
-                    bytes.subarray(zlibOffset, midpoint)
+                PcbEmbeddedFontExtractor.#hasZlibChecksumAt(
+                    input,
+                    compressedByteCount,
+                    checksum
                 )
             ) {
-                high = midpoint
-            } else {
-                low = midpoint + 1
+                return compressedByteCount
             }
         }
 
-        return PcbEmbeddedFontExtractor.#canInflate(
-            bytes.subarray(zlibOffset, low)
-        )
-            ? low
-            : -1
+        return -1
     }
 
     /**
-     * Returns true when one byte slice can be inflated as a complete zlib
-     * stream.
-     * @param {Uint8Array} bytes
+     * Returns true when a candidate zlib boundary ends with the checksum.
+     * @param {Uint8Array} input
+     * @param {number} compressedByteCount
+     * @param {number} checksum
      * @returns {boolean}
      */
-    static #canInflate(bytes) {
-        try {
-            unzlibSync(bytes)
-            return true
-        } catch {
+    static #hasZlibChecksumAt(input, compressedByteCount, checksum) {
+        if (compressedByteCount < 6 || compressedByteCount > input.byteLength) {
             return false
         }
+
+        const checksumOffset = compressedByteCount - 4
+        const actualChecksum = new DataView(
+            input.buffer,
+            input.byteOffset + checksumOffset,
+            4
+        ).getUint32(0, false)
+
+        return actualChecksum === checksum
+    }
+
+    /**
+     * Computes the Adler-32 checksum used by zlib trailers.
+     * @param {Uint8Array} bytes
+     * @returns {number}
+     */
+    static #adler32(bytes) {
+        const modulo = 65521
+        let low = 1
+        let high = 0
+
+        for (let offset = 0; offset < bytes.byteLength; offset += 5552) {
+            const end = Math.min(offset + 5552, bytes.byteLength)
+            for (let index = offset; index < end; index += 1) {
+                low += bytes[index]
+                high += low
+            }
+            low %= modulo
+            high %= modulo
+        }
+
+        return ((high << 16) | low) >>> 0
+    }
+
+    /**
+     * Concatenates inflated output chunks.
+     * @param {Uint8Array[]} chunks
+     * @returns {Uint8Array}
+     */
+    static #concatBytes(chunks) {
+        if (chunks.length === 1) {
+            return chunks[0]
+        }
+
+        const bytes = new Uint8Array(
+            chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0)
+        )
+        let offset = 0
+
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset)
+            offset += chunk.byteLength
+        }
+
+        return bytes
     }
 
     /**
@@ -451,22 +555,61 @@ export class PcbEmbeddedFontExtractor {
      * @returns {string}
      */
     static #bytesToBase64(bytes) {
-        if (typeof btoa === 'function') {
-            let binary = ''
-            const chunkSize = 0x8000
-            for (
-                let offset = 0;
-                offset < bytes.byteLength;
-                offset += chunkSize
-            ) {
-                binary += String.fromCharCode(
-                    ...bytes.subarray(offset, offset + chunkSize)
-                )
+        if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
+            return Buffer.from(bytes).toString('base64')
+        }
+
+        return PcbEmbeddedFontExtractor.#bytesToBase64Portable(bytes)
+    }
+
+    /**
+     * Encodes bytes as base64 without relying on Node APIs.
+     * @param {Uint8Array} bytes
+     * @returns {string}
+     */
+    static #bytesToBase64Portable(bytes) {
+        const alphabet = PcbEmbeddedFontExtractor.#BASE64_ALPHABET
+        const groupBuffer = new Array(4096)
+        const outputChunks = []
+        let groupIndex = 0
+        let byteIndex = 0
+
+        for (; byteIndex + 2 < bytes.byteLength; byteIndex += 3) {
+            const value =
+                (bytes[byteIndex] << 16) |
+                (bytes[byteIndex + 1] << 8) |
+                bytes[byteIndex + 2]
+            groupBuffer[groupIndex] =
+                alphabet[(value >> 18) & 63] +
+                alphabet[(value >> 12) & 63] +
+                alphabet[(value >> 6) & 63] +
+                alphabet[value & 63]
+            groupIndex += 1
+
+            if (groupIndex === groupBuffer.length) {
+                outputChunks.push(groupBuffer.join(''))
+                groupIndex = 0
             }
-            return btoa(binary)
         }
 
-        return Buffer.from(bytes).toString('base64')
+        if (byteIndex < bytes.byteLength) {
+            const hasSecondByte = byteIndex + 1 < bytes.byteLength
+            const value =
+                (bytes[byteIndex] << 16) |
+                ((hasSecondByte ? bytes[byteIndex + 1] : 0) << 8)
+            groupBuffer[groupIndex] =
+                alphabet[(value >> 18) & 63] +
+                alphabet[(value >> 12) & 63] +
+                (hasSecondByte ? alphabet[(value >> 6) & 63] : '=') +
+                '='
+            groupIndex += 1
+        }
+
+        if (groupIndex > 0) {
+            outputChunks.push(groupBuffer.slice(0, groupIndex).join(''))
+        }
+
+        return outputChunks.join('')
     }
 
     /**

package/src/core/altium/PcbLayerStackReadModelBuilder.mjs

@@ -14,6 +14,8 @@ const { parseNumericField } = ParserUtils
 export class PcbLayerStackReadModelBuilder {
     static SCHEMA_ID = 'altium-toolkit.pcb.layer-stack.a1'
 
+    static #fieldIndexes = new WeakMap()
+
     /**
      * Builds the layer-stack sidecar.
      * @param {{ fileName: string, boardRecords: { fields: Record<string, string | string[]>, sourceStream?: string }[], streamNames?: string[], layers: object[], primitiveLayers: object[], layerSubstacks: object[], boardRegions: object[] }} input Source model context.
@@ -799,17 +801,37 @@ export class PcbLayerStackReadModelBuilder {
      * @returns {string}
      */
     static #field(fields, key) {
-        if (Object.hasOwn(fields, key)) {
+        if (Object.hasOwn(fields, key) || key in fields) {
             return ParserUtils.getField(fields, key)
         }
-        const upperKey = key.toUpperCase()
-        const realKey = Object.keys(fields).find(
-            (fieldKey) => fieldKey.toUpperCase() === upperKey
+        const realKey = PcbLayerStackReadModelBuilder.#fieldIndex(fields).get(
+            key.toUpperCase()
         )
 
         return realKey ? ParserUtils.getField(fields, realKey) : ''
     }
 
+    /**
+     * Builds or returns a cached case-insensitive field-key index.
+     * @param {Record<string, string | string[]>} fields Source fields.
+     * @returns {Map<string, string>}
+     */
+    static #fieldIndex(fields) {
+        const cached = PcbLayerStackReadModelBuilder.#fieldIndexes.get(fields)
+        if (cached) return cached
+
+        const fieldIndex = new Map()
+        for (const fieldKey of Object.keys(fields)) {
+            const upperKey = fieldKey.toUpperCase()
+            if (!fieldIndex.has(upperKey)) {
+                fieldIndex.set(upperKey, fieldKey)
+            }
+        }
+
+        PcbLayerStackReadModelBuilder.#fieldIndexes.set(fields, fieldIndex)
+        return fieldIndex
+    }
+
     /**
      * Parses layer-id lists.
      * @param {string} value Raw list value.

package/src/core/altium/PcbLayerStackSourceMetadataParser.mjs

@@ -8,6 +8,8 @@ import { ParserUtils } from './ParserUtils.mjs'
  * Parses source-only layer-stack metadata that is not part of core geometry.
  */
 export class PcbLayerStackSourceMetadataParser {
+    static #fieldIndexes = new WeakMap()
+
     /**
      * Parses source-aware extras for one layer-stack row.
      * @param {Record<string, string | string[]>} fields Source fields.
@@ -401,17 +403,38 @@ export class PcbLayerStackSourceMetadataParser {
      * @returns {string}
      */
     static #field(fields, key) {
-        if (Object.hasOwn(fields, key)) {
+        if (Object.hasOwn(fields, key) || key in fields) {
             return ParserUtils.getField(fields, key)
         }
-        const upperKey = key.toUpperCase()
-        const realKey = Object.keys(fields).find(
-            (fieldKey) => fieldKey.toUpperCase() === upperKey
-        )
+        const realKey = PcbLayerStackSourceMetadataParser.#fieldIndex(
+            fields
+        ).get(key.toUpperCase())
 
         return realKey ? ParserUtils.getField(fields, realKey) : ''
     }
 
+    /**
+     * Builds or returns a cached case-insensitive field-key index.
+     * @param {Record<string, string | string[]>} fields Source fields.
+     * @returns {Map<string, string>}
+     */
+    static #fieldIndex(fields) {
+        const cached =
+            PcbLayerStackSourceMetadataParser.#fieldIndexes.get(fields)
+        if (cached) return cached
+
+        const fieldIndex = new Map()
+        for (const fieldKey of Object.keys(fields)) {
+            const upperKey = fieldKey.toUpperCase()
+            if (!fieldIndex.has(upperKey)) {
+                fieldIndex.set(upperKey, fieldKey)
+            }
+        }
+
+        PcbLayerStackSourceMetadataParser.#fieldIndexes.set(fields, fieldIndex)
+        return fieldIndex
+    }
+
     /**
      * Splits a native list field.
      * @param {string} value Raw list value.

package/src/core/altium/PcbOwnershipGraphBuilder.mjs

@@ -228,9 +228,7 @@ export class PcbOwnershipGraphBuilder {
         if (!groups[key]) {
             groups[key] = fallbackGroup
         }
-        if (!groups[key].primitiveKeys.includes(primitiveKey)) {
-            groups[key].primitiveKeys.push(primitiveKey)
-        }
+        groups[key].primitiveKeys.push(primitiveKey)
     }
 
     /**

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)
     }
 
     /**