altium-toolkit 1.1.1 → 1.1.3

package/src/ui/SchematicContentLayout.mjs

@@ -721,7 +721,12 @@ export class SchematicContentLayout {
         }
 
         for (const text of schematic?.texts || []) {
-            coordinates.push([text.x, projectSchematicY(sheetHeight, text.y)])
+            coordinates.push(
+                ...SchematicContentLayout.#collectRenderedTextPoints(
+                    text,
+                    sheetHeight
+                )
+            )
         }
 
         for (const component of schematic?.components || []) {
@@ -829,6 +834,58 @@ export class SchematicContentLayout {
         }))
     }
 
+    /**
+     * Collects rendered bounds points for a text primitive.
+     * @param {{ x?: number, y?: number, recordType?: string, cornerX?: number, cornerY?: number, noteLines?: string[] }} text Text primitive.
+     * @param {number} sheetHeight Sheet height.
+     * @returns {number[][]}
+     */
+    static #collectRenderedTextPoints(text, sheetHeight) {
+        const x = Number(text?.x)
+        const y = Number(text?.y)
+
+        if (!Number.isFinite(x) || !Number.isFinite(y)) {
+            return []
+        }
+
+        if (SchematicContentLayout.#hasRenderedTextFrame(text)) {
+            const cornerX = Number(text.cornerX)
+            const cornerY = Number(text.cornerY)
+            const left = Math.min(x, cornerX)
+            const right = Math.max(x, cornerX)
+            const top = Math.min(
+                projectSchematicY(sheetHeight, y),
+                projectSchematicY(sheetHeight, cornerY)
+            )
+            const bottom = Math.max(
+                projectSchematicY(sheetHeight, y),
+                projectSchematicY(sheetHeight, cornerY)
+            )
+
+            return [
+                [left, top],
+                [right, bottom]
+            ]
+        }
+
+        return [[x, projectSchematicY(sheetHeight, y)]]
+    }
+
+    /**
+     * Returns true when a text primitive renders as a framed note/callout box.
+     * @param {{ recordType?: string, cornerX?: number, cornerY?: number, noteLines?: string[] }} text Text primitive.
+     * @returns {boolean}
+     */
+    static #hasRenderedTextFrame(text) {
+        const recordType = String(text?.recordType || '')
+
+        return Boolean(
+            (recordType === '28' || recordType === '209') &&
+            Number.isFinite(Number(text?.cornerX)) &&
+            Number.isFinite(Number(text?.cornerY))
+        )
+    }
+
     /**
      * Computes the inner endpoint for one schematic pin stub.
      * @param {{ x: number, y: number, length: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin

package/src/ui/SchematicImageRenderer.mjs

@@ -4,9 +4,11 @@
 
 import { SchematicSvgUtils } from './SchematicSvgUtils.mjs'
 import { SchematicColorResolver } from './SchematicColorResolver.mjs'
+import { SchematicPowerDiagramImageProcessor } from './SchematicPowerDiagramImageProcessor.mjs'
 
 const { escapeHtml, formatNumber, projectSchematicY } = SchematicSvgUtils
 const MISSING_IMAGE_WRAP_SAFETY_FACTOR = 0.96
+const BLUEPRINT_IMAGE_FILTER_ID = 'schematic-blueprint-image-filter'
 
 /**
  * Renders normalized schematic image placements.
@@ -16,15 +18,19 @@ export class SchematicImageRenderer {
      * Builds markup for embedded schematic images and unresolved placeholders.
      * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType?: string, dataBase64?: string, diagnosticState?: string, keepAspect?: boolean }[]} images
      * @param {number} sheetHeight
+     * @param {{ colorizeImages?: boolean, colorize_images?: boolean }} options Image render options.
      * @returns {string}
      */
-    static buildMarkup(images, sheetHeight) {
-        return images
+    static buildMarkup(images, sheetHeight, options = {}) {
+        const renderOptions =
+            SchematicImageRenderer.#normalizeRenderOptions(options)
+        const imageMarkup = images
             .map((image) =>
                 image.dataBase64 && image.mimeType
                     ? SchematicImageRenderer.#buildEmbeddedImageMarkup(
                           image,
-                          sheetHeight
+                          sheetHeight,
+                          renderOptions
                       )
                     : SchematicImageRenderer.#buildPlaceholderMarkup(
                           image,
@@ -32,19 +38,82 @@ export class SchematicImageRenderer {
                       )
             )
             .join('')
+
+        return (
+            SchematicImageRenderer.#buildImageFilterMarkup(
+                images,
+                renderOptions
+            ) + imageMarkup
+        )
+    }
+
+    /**
+     * Normalizes image renderer options.
+     * @param {{ colorizeImages?: boolean, colorize_images?: boolean }} options Raw options.
+     * @returns {{ colorizeImages: boolean }}
+     */
+    static #normalizeRenderOptions(options) {
+        return {
+            colorizeImages:
+                options?.colorizeImages === true ||
+                options?.colorize_images === true
+        }
+    }
+
+    /**
+     * Builds any SVG filters needed by the embedded image set.
+     * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType?: string, dataBase64?: string }[]} images
+     * @param {{ colorizeImages: boolean }} options Normalized render options.
+     * @returns {string}
+     */
+    static #buildImageFilterMarkup(images, options) {
+        if (!options.colorizeImages) return ''
+
+        const hasDiagramImage = (images || []).some(
+            (image) =>
+                image?.dataBase64 &&
+                image?.mimeType &&
+                SchematicImageRenderer.#isDiagramImage(image) &&
+                !SchematicImageRenderer.#isPowerDiagramImage(image)
+        )
+
+        if (!hasDiagramImage) return ''
+
+        return (
+            '<defs>' +
+            SchematicImageRenderer.#buildBlueprintImageFilterMarkup() +
+            '</defs>'
+        )
     }
 
     /**
      * Builds one embedded SVG image node.
-     * @param {{ x: number, y: number, cornerX: number, cornerY: number, mimeType: string, dataBase64: string, keepAspect?: boolean }} image
+     * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType: string, dataBase64: string, keepAspect?: boolean }} image
      * @param {number} sheetHeight
+     * @param {{ colorizeImages: boolean }} options Normalized render options.
      * @returns {string}
      */
-    static #buildEmbeddedImageMarkup(image, sheetHeight) {
+    static #buildEmbeddedImageMarkup(image, sheetHeight, options) {
         const bounds = SchematicImageRenderer.#resolveBounds(image, sheetHeight)
+        const isDiagramImage = SchematicImageRenderer.#isDiagramImage(image)
+        const isPowerDiagramImage =
+            SchematicImageRenderer.#isPowerDiagramImage(image)
+        const colorizeImage = options.colorizeImages
+        const dataBase64 =
+            colorizeImage && isPowerDiagramImage
+                ? SchematicPowerDiagramImageProcessor.process(image)
+                : image.dataBase64
 
         return (
-            '<image class="schematic-embedded-image" x="' +
+            '<image class="' +
+            escapeHtml(
+                isPowerDiagramImage
+                    ? 'schematic-embedded-image schematic-embedded-image--power-diagram'
+                    : isDiagramImage
+                      ? 'schematic-embedded-image schematic-embedded-image--diagram'
+                      : 'schematic-embedded-image'
+            ) +
+            '" x="' +
             formatNumber(bounds.x) +
             '" y="' +
             formatNumber(bounds.y) +
@@ -54,14 +123,60 @@ export class SchematicImageRenderer {
             formatNumber(bounds.height) +
             '" preserveAspectRatio="' +
             escapeHtml(image.keepAspect === false ? 'none' : 'xMidYMid meet') +
-            '" href="' +
-            escapeHtml(
-                'data:' + image.mimeType + ';base64,' + image.dataBase64
-            ) +
+            '"' +
+            (colorizeImage && isDiagramImage && !isPowerDiagramImage
+                ? ' filter="url(#' +
+                  escapeHtml(BLUEPRINT_IMAGE_FILTER_ID) +
+                  ')"'
+                : '') +
+            ' href="' +
+            escapeHtml('data:' + image.mimeType + ';base64,' + dataBase64) +
             '" />'
         )
     }
 
+    /**
+     * Builds a filter that maps black diagram artwork to the schematic blue
+     * ink while keeping white backgrounds white.
+     * @returns {string}
+     */
+    static #buildBlueprintImageFilterMarkup() {
+        return (
+            '<filter id="' +
+            escapeHtml(BLUEPRINT_IMAGE_FILTER_ID) +
+            '" color-interpolation-filters="sRGB">' +
+            '<feColorMatrix type="matrix" values="' +
+            '1 0 0 0 0 ' +
+            '0 0.431 0 0 0.569 ' +
+            '0 0 0.325 0 0.675 ' +
+            '0 0 0 1 0' +
+            '" />' +
+            '</filter>'
+        )
+    }
+
+    /**
+     * Identifies recovered diagram artwork by explicit file naming.
+     * @param {{ fileName?: string, mimeType?: string }} image
+     * @returns {boolean}
+     */
+    static #isDiagramImage(image) {
+        return /diagram/i.test(String(image?.fileName || ''))
+    }
+
+    /**
+     * Identifies recovered power-diagram PNG artwork for selective palette
+     * processing.
+     * @param {{ fileName?: string, mimeType?: string }} image
+     * @returns {boolean}
+     */
+    static #isPowerDiagramImage(image) {
+        return (
+            image?.mimeType === 'image/png' &&
+            /power/i.test(String(image?.fileName || ''))
+        )
+    }
+
     /**
      * Builds one placeholder frame when an image payload is unavailable.
      * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string }} image

package/src/ui/SchematicJunctionRenderer.mjs

@@ -44,7 +44,7 @@ export class SchematicJunctionRenderer {
                     formatNumber(projectSchematicY(sheetHeight, junction.y)) +
                     '" r="2" fill="' +
                     escapeHtml(
-                        SchematicColorResolver.resolveColor(
+                        SchematicColorResolver.resolveNonTextColor(
                             junction.color,
                             '--schematic-default-ink-color'
                         )

package/src/ui/SchematicNativeFooterPartitioner.mjs

@@ -0,0 +1,275 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Splits native Altium footer/template primitives from scalable schematic
+ * content when a standard template page is larger than the stored custom size.
+ */
+export class SchematicNativeFooterPartitioner {
+    /**
+     * Partitions render primitives into scalable content and fixed footer
+     * chrome.
+     * @param {{ lines?: object[], polygons?: object[], rectangles?: object[], roundedRectangles?: object[], ellipses?: object[], arcs?: object[], beziers?: object[], pies?: object[], ieeeSymbols?: object[], texts?: object[], images?: object[] }} primitives Primitive families.
+     * @param {{ width?: number, height?: number, sourceWidth?: number, sourceHeight?: number, marginWidth?: number, paperSize?: string, borderOn?: boolean }} sheet Sheet metadata.
+     * @returns {{ content: Record<string, object[]>, footer: Record<string, object[]>, footerBounds: { minX: number, minY: number, maxX: number, maxY: number } | null }}
+     */
+    static partitionPrimitives(primitives, sheet) {
+        const families = [
+            'lines',
+            'polygons',
+            'rectangles',
+            'roundedRectangles',
+            'ellipses',
+            'arcs',
+            'beziers',
+            'pies',
+            'ieeeSymbols',
+            'texts',
+            'images'
+        ]
+        const content = {}
+        const footer = {}
+
+        for (const family of families) {
+            const values = primitives?.[family] || []
+            content[family] = values.filter(
+                (primitive) =>
+                    !SchematicNativeFooterPartitioner.#isNativeFooterPrimitive(
+                        primitive,
+                        sheet
+                    )
+            )
+            footer[family] = values.filter((primitive) =>
+                SchematicNativeFooterPartitioner.#isNativeFooterPrimitive(
+                    primitive,
+                    sheet
+                )
+            )
+        }
+
+        return {
+            content,
+            footer,
+            footerBounds:
+                SchematicNativeFooterPartitioner.#resolvePrimitiveSetBounds(
+                    Object.values(footer).flat()
+                )
+        }
+    }
+
+    /**
+     * Returns true when one primitive is native lower-page footer chrome.
+     * @param {object} primitive Primitive candidate.
+     * @param {{ width?: number, height?: number, sourceWidth?: number, sourceHeight?: number, marginWidth?: number, paperSize?: string, borderOn?: boolean }} sheet Sheet metadata.
+     * @returns {boolean}
+     */
+    static #isNativeFooterPrimitive(primitive, sheet) {
+        if (!SchematicNativeFooterPartitioner.#shouldSplitNativeFooter(sheet)) {
+            return false
+        }
+        if (!String(primitive?.ownerIndex || '').trim()) {
+            return false
+        }
+
+        const bounds =
+            SchematicNativeFooterPartitioner.#resolvePrimitiveBounds(primitive)
+        if (!bounds) {
+            return false
+        }
+
+        const margin = Math.max(Number(sheet?.marginWidth || 20), 10)
+        const footerLimit = Math.max(margin * 6, 120)
+        const footerStartX = Math.max(Number(sheet?.width || 0), 0) * 0.5
+
+        return bounds.maxY <= footerLimit && bounds.maxX >= footerStartX
+    }
+
+    /**
+     * Returns true when promoted standard-sheet content needs fixed native
+     * footer handling.
+     * @param {{ width?: number, height?: number, sourceWidth?: number, sourceHeight?: number, paperSize?: string, borderOn?: boolean }} sheet Sheet metadata.
+     * @returns {boolean}
+     */
+    static #shouldSplitNativeFooter(sheet) {
+        const width = Number(sheet?.width || 0)
+        const height = Number(sheet?.height || 0)
+        const sourceWidth = Number(sheet?.sourceWidth || 0)
+        const sourceHeight = Number(sheet?.sourceHeight || 0)
+
+        return Boolean(
+            sheet?.borderOn &&
+            sheet?.paperSize &&
+            sourceWidth > 0 &&
+            sourceHeight > 0 &&
+            (width > sourceWidth || height > sourceHeight)
+        )
+    }
+
+    /**
+     * Resolves one primitive's document-space bounds.
+     * @param {object} primitive Primitive candidate.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolvePrimitiveBounds(primitive) {
+        const points =
+            SchematicNativeFooterPartitioner.#collectPrimitivePoints(primitive)
+        if (!points.length) {
+            return null
+        }
+
+        return {
+            minX: Math.min(...points.map((point) => point.x)),
+            minY: Math.min(...points.map((point) => point.y)),
+            maxX: Math.max(...points.map((point) => point.x)),
+            maxY: Math.max(...points.map((point) => point.y))
+        }
+    }
+
+    /**
+     * Resolves combined bounds for a set of primitives.
+     * @param {object[]} primitives Primitive candidates.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolvePrimitiveSetBounds(primitives) {
+        const bounds = primitives
+            .map((primitive) =>
+                SchematicNativeFooterPartitioner.#resolvePrimitiveBounds(
+                    primitive
+                )
+            )
+            .filter(Boolean)
+
+        if (!bounds.length) {
+            return null
+        }
+
+        return {
+            minX: Math.min(...bounds.map((bound) => bound.minX)),
+            minY: Math.min(...bounds.map((bound) => bound.minY)),
+            maxX: Math.max(...bounds.map((bound) => bound.maxX)),
+            maxY: Math.max(...bounds.map((bound) => bound.maxY))
+        }
+    }
+
+    /**
+     * Collects point coordinates from one normalized primitive.
+     * @param {object} primitive Primitive candidate.
+     * @returns {{ x: number, y: number }[]}
+     */
+    static #collectPrimitivePoints(primitive) {
+        if (Array.isArray(primitive?.points)) {
+            return primitive.points
+                .map((point) =>
+                    SchematicNativeFooterPartitioner.#point(point?.x, point?.y)
+                )
+                .filter(Boolean)
+        }
+        if (Array.isArray(primitive?.segments)) {
+            return primitive.segments.flatMap((segment) =>
+                [
+                    SchematicNativeFooterPartitioner.#point(
+                        segment?.x1,
+                        segment?.y1
+                    ),
+                    SchematicNativeFooterPartitioner.#point(
+                        segment?.x2,
+                        segment?.y2
+                    )
+                ].filter(Boolean)
+            )
+        }
+        if (
+            Number.isFinite(Number(primitive?.x1)) &&
+            Number.isFinite(Number(primitive?.y1)) &&
+            Number.isFinite(Number(primitive?.x2)) &&
+            Number.isFinite(Number(primitive?.y2))
+        ) {
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x1,
+                    primitive.y1
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x2,
+                    primitive.y2
+                )
+            ]
+        }
+        if (
+            Number.isFinite(Number(primitive?.cornerX)) &&
+            Number.isFinite(Number(primitive?.cornerY))
+        ) {
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x,
+                    primitive.y
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.cornerX,
+                    primitive.cornerY
+                )
+            ].filter(Boolean)
+        }
+        if (
+            Number.isFinite(Number(primitive?.width)) &&
+            Number.isFinite(Number(primitive?.height))
+        ) {
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x,
+                    primitive.y
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    Number(primitive.x || 0) + Number(primitive.width || 0),
+                    Number(primitive.y || 0) + Number(primitive.height || 0)
+                )
+            ].filter(Boolean)
+        }
+        if (
+            Number.isFinite(Number(primitive?.radius)) ||
+            Number.isFinite(Number(primitive?.radiusX))
+        ) {
+            const radiusX = Math.max(
+                Number(primitive?.radiusX || primitive?.radius || 0),
+                0
+            )
+            const radiusY = Math.max(
+                Number(primitive?.radiusY || primitive?.radius || 0),
+                0
+            )
+
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    Number(primitive.x || 0) - radiusX,
+                    Number(primitive.y || 0) - radiusY
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    Number(primitive.x || 0) + radiusX,
+                    Number(primitive.y || 0) + radiusY
+                )
+            ]
+        }
+
+        return [
+            SchematicNativeFooterPartitioner.#point(primitive?.x, primitive?.y)
+        ].filter(Boolean)
+    }
+
+    /**
+     * Builds one finite point.
+     * @param {number | string | undefined} x Raw x coordinate.
+     * @param {number | string | undefined} y Raw y coordinate.
+     * @returns {{ x: number, y: number } | null}
+     */
+    static #point(x, y) {
+        const normalizedX = Number(x)
+        const normalizedY = Number(y)
+
+        if (!Number.isFinite(normalizedX) || !Number.isFinite(normalizedY)) {
+            return null
+        }
+
+        return { x: normalizedX, y: normalizedY }
+    }
+}

package/src/ui/SchematicNoteRenderer.mjs

@@ -15,7 +15,7 @@ const MINIMUM_NOTE_TEXT_SIZE = 4
 export class SchematicNoteRenderer {
     /**
      * Builds one boxed schematic note/callout with wrapped text rows.
-     * @param {{ x: number, y: number, color: string, fontSize?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string, cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, lineWidth?: number, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }} text
+     * @param {{ x: number, y: number, color: string, fontSize?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string, anchor?: 'start' | 'middle' | 'end', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, lineWidth?: number, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }} text
      * @param {number} sheetHeight
      * @returns {string}
      */
@@ -59,6 +59,10 @@ export class SchematicNoteRenderer {
                 height,
                 requestedTextSize
             )
+        const compactMarkerNote = SchematicNoteRenderer.#isCompactMarkerNote(
+            noteSourceLines,
+            compactSingleLineNote
+        )
         const horizontalTextMargin =
             SchematicNoteRenderer.#resolveHorizontalTextMargin(
                 textMargin,
@@ -94,6 +98,7 @@ export class SchematicNoteRenderer {
                     lineHeight,
                     textSize,
                     compactSingleLineNote,
+                    compactMarkerNote,
                     text
                 )
             )
@@ -462,7 +467,8 @@ export class SchematicNoteRenderer {
      * @param {number} lineHeight
      * @param {number} textSize
      * @param {boolean} compactSingleLineNote
-     * @param {{ color: string, fontFamily?: string, fontWeight?: number, fontStyle?: string }} text
+     * @param {boolean} compactMarkerNote
+     * @param {{ color: string, fontFamily?: string, fontWeight?: number, fontStyle?: string, anchor?: 'start' | 'middle' | 'end' }} text
      * @returns {string}
      */
     static #buildNoteLineMarkup(
@@ -476,9 +482,21 @@ export class SchematicNoteRenderer {
         lineHeight,
         textSize,
         compactSingleLineNote,
+        compactMarkerNote,
         text
     ) {
-        const x = left + horizontalTextMargin
+        const anchor = SchematicNoteRenderer.#resolveTextAnchor(
+            text,
+            compactMarkerNote
+        )
+        const x = SchematicNoteRenderer.#resolveLineX(
+            left,
+            right,
+            horizontalTextMargin,
+            anchor
+        )
+        const ruleLeft = left + horizontalTextMargin
+        const ruleRight = right - horizontalTextMargin
         const y =
             top +
             verticalTextMargin +
@@ -491,11 +509,11 @@ export class SchematicNoteRenderer {
         if (/^_+$/.test(String(line || '').trim())) {
             return (
                 '<line class="schematic-note-rule" x1="' +
-                formatNumber(x) +
+                formatNumber(ruleLeft) +
                 '" y1="' +
                 formatNumber(y - textSize * 0.35) +
                 '" x2="' +
-                formatNumber(right - horizontalTextMargin) +
+                formatNumber(ruleRight) +
                 '" y2="' +
                 formatNumber(y - textSize * 0.35) +
                 '" stroke="' +
@@ -521,7 +539,9 @@ export class SchematicNoteRenderer {
                     '--schematic-text-color'
                 )
             ) +
-            '" text-anchor="start" font-size="' +
+            '" text-anchor="' +
+            escapeHtml(anchor) +
+            '" font-size="' +
             formatNumber(textSize) +
             '" font-family="' +
             escapeHtml(text.fontFamily || 'Times New Roman') +
@@ -534,6 +554,62 @@ export class SchematicNoteRenderer {
         )
     }
 
+    /**
+     * Resolves the x coordinate for a note line from its text anchor.
+     * @param {number} left Note box left edge.
+     * @param {number} right Note box right edge.
+     * @param {number} horizontalTextMargin Text margin.
+     * @param {'start' | 'middle' | 'end'} anchor Text anchor.
+     * @returns {number}
+     */
+    static #resolveLineX(left, right, horizontalTextMargin, anchor) {
+        if (anchor === 'middle') return (left + right) / 2
+        if (anchor === 'end') return right - horizontalTextMargin
+
+        return left + horizontalTextMargin
+    }
+
+    /**
+     * Returns true for tight single-token marker boxes that Altium centers
+     * inside the authored note rectangle.
+     * @param {string[]} noteLines Source note rows.
+     * @param {boolean} compactSingleLineNote True for tight one-line note boxes.
+     * @returns {boolean}
+     */
+    static #isCompactMarkerNote(noteLines, compactSingleLineNote) {
+        if (!compactSingleLineNote) {
+            return false
+        }
+
+        const visibleLines = noteLines
+            .map((line) => String(line || '').trim())
+            .filter(Boolean)
+
+        if (visibleLines.length !== 1) {
+            return false
+        }
+
+        return /^[A-Z0-9._/-]{1,4}$/u.test(visibleLines[0])
+    }
+
+    /**
+     * Normalizes note text anchors to SVG text-anchor values.
+     * @param {{ anchor?: string }} text Note text.
+     * @param {boolean} compactMarkerNote True for centered marker notes.
+     * @returns {'start' | 'middle' | 'end'}
+     */
+    static #resolveTextAnchor(text, compactMarkerNote) {
+        if (compactMarkerNote) {
+            return 'middle'
+        }
+
+        if (text.anchor === 'middle' || text.anchor === 'end') {
+            return text.anchor
+        }
+
+        return 'start'
+    }
+
     /**
      * Builds an optional note font-style attribute.
      * @param {string | undefined} fontStyle