altium-toolkit 0.1.20 → 0.1.21

package/src/core/altium/SchematicStreamExtractor.mjs

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { AsciiRecordParser } from './AsciiRecordParser.mjs'
+import { OleCompoundDocument } from '../ole/OleCompoundDocument.mjs'
+import { OleConstants } from '../ole/OleConstants.mjs'
+
+/**
+ * Extracts stream-scoped printable schematic content from OLE-backed SchDoc
+ * containers.
+ */
+export class SchematicStreamExtractor {
+    /**
+     * Returns true when one buffer starts with the OLE compound-document
+     * signature.
+     * @param {ArrayBuffer} arrayBuffer
+     * @returns {boolean}
+     */
+    static isCompoundDocument(arrayBuffer) {
+        const bytes = new Uint8Array(
+            arrayBuffer,
+            0,
+            Math.min(
+                arrayBuffer.byteLength,
+                OleConstants.HEADER_SIGNATURE.length
+            )
+        )
+
+        if (bytes.byteLength < OleConstants.HEADER_SIGNATURE.length) {
+            return false
+        }
+
+        return OleConstants.HEADER_SIGNATURE.every(
+            (value, index) => bytes[index] === value
+        )
+    }
+
+    /**
+     * Extracts schematic records from the logical `FileHeader` stream.
+     * @param {ArrayBuffer} arrayBuffer
+     * @returns {{ records: Array<{ raw: string, fields: Record<string, string | string[]>, sourceStream: string }>, streamNames: string[] } | null}
+     */
+    static extractFromArrayBuffer(arrayBuffer) {
+        if (!SchematicStreamExtractor.isCompoundDocument(arrayBuffer)) {
+            return null
+        }
+
+        let compoundDocument
+
+        try {
+            compoundDocument = OleCompoundDocument.fromArrayBuffer(arrayBuffer)
+        } catch {
+            return null
+        }
+
+        let fileHeaderBytes
+
+        try {
+            fileHeaderBytes = compoundDocument.getStream('FileHeader')
+        } catch {
+            return null
+        }
+
+        const records = AsciiRecordParser.parse(
+            SchematicStreamExtractor.#toArrayBuffer(fileHeaderBytes)
+        ).map((record) => ({
+            ...record,
+            sourceStream: 'FileHeader'
+        }))
+
+        if (!records.length) {
+            return null
+        }
+
+        return {
+            records,
+            streamNames: compoundDocument.listStreams()
+        }
+    }
+
+    /**
+     * Returns an ArrayBuffer view over one byte slice.
+     * @param {Uint8Array} bytes
+     * @returns {ArrayBuffer}
+     */
+    static #toArrayBuffer(bytes) {
+        return bytes.buffer.slice(
+            bytes.byteOffset,
+            bytes.byteOffset + bytes.byteLength
+        )
+    }
+}

package/src/core/altium/SchematicTextPostProcessor.mjs

@@ -136,13 +136,25 @@ export class SchematicTextPostProcessor {
      * @param {{ x1: number, y1: number, x2: number, y2: number, ownerIndex?: string }[]} lines
      * @param {{ x: number, y: number, ownerIndex: string, length: number, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
      * @param {{ x: number, y: number, width: number, direction?: 'left' | 'right' | 'up' | 'down' }[]} ports
+     * @param {{ x: number, y: number, width: number, height: number, ownerIndex?: string }[]} rectangles
      * @returns {{ x: number, y: number, text: string, name?: string, ownerIndex?: string, recordType?: string, rotation?: number, anchor?: 'start' | 'middle' | 'end' }[]}
      */
-    static anchorComponentTextsFromOwnerBounds(texts, lines, pins, ports = []) {
+    static anchorComponentTextsFromOwnerBounds(
+        texts,
+        lines,
+        pins,
+        ports = [],
+        rectangles = []
+    ) {
         const ownerBounds = SchematicTextPostProcessor.#buildOwnerBounds(
             lines,
             pins
         )
+        const ownerBodyBounds = SchematicTextPostProcessor.#buildOwnerBounds(
+            lines,
+            pins,
+            rectangles
+        )
         const ownerPinCounts =
             SchematicTextPostProcessor.#buildOwnerPinCounts(pins)
         const ownerPinOrientations =
@@ -164,14 +176,11 @@ export class SchematicTextPostProcessor {
                 return text
             }
 
-            const paddedText = SchematicTextPostProcessor.#isDesignatorText(
-                text
-            )
-                ? SchematicTextPostProcessor.#padDesignatorAboveOwner(
-                      text,
-                      bounds
-                  )
-                : text
+            const paddedText =
+                SchematicTextPostProcessor.#padDesignatorAboveOwner(
+                    text,
+                    ownerBodyBounds.get(text.ownerIndex) || bounds
+                )
             const ownerPinCount = ownerPinCounts.get(text.ownerIndex) || 0
 
             if (text.y > bounds.maxY) {
@@ -290,12 +299,13 @@ export class SchematicTextPostProcessor {
     }
 
     /**
-     * Builds per-owner primitive bounds from drawable lines and pins.
+     * Builds per-owner primitive bounds from drawable lines, pins, and bodies.
      * @param {{ x1: number, y1: number, x2: number, y2: number, ownerIndex?: string }[]} lines
      * @param {{ x: number, y: number, ownerIndex: string }[]} pins
+     * @param {{ x: number, y: number, width: number, height: number, ownerIndex?: string }[]} rectangles
      * @returns {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>}
      */
-    static #buildOwnerBounds(lines, pins) {
+    static #buildOwnerBounds(lines, pins, rectangles = []) {
         const ownerBounds = new Map()
 
         for (const line of lines) {
@@ -325,6 +335,24 @@ export class SchematicTextPostProcessor {
             )
         }
 
+        for (const rectangle of rectangles) {
+            if (!rectangle.ownerIndex) {
+                continue
+            }
+
+            SchematicTextPostProcessor.#extendBounds(
+                ownerBounds,
+                rectangle.ownerIndex,
+                [
+                    { x: rectangle.x, y: rectangle.y },
+                    {
+                        x: rectangle.x + rectangle.width,
+                        y: rectangle.y + rectangle.height
+                    }
+                ]
+            )
+        }
+
         return ownerBounds
     }
 
@@ -506,7 +534,7 @@ export class SchematicTextPostProcessor {
      * @returns {{ x: number, y: number }}
      */
     static #padDesignatorAboveOwner(text, bounds) {
-        if (text.y <= bounds.maxY) {
+        if (text.y < bounds.maxY - 1 || text.y >= bounds.maxY + 4) {
             return text
         }