altium-toolkit 0.1.0

package/src/ui/SchematicSvgUtils.mjs

@@ -0,0 +1,182 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Shared SVG and markup formatting helpers.
+ */
+export class SchematicSvgUtils {
+    /**
+     * Escapes user-facing markup.
+     * @param {string} value
+     * @returns {string}
+     */
+    static escapeHtml(value) {
+        return String(value)
+            .replaceAll('&', '&')
+            .replaceAll('<', '&lt;')
+            .replaceAll('>', '&gt;')
+            .replaceAll('"', '&quot;')
+    }
+
+    /**
+     * Formats a concise numeric attribute.
+     * @param {number} value
+     * @returns {string}
+     */
+    static formatNumber(value) {
+        return Number(value).toFixed(2).replace(/\.00$/, '')
+    }
+
+    /**
+     * Converts bottom-left schematic coordinates into SVG coordinates.
+     * @param {number} sheetHeight
+     * @param {number} value
+     * @returns {number}
+     */
+    static projectSchematicY(sheetHeight, value) {
+        return Number(sheetHeight) - Number(value)
+    }
+
+    /**
+     * Creates one escaped SVG text element.
+     * @param {string} className
+     * @param {number} x
+     * @param {number} y
+     * @param {string} text
+     * @param {string} color
+     * @param {'start' | 'end' | 'middle'} anchor
+     * @param {{ fontSize?: number, fontFamily?: string, fontWeight?: number, rotation?: number, segments?: { text: string, overline?: boolean }[] }} [options]
+     * @returns {string}
+     */
+    static createSvgText(className, x, y, text, color, anchor, options = {}) {
+        const hasSegments = Array.isArray(options.segments)
+            ? options.segments.some((segment) => segment?.text)
+            : false
+        const hasPlainText =
+            text !== undefined && text !== null && String(text).length > 0
+        if (!hasSegments && !hasPlainText) return ''
+
+        return (
+            '<text class="' +
+            SchematicSvgUtils.escapeHtml(className) +
+            '" x="' +
+            SchematicSvgUtils.formatNumber(x) +
+            '" y="' +
+            SchematicSvgUtils.formatNumber(y) +
+            '" fill="' +
+            SchematicSvgUtils.escapeHtml(color) +
+            '" text-anchor="' +
+            SchematicSvgUtils.escapeHtml(anchor) +
+            '"' +
+            SchematicSvgUtils.#buildSvgTextStyleAttributes(x, y, options) +
+            '>' +
+            SchematicSvgUtils.#buildSvgTextContent(text, options.segments) +
+            '</text>'
+        )
+    }
+
+    /**
+     * Returns only the trailing file segment for footer display.
+     * @param {string | undefined} fileName
+     * @returns {string}
+     */
+    static basename(fileName) {
+        if (!fileName) return ''
+        const parts = String(fileName).split(/[\\/]/)
+        return parts.at(-1) || ''
+    }
+
+    /**
+     * Formats the current date like Altium's default title block.
+     * @returns {string}
+     */
+    static buildCurrentDateValue() {
+        const today = new Date()
+        const month = String(today.getMonth() + 1)
+        const day = String(today.getDate()).padStart(2, '0')
+        return month + '/' + day + '/' + today.getFullYear()
+    }
+
+    /**
+     * Creates optional inline SVG text attributes for typography and rotation.
+     * @param {number} x
+     * @param {number} y
+     * @param {{ fontSize?: number, fontFamily?: string, fontWeight?: number, rotation?: number }} options
+     * @returns {string}
+     */
+    static #buildSvgTextStyleAttributes(x, y, options) {
+        let attributes = ''
+
+        if (options.fontSize) {
+            attributes +=
+                ' font-size="' +
+                SchematicSvgUtils.escapeHtml(
+                    SchematicSvgUtils.formatNumber(options.fontSize)
+                ) +
+                '"'
+        }
+
+        if (options.fontFamily) {
+            attributes +=
+                ' font-family="' +
+                SchematicSvgUtils.escapeHtml(options.fontFamily) +
+                '"'
+        }
+
+        if (options.fontWeight) {
+            attributes +=
+                ' font-weight="' +
+                SchematicSvgUtils.escapeHtml(String(options.fontWeight)) +
+                '"'
+        }
+
+        if (options.rotation) {
+            attributes +=
+                ' transform="rotate(' +
+                SchematicSvgUtils.escapeHtml(
+                    SchematicSvgUtils.formatNumber(options.rotation)
+                ) +
+                ' ' +
+                SchematicSvgUtils.escapeHtml(
+                    SchematicSvgUtils.formatNumber(x)
+                ) +
+                ' ' +
+                SchematicSvgUtils.escapeHtml(
+                    SchematicSvgUtils.formatNumber(y)
+                ) +
+                ')"'
+        }
+
+        return attributes
+    }
+
+    /**
+     * Builds escaped text or segmented tspan markup for one SVG text element.
+     * @param {string} text
+     * @param {{ text: string, overline?: boolean }[] | undefined} segments
+     * @returns {string}
+     */
+    static #buildSvgTextContent(text, segments) {
+        if (
+            Array.isArray(segments) &&
+            segments.some((segment) => segment?.text)
+        ) {
+            return segments
+                .filter((segment) => segment?.text)
+                .map(
+                    (segment) =>
+                        '<tspan text-decoration="' +
+                        SchematicSvgUtils.escapeHtml(
+                            segment.overline ? 'overline' : 'none'
+                        ) +
+                        '">' +
+                        SchematicSvgUtils.escapeHtml(segment.text) +
+                        '</tspan>'
+                )
+                .join('')
+        }
+
+        return SchematicSvgUtils.escapeHtml(text)
+    }
+}

package/src/ui/SchematicTypography.mjs

@@ -0,0 +1,204 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Shared typography helpers for synthetic schematic SVG labels.
+ */
+export class SchematicTypography {
+    /**
+     * Returns true when the schematic already contains a visible designator text
+     * close to one component origin.
+     * @param {{ x?: number, y?: number }} component
+     * @param {{ x: number, y: number, name?: string }[]} texts
+     * @returns {boolean}
+     */
+    static hasNearbyVisibleDesignatorText(component, texts) {
+        return texts.some(
+            (text) =>
+                String(text.name || '')
+                    .trim()
+                    .toLowerCase() === 'designator' &&
+                Math.abs(Number(text.x) - Number(component.x)) <= 80 &&
+                Math.abs(Number(text.y) - Number(component.y)) <= 80
+        )
+    }
+
+    /**
+     * Builds the default font options used for synthetic schematic labels.
+     * @param {{ fonts?: Record<string, { size: number, family: string, bold: boolean }> }} sheet
+     * @returns {{ fontSize: number, fontFamily: string, fontWeight: number }}
+     */
+    static buildDefaultSchematicFontOptions(sheet) {
+        const font = sheet?.fonts?.['1'] || {
+            size: 10,
+            family: 'Times New Roman',
+            bold: false
+        }
+
+        return {
+            fontSize: SchematicTypography.#toSvgFontSize(font.size),
+            fontFamily: font.family || 'Times New Roman',
+            fontWeight: font.bold ? 700 : 400
+        }
+    }
+
+    /**
+     * Builds default font options with the viewer-wide one-point reduction
+     * already applied.
+     * @param {{ fonts?: Record<string, { size: number, family: string, bold: boolean }> }} sheet
+     * @returns {{ fontSize: number | undefined, fontFamily: string, fontWeight: number }}
+     */
+    static buildViewerSchematicFontOptions(sheet) {
+        return SchematicTypography.withViewerFontSize(
+            SchematicTypography.buildDefaultSchematicFontOptions(sheet)
+        )
+    }
+
+    /**
+     * Builds render options for one schematic text label, including the signed
+     * SVG rotation derived from the original Altium orientation and mirrored
+     * source state.
+     * @param {{ fontSize?: number, fontFamily?: string, fontWeight?: number, rotation?: number, sourceOrientation?: number, isMirrored?: boolean }} text
+     * @returns {{ fontSize?: number, fontFamily?: string, fontWeight?: number, rotation?: number }}
+     */
+    static buildSchematicTextRenderOptions(text) {
+        return {
+            fontSize: SchematicTypography.resolveViewerFontSize(text.fontSize),
+            fontFamily: text.fontFamily,
+            fontWeight: text.fontWeight,
+            rotation: SchematicTypography.#resolveSignedTextRotation(
+                text.rotation,
+                text.sourceOrientation,
+                text.isMirrored
+            )
+        }
+    }
+
+    /**
+     * Applies the viewer-wide one-point text reduction to one option bag.
+     * @param {{ fontSize?: number, fontFamily?: string, fontWeight?: number, rotation?: number }} options
+     * @returns {{ fontSize?: number, fontFamily?: string, fontWeight?: number, rotation?: number }}
+     */
+    static withViewerFontSize(options) {
+        return {
+            ...options,
+            fontSize: SchematicTypography.resolveViewerFontSize(
+                options?.fontSize
+            )
+        }
+    }
+
+    /**
+     * Returns the one-point-smaller font size used for viewer text.
+     * @param {number | undefined} size
+     * @returns {number | undefined}
+     */
+    static resolveViewerFontSize(size) {
+        const numericSize = Number(size)
+
+        if (!Number.isFinite(numericSize) || numericSize <= 0) {
+            return undefined
+        }
+
+        return Math.max(numericSize - 1, 1)
+    }
+
+    /**
+     * Collects number-only owner groups whose top pin numbers should rotate
+     * along the vertical pin axis.
+     * @param {{ ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom', labelMode?: 'hidden' | 'number-only' | 'name-only' | 'name-and-number' }[]} pins
+     * @returns {Set<string>}
+     */
+    static collectRotatedVerticalNumberOwners(pins) {
+        const ownerPins = new Map()
+
+        for (const pin of pins) {
+            const ownerIndex = String(pin.ownerIndex || '').trim()
+            if (!ownerIndex) continue
+            if (!ownerPins.has(ownerIndex)) ownerPins.set(ownerIndex, [])
+            ownerPins.get(ownerIndex).push(pin)
+        }
+
+        return new Set(
+            [...ownerPins.entries()]
+                .filter(([, groupedPins]) => {
+                    const hasTopPin = groupedPins.some(
+                        (pin) => pin.orientation === 'top'
+                    )
+                    const hasHorizontalPins = groupedPins.some(
+                        (pin) =>
+                            pin.orientation === 'left' ||
+                            pin.orientation === 'right'
+                    )
+                    return (
+                        groupedPins.length >= 4 &&
+                        hasTopPin &&
+                        hasHorizontalPins &&
+                        groupedPins.every(
+                            (pin) =>
+                                (pin.labelMode || 'name-and-number') ===
+                                'number-only'
+                        )
+                    )
+                })
+                .map(([ownerIndex]) => ownerIndex)
+        )
+    }
+
+    /**
+     * Collects owner/text pairs that already expose explicit pin-name labels as
+     * free text primitives, so the pin renderer can avoid duplicating them.
+     * @param {{ ownerIndex?: string, recordType?: string, text?: string }[]} texts
+     * @returns {Set<string>}
+     */
+    static collectExplicitOwnerPinNameLabels(texts) {
+        return new Set(
+            texts
+                .filter(
+                    (text) =>
+                        text &&
+                        text.recordType === '4' &&
+                        String(text.ownerIndex || '').trim() &&
+                        String(text.text || '').trim()
+                )
+                .map(
+                    (text) =>
+                        String(text.ownerIndex || '').trim() +
+                        '::' +
+                        String(text.text || '').trim()
+                )
+        )
+    }
+
+    /**
+     * Converts Altium point sizes into SVG font units.
+     * @param {number} size
+     * @returns {number}
+     */
+    static #toSvgFontSize(size) {
+        return Number(size || 10)
+    }
+
+    /**
+     * Resolves the signed SVG rotation for one schematic text label.
+     * @param {number | undefined} rotation
+     * @param {number | undefined} sourceOrientation
+     * @param {boolean | undefined} isMirrored
+     * @returns {number}
+     */
+    static #resolveSignedTextRotation(rotation, sourceOrientation, isMirrored) {
+        const normalizedRotation = Number(rotation || 0)
+
+        if (!normalizedRotation) {
+            return 0
+        }
+
+        const signedRotation =
+            Number(sourceOrientation || 0) === 3
+                ? normalizedRotation
+                : -normalizedRotation
+
+        return isMirrored ? -signedRotation : signedRotation
+    }
+}

package/src/workers/altium-parser.worker.mjs

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { AltiumParser } from '../core/altium/AltiumParser.mjs'
+
+self.addEventListener('message', (event) => {
+    const payload = event?.data || {}
+    if (payload.type !== 'parse:file') return
+
+    try {
+        const documentModel = AltiumParser.parseArrayBuffer(
+            String(payload.fileName || 'document'),
+            payload.buffer
+        )
+        self.postMessage({
+            type: 'parser:success',
+            requestId: String(payload.requestId || ''),
+            documentModel
+        })
+    } catch (error) {
+        self.postMessage({
+            type: 'parser:error',
+            requestId: String(payload.requestId || ''),
+            message:
+                error instanceof Error ? error.message : 'Parser worker failed.'
+        })
+    }
+})