altium-toolkit 1.1.3 → 1.1.22

package/src/ui/SchematicColorResolver.mjs

@@ -31,6 +31,7 @@ export class SchematicColorResolver {
      * Resolves one SVG color value to a schematic theme variable.
      * @param {string | undefined} color
      * @param {string} fallbackVariable
+     * @param {boolean} [preserveUnknown]
      * @returns {string}
      */
     static resolveColor(color, fallbackVariable, preserveUnknown = false) {
@@ -88,6 +89,7 @@ export class SchematicColorResolver {
      * Resolves one SVG fill value to a schematic theme variable.
      * @param {string | undefined} fill
      * @param {string} fallbackVariable
+     * @param {boolean} [preserveUnknown]
      * @returns {string}
      */
     static resolveFill(fill, fallbackVariable, preserveUnknown = false) {
@@ -153,6 +155,32 @@ export class SchematicColorResolver {
         )
     }
 
+    /**
+     * Resolves an authored source stroke through a muted source palette.
+     * @param {string | undefined} color
+     * @param {string} fallbackVariable
+     * @returns {string}
+     */
+    static resolveMutedSourceColor(color, fallbackVariable) {
+        return SchematicColorResolver.#resolveMutedSourcePaint(
+            color,
+            fallbackVariable
+        )
+    }
+
+    /**
+     * Resolves an authored source fill through a muted source palette.
+     * @param {string | undefined} fill
+     * @param {string} fallbackVariable
+     * @returns {string}
+     */
+    static resolveMutedSourceFill(fill, fallbackVariable) {
+        return SchematicColorResolver.#resolveMutedSourcePaint(
+            fill,
+            fallbackVariable
+        )
+    }
+
     /**
      * Resolves one literal source paint value while preserving SVG control
      * values and falling back only when no source paint exists.
@@ -178,6 +206,42 @@ export class SchematicColorResolver {
         return normalized
     }
 
+    /**
+     * Resolves one literal source paint while reducing vivid palette colors.
+     * @param {string | undefined} paint
+     * @param {string} fallbackVariable
+     * @returns {string}
+     */
+    static #resolveMutedSourcePaint(paint, fallbackVariable) {
+        const normalized = SchematicColorResolver.#normalizeColor(paint)
+
+        if (!normalized) {
+            return SchematicColorResolver.#toVariable(fallbackVariable)
+        }
+
+        if (
+            normalized === 'none' ||
+            normalized === 'transparent' ||
+            normalized.startsWith('var(')
+        ) {
+            return normalized
+        }
+
+        const rgb = SchematicColorResolver.#parseHexColor(normalized)
+        if (!rgb) {
+            return normalized
+        }
+
+        const hsl = SchematicColorResolver.#rgbToHsl(rgb)
+        const mutedRgb = SchematicColorResolver.#hslToRgb({
+            h: hsl.h,
+            s: Math.min(hsl.s, 45),
+            l: Math.min(Math.max(hsl.l, 30), 68)
+        })
+
+        return SchematicColorResolver.#formatHexColor(mutedRgb)
+    }
+
     /**
      * Normalizes one raw color string for token lookup.
      * @param {string | undefined} color
@@ -189,6 +253,127 @@ export class SchematicColorResolver {
             .toLowerCase()
     }
 
+    /**
+     * Parses a six-digit hex color.
+     * @param {string} color
+     * @returns {{ r: number, g: number, b: number } | null}
+     */
+    static #parseHexColor(color) {
+        const match = /^#([0-9a-f]{6})$/u.exec(color)
+        if (!match) {
+            return null
+        }
+
+        const value = match[1]
+        return {
+            r: Number.parseInt(value.slice(0, 2), 16),
+            g: Number.parseInt(value.slice(2, 4), 16),
+            b: Number.parseInt(value.slice(4, 6), 16)
+        }
+    }
+
+    /**
+     * Converts RGB channels to HSL.
+     * @param {{ r: number, g: number, b: number }} color
+     * @returns {{ h: number, s: number, l: number }}
+     */
+    static #rgbToHsl(color) {
+        const r = color.r / 255
+        const g = color.g / 255
+        const b = color.b / 255
+        const max = Math.max(r, g, b)
+        const min = Math.min(r, g, b)
+        let h = 0
+        let s = 0
+        const l = ((max + min) / 2) * 100
+
+        if (max !== min) {
+            const delta = max - min
+            s =
+                ((max + min) / 2 > 0.5
+                    ? delta / (2 - max - min)
+                    : delta / (max + min)) * 100
+
+            switch (max) {
+                case r:
+                    h = (g - b) / delta + (g < b ? 6 : 0)
+                    break
+                case g:
+                    h = (b - r) / delta + 2
+                    break
+                default:
+                    h = (r - g) / delta + 4
+                    break
+            }
+
+            h /= 6
+        }
+
+        return { h, s, l }
+    }
+
+    /**
+     * Converts HSL channels to RGB.
+     * @param {{ h: number, s: number, l: number }} color
+     * @returns {{ r: number, g: number, b: number }}
+     */
+    static #hslToRgb(color) {
+        const s = color.s / 100
+        const l = color.l / 100
+
+        if (s === 0) {
+            const value = Math.round(l * 255)
+            return { r: value, g: value, b: value }
+        }
+
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s
+        const p = 2 * l - q
+        const r = SchematicColorResolver.#hueToRgb(p, q, color.h + 1 / 3)
+        const g = SchematicColorResolver.#hueToRgb(p, q, color.h)
+        const b = SchematicColorResolver.#hueToRgb(p, q, color.h - 1 / 3)
+
+        return {
+            r: Math.round(r * 255),
+            g: Math.round(g * 255),
+            b: Math.round(b * 255)
+        }
+    }
+
+    /**
+     * Converts one hue channel to RGB.
+     * @param {number} p
+     * @param {number} q
+     * @param {number} t
+     * @returns {number}
+     */
+    static #hueToRgb(p, q, t) {
+        let value = t
+        if (value < 0) value += 1
+        if (value > 1) value -= 1
+        if (value < 1 / 6) return p + (q - p) * 6 * value
+        if (value < 1 / 2) return q
+        if (value < 2 / 3) return p + (q - p) * (2 / 3 - value) * 6
+        return p
+    }
+
+    /**
+     * Formats RGB channels as a hex color.
+     * @param {{ r: number, g: number, b: number }} color
+     * @returns {string}
+     */
+    static #formatHexColor(color) {
+        return (
+            '#' +
+            [color.r, color.g, color.b]
+                .map((channel) =>
+                    Math.max(0, Math.min(255, channel))
+                        .toString(16)
+                        .padStart(2, '0')
+                )
+                .join('')
+        )
+    }
+
     /**
      * Wraps one CSS custom property name in `var(...)` markup.
      * @param {string} variableName

package/src/ui/SchematicDirectiveRenderer.mjs

@@ -50,32 +50,45 @@ export class SchematicDirectiveRenderer {
                 return SchematicDirectiveRenderer.#buildRouteMarkup(
                     directive,
                     sheetHeight,
-                    sheet
+                    sheet,
+                    'route'
                 )
             default:
-                return ''
+                return directive?.name
+                    ? SchematicDirectiveRenderer.#buildRouteMarkup(
+                          directive,
+                          sheetHeight,
+                          sheet,
+                          'parameter-set'
+                      )
+                    : ''
         }
     }
 
     /**
-     * Builds the labeled route-callout marker for one differential-pair
-     * routing directive.
-     * @param {{ x: number, y: number, color: string, orientation?: number }} directive
+     * Builds the labeled info-callout marker for one parameter-set directive.
+     * @param {{ x: number, y: number, color: string, name: string, orientation?: number }} directive
      * @param {number} sheetHeight
      * @param {{ fonts?: Record<string, { size: number, family: string, bold: boolean }> }} sheet
+     * @param {string} classModifier
      * @returns {string}
      */
-    static #buildRouteMarkup(directive, sheetHeight, sheet) {
+    static #buildRouteMarkup(directive, sheetHeight, sheet, classModifier) {
         const color = SchematicColorResolver.resolveColor(
             directive.color,
             '--schematic-alert-color'
         )
         const projectedY = projectSchematicY(sheetHeight, directive.y)
-        const verticalDirection =
-            Number(directive.orientation || 0) === 3 ? 1 : -1
+        const direction = SchematicDirectiveRenderer.#resolveCalloutDirection(
+            directive.orientation
+        )
         const circleRadius = 7
-        const circleCenterY = projectedY + verticalDirection * 18
-        const leaderEndY = circleCenterY - verticalDirection * circleRadius
+        const calloutDistance =
+            SchematicDirectiveRenderer.#resolveCalloutDistance(direction)
+        const circleCenterX = directive.x + direction.x * calloutDistance
+        const circleCenterY = projectedY + direction.y * calloutDistance
+        const leaderEndX = circleCenterX - direction.x * circleRadius
+        const leaderEndY = circleCenterY - direction.y * circleRadius
         const labelOptions =
             SchematicTypography.buildViewerSchematicFontOptions(sheet)
         const infoOptions = {
@@ -83,26 +96,32 @@ export class SchematicDirectiveRenderer {
             fontSize: Math.max(Number(labelOptions.fontSize || 9) - 1, 6),
             fontWeight: 700
         }
-        const labelY =
-            circleCenterY +
-            verticalDirection *
-                (circleRadius + Number(labelOptions.fontSize || 9))
+        const labelPlacement =
+            SchematicDirectiveRenderer.#resolveLabelPlacement(
+                circleCenterX,
+                circleCenterY,
+                direction,
+                circleRadius,
+                Number(labelOptions.fontSize || 9)
+            )
 
         return (
-            '<g class="schematic-directive schematic-directive--route">' +
+            '<g class="schematic-directive schematic-directive--' +
+            escapeHtml(classModifier) +
+            '">' +
             '<line x1="' +
             formatNumber(directive.x) +
             '" y1="' +
             formatNumber(projectedY) +
             '" x2="' +
-            formatNumber(directive.x) +
+            formatNumber(leaderEndX) +
             '" y2="' +
             formatNumber(leaderEndY) +
             '" stroke="' +
             escapeHtml(color) +
             '" stroke-width="1" />' +
             '<circle cx="' +
-            formatNumber(directive.x) +
+            formatNumber(circleCenterX) +
             '" cy="' +
             formatNumber(circleCenterY) +
             '" r="' +
@@ -112,17 +131,20 @@ export class SchematicDirectiveRenderer {
             '" stroke-width="1" />' +
             createSvgText(
                 'schematic-directive-label',
-                directive.x,
-                labelY,
+                labelPlacement.x,
+                labelPlacement.y,
                 String(directive.name || ''),
                 color,
-                'middle',
+                labelPlacement.anchor,
                 labelOptions
             ) +
             createSvgText(
                 'schematic-directive-info',
-                directive.x,
-                circleCenterY + Number(infoOptions.fontSize || 8) * 0.34,
+                circleCenterX,
+                circleCenterY +
+                    SchematicDirectiveRenderer.#baselineOffset(
+                        Number(infoOptions.fontSize || 8)
+                    ),
                 'i',
                 color,
                 'middle',
@@ -132,6 +154,95 @@ export class SchematicDirectiveRenderer {
         )
     }
 
+    /**
+     * Resolves Altium's four-way callout orientation into an outward vector.
+     * @param {number | undefined} orientation
+     * @returns {{ x: number, y: number }}
+     */
+    static #resolveCalloutDirection(orientation) {
+        switch (Number(orientation || 0)) {
+            case 1:
+                return { x: 0, y: -1 }
+            case 2:
+                return { x: -1, y: 0 }
+            case 3:
+                return { x: 0, y: 1 }
+            default:
+                return { x: 1, y: 0 }
+        }
+    }
+
+    /**
+     * Resolves the distance from a directive anchor to its info marker center.
+     * @param {{ x: number, y: number }} direction
+     * @returns {number}
+     */
+    static #resolveCalloutDistance(direction) {
+        return direction.y < 0 ? 12 : 18
+    }
+
+    /**
+     * Resolves label placement outside one directive info marker.
+     * @param {number} circleCenterX
+     * @param {number} circleCenterY
+     * @param {{ x: number, y: number }} direction
+     * @param {number} circleRadius
+     * @param {number} fontSize
+     * @returns {{ x: number, y: number, anchor: 'start' | 'middle' | 'end' }}
+     */
+    static #resolveLabelPlacement(
+        circleCenterX,
+        circleCenterY,
+        direction,
+        circleRadius,
+        fontSize
+    ) {
+        const labelDistance = circleRadius + fontSize
+
+        if (direction.x < 0) {
+            return {
+                x: circleCenterX - labelDistance,
+                y:
+                    circleCenterY +
+                    SchematicDirectiveRenderer.#baselineOffset(fontSize),
+                anchor: 'end'
+            }
+        }
+
+        if (direction.x > 0) {
+            return {
+                x: circleCenterX + labelDistance,
+                y:
+                    circleCenterY +
+                    SchematicDirectiveRenderer.#baselineOffset(fontSize),
+                anchor: 'start'
+            }
+        }
+
+        if (direction.y < 0) {
+            return {
+                x: circleCenterX,
+                y: circleCenterY - circleRadius - 2,
+                anchor: 'middle'
+            }
+        }
+
+        return {
+            x: circleCenterX,
+            y: circleCenterY + direction.y * labelDistance,
+            anchor: 'middle'
+        }
+    }
+
+    /**
+     * Returns a baseline offset that visually centers text around a marker.
+     * @param {number} fontSize
+     * @returns {number}
+     */
+    static #baselineOffset(fontSize) {
+        return fontSize * 0.34
+    }
+
     /**
      * Builds the paired-trace differential-pair marker glyph.
      * @param {{ x: number, y: number, color: string }} directive

package/src/ui/SchematicLineColorResolver.mjs

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { SchematicColorResolver } from './SchematicColorResolver.mjs'
+
+/**
+ * Resolves schematic line stroke colors from normalized line metadata.
+ */
+export class SchematicLineColorResolver {
+    /**
+     * Resolves one schematic line stroke color.
+     * @param {{ color?: string, ownerIndex?: string, isBus?: boolean, recordType?: string, x1?: number, x2?: number }} line Line primitive.
+     * @returns {string}
+     */
+    static resolveColor(line) {
+        if (SchematicLineColorResolver.isElectricalLine(line)) {
+            return SchematicColorResolver.resolveNonTextColor(
+                line?.color,
+                '--schematic-default-ink-color'
+            )
+        }
+
+        if (SchematicLineColorResolver.#isOwnerVerticalLine(line)) {
+            const resolvedColor = SchematicColorResolver.resolveNonTextColor(
+                line?.color,
+                '--schematic-default-ink-color',
+                true
+            )
+            return resolvedColor.startsWith('var(')
+                ? resolvedColor
+                : SchematicColorResolver.resolveMutedSourceColor(
+                      line?.color,
+                      '--schematic-default-ink-color'
+                  )
+        }
+
+        return SchematicColorResolver.resolveColor(
+            line?.color,
+            '--schematic-default-ink-color'
+        )
+    }
+
+    /**
+     * Returns true when one normalized line can carry schematic net color.
+     * @param {{ ownerIndex?: string, isBus?: boolean, recordType?: string } | null | undefined} line Line primitive.
+     * @returns {boolean}
+     */
+    static isElectricalLine(line) {
+        if (line?.ownerIndex || line?.isBus === true) {
+            return false
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(line || {}, 'recordType')) {
+            return true
+        }
+
+        return !['6', '7', '26'].includes(String(line.recordType || ''))
+    }
+
+    /**
+     * Returns true when owner geometry encodes a vertical side rail as a line.
+     * @param {{ ownerIndex?: string, x1?: number, x2?: number } | null | undefined} line Line primitive.
+     * @returns {boolean}
+     */
+    static #isOwnerVerticalLine(line) {
+        return (
+            Boolean(String(line?.ownerIndex || '').trim()) &&
+            SchematicLineColorResolver.#isVerticalLine(line)
+        )
+    }
+
+    /**
+     * Returns true when one line is vertical within parser coordinate tolerance.
+     * @param {{ x1?: number, x2?: number } | null | undefined} line Line primitive.
+     * @returns {boolean}
+     */
+    static #isVerticalLine(line) {
+        const x1 = Number(line?.x1)
+        const x2 = Number(line?.x2)
+
+        return (
+            Number.isFinite(x1) &&
+            Number.isFinite(x2) &&
+            Math.abs(x1 - x2) <= 0.001
+        )
+    }
+}

package/src/ui/SchematicNoteRenderer.mjs

@@ -8,6 +8,7 @@ import { SchematicTypography } from './SchematicTypography.mjs'
 
 const { escapeHtml, formatNumber, projectSchematicY } = SchematicSvgUtils
 const MINIMUM_NOTE_TEXT_SIZE = 4
+const COMPACT_SINGLE_LINE_HEIGHT_RATIO = 1.6
 
 /**
  * Renders boxed schematic notes recovered from Altium note records.
@@ -328,7 +329,10 @@ export class SchematicNoteRenderer {
             String(line || '').trim()
         ).length
 
-        return visibleLineCount === 1 && height <= requestedTextSize * 1.5
+        return (
+            visibleLineCount === 1 &&
+            height <= requestedTextSize * COMPACT_SINGLE_LINE_HEIGHT_RATIO
+        )
     }
 
     /**