altium-toolkit 1.1.39 → 1.1.40

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "altium-toolkit",
-    "version": "1.1.39",
+    "version": "1.1.40",
     "description": "Altium document parsing and non-interactive rendering utilities",
     "keywords": [
         "altium",

package/src/core/altium/SchematicPinParser.mjs

@@ -873,11 +873,18 @@ export class SchematicPinParser {
             ownerDrawnInternalPinOwners.has(ownerIndex) &&
             SchematicPinParser.#isCompactNumberedFetTerminalGroup(
                 normalizedPins,
-                semanticNames,
                 orientationCount
             )
         ) {
             labelMode = 'number-only'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isOwnerDrawnAmplifierTerminalGroup(
+                normalizedPins,
+                semanticNames
+            )
+        ) {
+            labelMode = 'number-only'
         } else if (
             SchematicPinParser.#isOwnerDrawnTerminalGlyphGroup(
                 normalizedPins,
@@ -957,32 +964,94 @@ export class SchematicPinParser {
     }
 
     /**
-     * Returns true when a compact owner-drawn FET body uses semantic terminal
-     * names internally but still exposes external numeric contact labels.
+     * Returns true when a compact owner-drawn FET body or pin array uses
+     * semantic terminal names internally but still exposes external numeric
+     * contact labels.
      * @param {{ designator: string, name: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
-     * @param {string[]} semanticNames
      * @param {number} orientationCount
      * @returns {boolean}
      */
-    static #isCompactNumberedFetTerminalGroup(
-        pins,
-        semanticNames,
-        orientationCount
-    ) {
+    static #isCompactNumberedFetTerminalGroup(pins, orientationCount) {
         if (
-            pins.length !== 4 ||
-            orientationCount < 3 ||
+            pins.length < 4 ||
+            pins.length > 12 ||
+            orientationCount < 2 ||
+            !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
+        ) {
+            return false
+        }
+
+        const normalizedNames = pins.map((pin) =>
+            String(pin.name || '')
+                .trim()
+                .toUpperCase()
+        )
+
+        return (
+            new Set(normalizedNames).size >= 2 &&
+            normalizedNames.every((name) =>
+                SchematicPinParser.#isFetTerminalName(name)
+            )
+        )
+    }
+
+    /**
+     * Returns true when an owner-drawn amplifier body already represents its
+     * input, output, and supply terminal names in the drawn symbol artwork.
+     * @param {{ designator: string, name: string }[]} pins
+     * @param {string[]} semanticNames
+     * @returns {boolean}
+     */
+    static #isOwnerDrawnAmplifierTerminalGroup(pins, semanticNames) {
+        if (
+            pins.length < 3 ||
+            pins.length > 8 ||
             semanticNames.length !== pins.length ||
             !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
         ) {
             return false
         }
 
-        return semanticNames.every((name) =>
-            SchematicPinParser.#isFetTerminalName(name)
+        const normalizedNames = semanticNames.map((name) =>
+            SchematicPinParser.#normalizeAmplifierTerminalName(name)
+        )
+
+        return (
+            normalizedNames.every(Boolean) &&
+            normalizedNames.some((name) => name === 'IN+' || name === 'IN-') &&
+            normalizedNames.includes('OUT')
         )
     }
 
+    /**
+     * Normalizes amplifier terminal names that are normally drawn inside the
+     * owner-authored symbol body.
+     * @param {string} name Raw pin name.
+     * @returns {string}
+     */
+    static #normalizeAmplifierTerminalName(name) {
+        const normalized = String(name || '')
+            .trim()
+            .toUpperCase()
+
+        switch (normalized) {
+            case 'IN+':
+            case '+IN':
+            case '+':
+                return 'IN+'
+            case 'IN-':
+            case '-IN':
+            case '-':
+                return 'IN-'
+            case 'OUT':
+            case 'V+':
+            case 'V-':
+                return normalized
+            default:
+                return ''
+        }
+    }
+
     /**
      * Returns true when a compact multi-side owner has transistor-like terminal
      * letters that are part of the drawn symbol body, not external pin labels.

package/src/ui/SchematicColorResolver.mjs

@@ -49,6 +49,12 @@ export class SchematicColorResolver {
             return normalized
         }
 
+        if (SchematicColorResolver.#isDefaultInkSourceColor(normalized)) {
+            return SchematicColorResolver.#toVariable(
+                '--schematic-default-ink-color'
+            )
+        }
+
         const token = COLOR_TOKEN_BY_VALUE.get(normalized)
 
         if (token) {
@@ -316,6 +322,30 @@ export class SchematicColorResolver {
         return Math.max(rgb.r, rgb.g, rgb.b) <= 32
     }
 
+    /**
+     * Returns true for dark saturated blue source colors that represent
+     * Altium's default schematic ink family rather than custom artwork color.
+     * @param {string} color Normalized color.
+     * @returns {boolean}
+     */
+    static #isDefaultInkSourceColor(color) {
+        const rgb = SchematicColorResolver.#parseHexColor(color)
+        if (!rgb) {
+            return false
+        }
+
+        const hsl = SchematicColorResolver.#rgbToHsl(rgb)
+        const hueDegrees = hsl.h * 360
+
+        return (
+            hueDegrees >= 220 &&
+            hueDegrees <= 270 &&
+            hsl.s >= 45 &&
+            hsl.l >= 12 &&
+            hsl.l <= 38
+        )
+    }
+
     /**
      * Converts RGB channels to HSL.
      * @param {{ r: number, g: number, b: number }} color