altium-toolkit 0.1.0 → 0.1.16

package/src/core/altium/PcbStreamExtractor.mjs

@@ -4,7 +4,11 @@
 
 import { AsciiRecordParser } from './AsciiRecordParser.mjs'
 import { PcbBinaryPrimitiveParser } from './PcbBinaryPrimitiveParser.mjs'
+import { PcbEmbeddedFontExtractor } from './PcbEmbeddedFontExtractor.mjs'
 import { PcbEmbeddedModelExtractor } from './PcbEmbeddedModelExtractor.mjs'
+import { PcbPrimitiveParameterParser } from './PcbPrimitiveParameterParser.mjs'
+import { PcbRawRecordRegistry } from './PcbRawRecordRegistry.mjs'
+import { PcbWideStringTableParser } from './PcbWideStringTableParser.mjs'
 import { OleCompoundDocument } from '../ole/OleCompoundDocument.mjs'
 import { OleConstants } from '../ole/OleConstants.mjs'
 
@@ -41,7 +45,7 @@ export class PcbStreamExtractor {
     /**
      * Extracts PCB content directly from one OLE-backed PcbDoc buffer.
      * @param {ArrayBuffer} arrayBuffer
-     * @returns {{ records: Array<{ raw: string, fields: Record<string, string | string[]>, sourceStream: string }>, streamNames: string[], binaryPrimitives: { fills: { x1: number, y1: number, x2: number, y2: number, layerCode: number }[], tracks: { x1: number, y1: number, x2: number, y2: number, width: number, layerCode: number }[], arcs: { x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode: number, layerId: number }[], vias: { x: number, y: number, diameter: number, holeDiameter: number }[], pads: { x: number, y: number, sizeTopX: number, sizeTopY: number, sizeMidX: number, sizeMidY: number, sizeBottomX: number, sizeBottomY: number, holeDiameter: number, shapeTop: number, shapeMid: number, shapeBottom: number, rotation: number, isPlated: boolean }[] }, diagnostics: { printableRecordCount: number, printableStreamCount: number, binaryPrimitiveCount: number } } | null}
+     * @returns {{ records: Array<{ raw: string, fields: Record<string, string | string[]>, sourceStream: string }>, streamNames: string[], binaryPrimitives: Record<string, object[]>, primitiveParameters: object, wideStrings: object, diagnostics: { printableRecordCount: number, printableStreamCount: number, binaryPrimitiveCount: number, primitiveParameterGroupCount: number, wideStringCount: number } } | null}
      */
     static extractFromArrayBuffer(arrayBuffer) {
         if (!PcbStreamExtractor.isCompoundDocument(arrayBuffer)) {
@@ -63,7 +67,7 @@ export class PcbStreamExtractor {
      * Extracts stream-scoped printable records and known binary primitives from
      * a stream map.
      * @param {Map<string, Uint8Array>} streams
-     * @returns {{ records: Array<{ raw: string, fields: Record<string, string | string[]>, sourceStream: string }>, streamNames: string[], binaryPrimitives: { fills: { x1: number, y1: number, x2: number, y2: number, layerCode: number }[], tracks: { x1: number, y1: number, x2: number, y2: number, width: number, layerCode: number }[], arcs: { x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode: number, layerId: number }[], vias: { x: number, y: number, diameter: number, holeDiameter: number }[], pads: { x: number, y: number, sizeTopX: number, sizeTopY: number, sizeMidX: number, sizeMidY: number, sizeBottomX: number, sizeBottomY: number, holeDiameter: number, shapeTop: number, shapeMid: number, shapeBottom: number, rotation: number, isPlated: boolean }[] }, diagnostics: { printableRecordCount: number, printableStreamCount: number, binaryPrimitiveCount: number } }}
+     * @returns {{ records: Array<{ raw: string, fields: Record<string, string | string[]>, sourceStream: string }>, streamNames: string[], binaryPrimitives: Record<string, object[]>, primitiveParameters: object, wideStrings: object, diagnostics: { printableRecordCount: number, printableStreamCount: number, binaryPrimitiveCount: number, primitiveParameterGroupCount: number, wideStringCount: number } }}
      */
     static extractFromStreams(streams) {
         const records = []
@@ -74,7 +78,11 @@ export class PcbStreamExtractor {
             tracks: [],
             arcs: [],
             vias: [],
-            pads: []
+            pads: [],
+            texts: [],
+            regions: [],
+            shapeBasedRegions: [],
+            boardRegions: []
         }
 
         for (const [name, bytes] of streams.entries()) {
@@ -82,6 +90,10 @@ export class PcbStreamExtractor {
                 continue
             }
 
+            if (PcbStreamExtractor.#isBinarySidecarDataStream(name)) {
+                continue
+            }
+
             const recordBuffer = PcbStreamExtractor.#toArrayBuffer(bytes)
             const streamRecords = AsciiRecordParser.parse(recordBuffer).map(
                 (record) => ({
@@ -109,6 +121,35 @@ export class PcbStreamExtractor {
         const fillDataBytes = streams.get('Fills6/Data')
         const padHeaderBytes = streams.get('Pads6/Header')
         const padDataBytes = streams.get('Pads6/Data')
+        const textHeaderBytes =
+            streams.get('Texts6/Header') || streams.get('Texts/Header')
+        const textDataBytes =
+            streams.get('Texts6/Data') || streams.get('Texts/Data')
+        const textStreamName = streams.has('Texts6/Data')
+            ? 'Texts6/Data'
+            : 'Texts/Data'
+        const regionHeaderBytes = streams.get('Regions6/Header')
+        const regionDataBytes = streams.get('Regions6/Data')
+        const shapeBasedRegionHeaderBytes = streams.get(
+            'ShapeBasedRegions6/Header'
+        )
+        const shapeBasedRegionDataBytes = streams.get('ShapeBasedRegions6/Data')
+        const boardRegionHeaderBytes = streams.get('BoardRegions/Header')
+        const boardRegionDataBytes = streams.get('BoardRegions/Data')
+        const primitiveParameters = PcbPrimitiveParameterParser.parse(
+            streams.get('PrimitiveParameters/Data')
+        )
+        const wideStrings = PcbWideStringTableParser.parse(
+            streams.get('WideStrings6/Data')
+        )
+
+        if (primitiveParameters.groups.length) {
+            usedStreamNames.add('PrimitiveParameters/Data')
+        }
+
+        if (wideStrings.entries.length) {
+            usedStreamNames.add('WideStrings6/Data')
+        }
 
         if (arcHeaderBytes && arcDataBytes) {
             binaryPrimitives.arcs = PcbBinaryPrimitiveParser.parseArcStream(
@@ -160,8 +201,61 @@ export class PcbStreamExtractor {
             }
         }
 
+        if (textHeaderBytes && textDataBytes) {
+            binaryPrimitives.texts = PcbBinaryPrimitiveParser.parseTextStream(
+                textHeaderBytes,
+                textDataBytes,
+                { wideStrings }
+            )
+            if (binaryPrimitives.texts.length) {
+                usedStreamNames.add(textStreamName)
+            }
+        }
+
+        if (regionHeaderBytes && regionDataBytes) {
+            binaryPrimitives.regions =
+                PcbBinaryPrimitiveParser.parseRegionStream(
+                    regionHeaderBytes,
+                    regionDataBytes
+                )
+            if (binaryPrimitives.regions.length) {
+                usedStreamNames.add('Regions6/Data')
+            }
+        }
+
+        if (shapeBasedRegionHeaderBytes && shapeBasedRegionDataBytes) {
+            binaryPrimitives.shapeBasedRegions =
+                PcbBinaryPrimitiveParser.parseRegionStream(
+                    shapeBasedRegionHeaderBytes,
+                    shapeBasedRegionDataBytes,
+                    { shapeBased: true }
+                )
+            if (binaryPrimitives.shapeBasedRegions.length) {
+                usedStreamNames.add('ShapeBasedRegions6/Data')
+            }
+        }
+
+        if (boardRegionHeaderBytes && boardRegionDataBytes) {
+            binaryPrimitives.boardRegions =
+                PcbBinaryPrimitiveParser.parseRegionStream(
+                    boardRegionHeaderBytes,
+                    boardRegionDataBytes
+                )
+            if (binaryPrimitives.boardRegions.length) {
+                usedStreamNames.add('BoardRegions/Data')
+            }
+        }
+
         const embeddedModels =
             PcbEmbeddedModelExtractor.extractFromStreams(streams)
+        const embeddedFonts =
+            PcbEmbeddedFontExtractor.extractFromStreams(streams)
+        const rawRecords = PcbRawRecordRegistry.collectPcbDocRecords(
+            streams,
+            binaryPrimitives
+        )
+
+        rawRecords.forEach((record) => usedStreamNames.add(record.sourceStream))
 
         if (
             embeddedModels.models.length ||
@@ -176,22 +270,40 @@ export class PcbStreamExtractor {
             )
         }
 
+        if (embeddedFonts.fonts.length) {
+            embeddedFonts.fonts.forEach((font) =>
+                usedStreamNames.add(font.sourceStream)
+            )
+        }
+
         return {
             records,
             streamNames: [...usedStreamNames].sort((left, right) =>
                 left.localeCompare(right)
             ),
             binaryPrimitives,
+            primitiveParameters,
+            wideStrings,
             embeddedModels,
+            embeddedFonts,
+            rawRecords,
             diagnostics: {
                 printableRecordCount: records.length,
                 printableStreamCount: printableStreamNames.size,
+                embeddedFontCount: embeddedFonts.fonts.length,
+                rawRecordCount: rawRecords.length,
+                primitiveParameterGroupCount: primitiveParameters.groups.length,
+                wideStringCount: wideStrings.entries.length,
                 binaryPrimitiveCount:
                     binaryPrimitives.arcs.length +
                     binaryPrimitives.tracks.length +
                     binaryPrimitives.vias.length +
                     binaryPrimitives.fills.length +
-                    binaryPrimitives.pads.length
+                    binaryPrimitives.pads.length +
+                    binaryPrimitives.texts.length +
+                    binaryPrimitives.regions.length +
+                    binaryPrimitives.shapeBasedRegions.length +
+                    binaryPrimitives.boardRegions.length
             }
         }
     }
@@ -207,4 +319,15 @@ export class PcbStreamExtractor {
             bytes.byteOffset + bytes.byteLength
         )
     }
+
+    /**
+     * Returns true for binary sidecar streams with printable-looking payloads.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static #isBinarySidecarDataStream(name) {
+        return (
+            name === 'PrimitiveParameters/Data' || name === 'WideStrings6/Data'
+        )
+    }
 }