altium-toolkit 1.1.23 → 1.1.25

package/src/core/altium/UnsupportedFeatureReportBuilder.mjs

@@ -10,7 +10,7 @@ export class UnsupportedFeatureReportBuilder {
 
     /**
      * Builds an unsupported feature report.
-     * @param {{ models?: object[], recordTypes?: object[], rawRecords?: object[], opaqueRecords?: object[], diagnostics?: object[] }} [input] Report input.
+     * @param {{ models?: object[], recordTypes?: object[], rawRecords?: object[], opaqueRecords?: object[], diagnostics?: object[], edgeCases?: object[] }} [input] Report input.
      * @returns {object}
      */
     static build(input = {}) {
@@ -32,11 +32,16 @@ export class UnsupportedFeatureReportBuilder {
             input,
             models
         )
+        const edgeCases = UnsupportedFeatureReportBuilder.#edgeCases(
+            input,
+            models
+        )
         const itemCount =
             recordTypes.length +
             rawRecords.length +
             opaqueRecords.length +
-            diagnostics.length
+            diagnostics.length +
+            edgeCases.length
 
         return {
             schema: UnsupportedFeatureReportBuilder.SCHEMA,
@@ -46,13 +51,15 @@ export class UnsupportedFeatureReportBuilder {
                 rawRecordCount: rawRecords.length,
                 opaqueRecordCount: opaqueRecords.length,
                 diagnosticCount: diagnostics.length,
+                edgeCaseCount: edgeCases.length,
                 itemCount,
                 status: itemCount ? 'unsupported' : 'supported'
             },
             recordTypes,
             rawRecords,
             opaqueRecords,
-            diagnostics
+            diagnostics,
+            edgeCases
         }
     }
 
@@ -344,6 +351,506 @@ export class UnsupportedFeatureReportBuilder {
             )
     }
 
+    /**
+     * Collects parser edge-case coverage rows.
+     * @param {object} input Report input.
+     * @param {object[]} models Parser roots.
+     * @returns {object[]}
+     */
+    static #edgeCases(input, models) {
+        return UnsupportedFeatureReportBuilder.#dedupeEdgeCases(
+            [
+                ...(Array.isArray(input?.edgeCases)
+                    ? input.edgeCases.map((edgeCase) => ({
+                          edgeCase: edgeCase || {},
+                          fileName: edgeCase?.fileName || '',
+                          domain: edgeCase?.domain || ''
+                      }))
+                    : []),
+                ...models.flatMap((model) =>
+                    (model?.diagnostics || [])
+                        .filter((diagnostic) =>
+                            UnsupportedFeatureReportBuilder.#isEdgeCaseDiagnostic(
+                                diagnostic
+                            )
+                        )
+                        .map((diagnostic) => ({
+                            edgeCase: diagnostic,
+                            fileName:
+                                model.fileName || diagnostic.fileName || '',
+                            domain: diagnostic.domain || ''
+                        }))
+                ),
+                ...models.flatMap((model) =>
+                    UnsupportedFeatureReportBuilder.#modelDerivedEdgeCases(
+                        model
+                    )
+                )
+            ].map(({ edgeCase, fileName, domain }) =>
+                UnsupportedFeatureReportBuilder.#stripUndefined({
+                    fileName,
+                    domain,
+                    code: edgeCase.code,
+                    feature: edgeCase.feature,
+                    supportState: edgeCase.supportState,
+                    severity: edgeCase.severity,
+                    message: edgeCase.message,
+                    source: edgeCase.source,
+                    sourceStream: edgeCase.sourceStream,
+                    sourceStorage: edgeCase.sourceStorage,
+                    recordIndex:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            edgeCase.recordIndex
+                        ),
+                    recordType:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            edgeCase.recordType
+                        ),
+                    errorKind: edgeCase.errorKind
+                })
+            )
+        )
+    }
+
+    /**
+     * Collects compatibility edge cases derivable from parsed model data.
+     * @param {object} model Parser root.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }[]}
+     */
+    static #modelDerivedEdgeCases(model) {
+        const fileName = String(model?.fileName || '')
+        const pcb = model?.pcb || {}
+
+        return [
+            ...UnsupportedFeatureReportBuilder.#padEdgeCases(
+                pcb.pads,
+                fileName
+            ),
+            ...UnsupportedFeatureReportBuilder.#arcEdgeCases(
+                pcb.arcs,
+                fileName
+            ),
+            ...UnsupportedFeatureReportBuilder.#regionEdgeCases(
+                pcb.regions,
+                fileName
+            ),
+            ...UnsupportedFeatureReportBuilder.#componentBodyEdgeCases(
+                pcb.componentBodies,
+                fileName
+            ),
+            ...UnsupportedFeatureReportBuilder.#embeddedModelIntegrityEdgeCases(
+                pcb.embeddedModelIntegrity?.issues,
+                fileName
+            )
+        ]
+    }
+
+    /**
+     * Collects pad compatibility rows.
+     * @param {object[] | undefined} pads Pads.
+     * @param {string} fileName Source file.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }[]}
+     */
+    static #padEdgeCases(pads, fileName) {
+        return (Array.isArray(pads) ? pads : []).flatMap((pad) => {
+            const rows = []
+
+            if (UnsupportedFeatureReportBuilder.#hasOctagonalPadShape(pad)) {
+                rows.push(
+                    UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                        code: 'pcb.pad.octagonal',
+                        feature: 'octagonal-pad',
+                        supportState: 'inspection-required',
+                        severity: 'warning',
+                        message:
+                            'Pad uses an octagonal shape that should be inspected in downstream views.',
+                        ...UnsupportedFeatureReportBuilder.#recordLocation(pad)
+                    })
+                )
+            }
+
+            if (Number(pad?.padMode) > 0) {
+                rows.push(
+                    UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                        code: 'pcb.pad.non-simple-stack',
+                        feature: 'non-simple-pad-stack',
+                        supportState: 'inspection-required',
+                        severity: 'warning',
+                        message:
+                            'Pad uses layer-specific pad-stack mode metadata.',
+                        ...UnsupportedFeatureReportBuilder.#recordLocation(pad)
+                    })
+                )
+            }
+
+            if (
+                UnsupportedFeatureReportBuilder.#hasLayerSpecificPadGeometry(
+                    pad
+                )
+            ) {
+                rows.push(
+                    UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                        code: 'pcb.pad.layer-specific-geometry',
+                        feature: 'layer-specific-pad-geometry',
+                        supportState: 'preserved',
+                        severity: 'info',
+                        message:
+                            'Pad has different top, middle, or bottom geometry.',
+                        ...UnsupportedFeatureReportBuilder.#recordLocation(pad)
+                    })
+                )
+            }
+
+            if (UnsupportedFeatureReportBuilder.#hasSlotHole(pad)) {
+                rows.push(
+                    UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                        code: 'pcb.pad.slot-hole',
+                        feature: 'slot-hole',
+                        supportState: 'preserved',
+                        severity: 'info',
+                        message: 'Pad uses slot-hole geometry.',
+                        ...UnsupportedFeatureReportBuilder.#recordLocation(pad)
+                    })
+                )
+            }
+
+            if (UnsupportedFeatureReportBuilder.#hasManualMaskPaste(pad)) {
+                rows.push(
+                    UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                        code: 'pcb.pad.manual-mask-paste',
+                        feature: 'manual-mask-paste-expansion',
+                        supportState: 'inspection-required',
+                        severity: 'warning',
+                        message:
+                            'Pad carries manual solder-mask or paste-mask expansion metadata.',
+                        ...UnsupportedFeatureReportBuilder.#recordLocation(pad)
+                    })
+                )
+            }
+
+            if (
+                UnsupportedFeatureReportBuilder.#hasMissingCustomShapeGeometry(
+                    pad
+                )
+            ) {
+                rows.push(
+                    UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                        code: 'pcb.custom-shape.missing-linked-geometry',
+                        feature: 'custom-pad-shape-linkage',
+                        supportState: 'inspection-required',
+                        severity: 'warning',
+                        message:
+                            'Custom pad shape sidecar has no linked primitive geometry.',
+                        ...UnsupportedFeatureReportBuilder.#recordLocation(pad)
+                    })
+                )
+            }
+
+            return rows
+        })
+    }
+
+    /**
+     * Collects arc compatibility rows.
+     * @param {object[] | undefined} arcs Arcs.
+     * @param {string} fileName Source file.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }[]}
+     */
+    static #arcEdgeCases(arcs, fileName) {
+        return (Array.isArray(arcs) ? arcs : [])
+            .filter((arc) => {
+                const radius = Math.abs(Number(arc?.radius))
+                const width = Math.abs(Number(arc?.width))
+                return Number.isFinite(radius) && radius > 0 && width >= radius
+            })
+            .map((arc) =>
+                UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                    code: 'pcb.arc.width-radius-conflict',
+                    feature: 'wide-arc',
+                    supportState: 'inspection-required',
+                    severity: 'warning',
+                    message:
+                        'Arc stroke width is greater than or equal to its radius.',
+                    ...UnsupportedFeatureReportBuilder.#recordLocation(arc)
+                })
+            )
+    }
+
+    /**
+     * Collects region compatibility rows.
+     * @param {object[] | undefined} regions Regions.
+     * @param {string} fileName Source file.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }[]}
+     */
+    static #regionEdgeCases(regions, fileName) {
+        return (Array.isArray(regions) ? regions : [])
+            .filter(
+                (region) =>
+                    Number(region?.holeCount || region?.HOLECOUNT || 0) > 0
+            )
+            .map((region) =>
+                UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                    code: 'pcb.region.holes',
+                    feature: 'region-with-holes',
+                    supportState: 'preserved',
+                    severity: 'info',
+                    message: 'Region contains one or more holes.',
+                    ...UnsupportedFeatureReportBuilder.#recordLocation(region)
+                })
+            )
+    }
+
+    /**
+     * Collects component-body compatibility rows.
+     * @param {object[] | undefined} componentBodies Component bodies.
+     * @param {string} fileName Source file.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }[]}
+     */
+    static #componentBodyEdgeCases(componentBodies, fileName) {
+        return (Array.isArray(componentBodies) ? componentBodies : [])
+            .filter((componentBody) =>
+                UnsupportedFeatureReportBuilder.#missingStaticBodyGeometry(
+                    componentBody
+                )
+            )
+            .map((componentBody) =>
+                UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                    code: 'pcb.model.shape-body-static-geometry-missing',
+                    feature: 'shape-based-3d-body',
+                    supportState: 'inspection-required',
+                    severity: 'warning',
+                    message:
+                        'Shape-based 3D body has no complete static geometry description.',
+                    ...UnsupportedFeatureReportBuilder.#recordLocation(
+                        componentBody
+                    )
+                })
+            )
+    }
+
+    /**
+     * Collects embedded-model integrity rows.
+     * @param {object[] | undefined} issues Integrity issues.
+     * @param {string} fileName Source file.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }[]}
+     */
+    static #embeddedModelIntegrityEdgeCases(issues, fileName) {
+        return (Array.isArray(issues) ? issues : []).map((issue) =>
+            UnsupportedFeatureReportBuilder.#pcbEdgeCase(fileName, {
+                code: issue.code,
+                feature: 'embedded-model-integrity',
+                supportState: 'diagnostic',
+                severity: issue.severity || 'warning',
+                message: issue.message,
+                ...UnsupportedFeatureReportBuilder.#recordLocation(issue)
+            })
+        )
+    }
+
+    /**
+     * Wraps one PCB edge-case row.
+     * @param {string} fileName Source file.
+     * @param {object} edgeCase Edge-case row.
+     * @returns {{ edgeCase: object, fileName: string, domain: string }}
+     */
+    static #pcbEdgeCase(fileName, edgeCase) {
+        return {
+            edgeCase,
+            fileName,
+            domain: 'pcb'
+        }
+    }
+
+    /**
+     * Extracts common record location fields.
+     * @param {object} row Source row.
+     * @returns {object}
+     */
+    static #recordLocation(row) {
+        return UnsupportedFeatureReportBuilder.#stripUndefined({
+            source: row?.source,
+            sourceStream: row?.sourceStream,
+            sourceStorage: row?.sourceStorage,
+            recordIndex: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                row?.recordIndex
+            ),
+            recordType: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                row?.recordType
+            )
+        })
+    }
+
+    /**
+     * Returns true when one pad uses an octagonal pad shape.
+     * @param {object} pad Pad row.
+     * @returns {boolean}
+     */
+    static #hasOctagonalPadShape(pad) {
+        const shapeNames = [
+            pad?.shapeTopName,
+            pad?.shapeMidName,
+            pad?.shapeBottomName,
+            pad?.padShapeNames?.top,
+            pad?.padShapeNames?.middle,
+            pad?.padShapeNames?.bottom
+        ].map((value) => String(value || '').toLowerCase())
+        const shapeCodes = [pad?.shapeTop, pad?.shapeMid, pad?.shapeBottom].map(
+            (value) => Number(value)
+        )
+
+        return (
+            shapeNames.includes('octagonal') || shapeCodes.includes(Number(3))
+        )
+    }
+
+    /**
+     * Returns true when top, middle, or bottom pad geometry differs.
+     * @param {object} pad Pad row.
+     * @returns {boolean}
+     */
+    static #hasLayerSpecificPadGeometry(pad) {
+        const sizes = [
+            [pad?.sizeTopX, pad?.sizeTopY],
+            [pad?.sizeMidX, pad?.sizeMidY],
+            [pad?.sizeBottomX, pad?.sizeBottomY]
+        ].map(([x, y]) => [Number(x), Number(y)])
+        const finiteSizes = sizes.filter(([x, y]) =>
+            [x, y].every(Number.isFinite)
+        )
+        const shapes = [pad?.shapeTop, pad?.shapeMid, pad?.shapeBottom]
+            .map((value) => Number(value))
+            .filter(Number.isFinite)
+
+        return (
+            UnsupportedFeatureReportBuilder.#hasDistinctPairs(finiteSizes) ||
+            new Set(shapes).size > 1
+        )
+    }
+
+    /**
+     * Returns true when an array of numeric pairs has more than one value.
+     * @param {number[][]} pairs Numeric pairs.
+     * @returns {boolean}
+     */
+    static #hasDistinctPairs(pairs) {
+        return new Set(pairs.map((pair) => pair.join(','))).size > 1
+    }
+
+    /**
+     * Returns true when one pad uses slot-hole geometry.
+     * @param {object} pad Pad row.
+     * @returns {boolean}
+     */
+    static #hasSlotHole(pad) {
+        return (
+            String(
+                pad?.holeShapeName || pad?.holeGeometry?.shapeName || ''
+            ).toLowerCase() === 'slot'
+        )
+    }
+
+    /**
+     * Returns true when one pad uses manual mask or paste expansion metadata.
+     * @param {object} pad Pad row.
+     * @returns {boolean}
+     */
+    static #hasManualMaskPaste(pad) {
+        const sources = [
+            pad?.pasteMaskExpansionSource,
+            pad?.solderMaskExpansionSource
+        ].map((value) => String(value || '').toLowerCase())
+        const modes = [
+            pad?.pasteMaskExpansionMode,
+            pad?.solderMaskExpansionMode
+        ].map((value) => Number(value))
+
+        return sources.includes('manual') || modes.includes(Number(2))
+    }
+
+    /**
+     * Returns true when custom-shape layers have no linked geometry.
+     * @param {object} pad Pad row.
+     * @returns {boolean}
+     */
+    static #hasMissingCustomShapeGeometry(pad) {
+        const layers = Array.isArray(pad?.customShape?.layers)
+            ? pad.customShape.layers
+            : []
+
+        return (
+            layers.length > 0 &&
+            layers.some(
+                (layer) =>
+                    !UnsupportedFeatureReportBuilder.#customShapeLayerHasGeometry(
+                        layer
+                    )
+            )
+        )
+    }
+
+    /**
+     * Returns true when a custom-shape layer links to any primitive geometry.
+     * @param {object} layer Custom shape layer.
+     * @returns {boolean}
+     */
+    static #customShapeLayerHasGeometry(layer) {
+        return ['regions', 'shapeRegions', 'arcs', 'tracks', 'fills'].some(
+            (key) => Array.isArray(layer?.[key]) && layer[key].length > 0
+        )
+    }
+
+    /**
+     * Returns true when a known shape body lacks complete static geometry.
+     * @param {object} componentBody Component body.
+     * @returns {boolean}
+     */
+    static #missingStaticBodyGeometry(componentBody) {
+        const typeName = String(componentBody?.modelTypeName || '')
+        const isShapeBody = [
+            'extruded-polygon',
+            'cone',
+            'cylinder',
+            'sphere'
+        ].includes(typeName)
+
+        if (!isShapeBody) {
+            return false
+        }
+
+        return componentBody?.staticGeometry?.status !== 'complete'
+    }
+
+    /**
+     * Removes repeated edge-case rows.
+     * @param {object[]} edgeCases Edge cases.
+     * @returns {object[]}
+     */
+    static #dedupeEdgeCases(edgeCases) {
+        const seen = new Set()
+        const deduped = []
+
+        for (const edgeCase of edgeCases) {
+            const row = edgeCase?.edgeCase || edgeCase || {}
+            const key = [
+                edgeCase?.fileName || row.fileName || '',
+                edgeCase?.domain || row.domain || '',
+                row.code || '',
+                row.sourceStream || '',
+                row.sourceStorage || '',
+                row.recordIndex ?? ''
+            ].join('\u0000')
+
+            if (seen.has(key)) {
+                continue
+            }
+
+            seen.add(key)
+            deduped.push(edgeCase)
+        }
+
+        return deduped
+    }
+
     /**
      * Returns true for unsupported-feature diagnostics.
      * @param {object} diagnostic Diagnostic row.
@@ -357,6 +864,19 @@ export class UnsupportedFeatureReportBuilder {
             .includes('unsupported')
     }
 
+    /**
+     * Returns true for diagnostics that describe parser edge-case coverage.
+     * @param {object} diagnostic Diagnostic row.
+     * @returns {boolean}
+     */
+    static #isEdgeCaseDiagnostic(diagnostic) {
+        if (!diagnostic || typeof diagnostic !== 'object') return false
+        if (diagnostic.errorKind === 'edge-case') return true
+        return String(diagnostic.code || '')
+            .toLowerCase()
+            .includes('edge-case')
+    }
+
     /**
      * Returns a finite number or undefined.
      * @param {unknown} value Candidate value.

package/src/parser.mjs

@@ -68,9 +68,11 @@ export { PcbComponentKindPolicy } from './core/altium/PcbComponentKindPolicy.mjs
 export { PcbComponentPrimitiveIndexer } from './core/altium/PcbComponentPrimitiveIndexer.mjs'
 export { PcbCustomPadShapeParser } from './core/altium/PcbCustomPadShapeParser.mjs'
 export { PcbDimensionParser } from './core/altium/PcbDimensionParser.mjs'
+export { PcbDimensionReportBuilder } from './core/altium/PcbDimensionReportBuilder.mjs'
 export { PcbEmbeddedFontExtractor } from './core/altium/PcbEmbeddedFontExtractor.mjs'
 export { PcbEmbeddedModelExtractor } from './core/altium/PcbEmbeddedModelExtractor.mjs'
 export { PcbExtendedPrimitiveInformationParser } from './core/altium/PcbExtendedPrimitiveInformationParser.mjs'
+export { PcbFabricationReadinessReportBuilder } from './core/altium/PcbFabricationReadinessReportBuilder.mjs'
 export { PcbFontMetricsParser } from './core/altium/PcbFontMetricsParser.mjs'
 export { PcbLayerIdCodec } from './core/altium/PcbLayerIdCodec.mjs'
 export { PcbLayerGroups } from './core/altium/PcbLayerGroups.mjs'
@@ -89,12 +91,15 @@ export { PcbPadStackParser } from './core/altium/PcbPadStackParser.mjs'
 export { PcbPlacedFootprintManifestBuilder } from './core/altium/PcbPlacedFootprintManifestBuilder.mjs'
 export { PcbPickPlacePositionResolver } from './core/altium/PcbPickPlacePositionResolver.mjs'
 export { PcbPolygonRecordParser } from './core/altium/PcbPolygonRecordParser.mjs'
+export { PcbPrimitiveFieldOffsetReportBuilder } from './core/altium/PcbPrimitiveFieldOffsetReportBuilder.mjs'
 export { PcbRawRecordRegistry } from './core/altium/PcbRawRecordRegistry.mjs'
 export { PcbReviewMetadataBuilder } from './core/altium/PcbReviewMetadataBuilder.mjs'
+export { PcbReviewPolygonRealizationBuilder } from './core/altium/PcbReviewPolygonRealizationBuilder.mjs'
 export { PcbClassReportBuilder } from './core/altium/PcbClassReportBuilder.mjs'
 export { PcbInspectionReportBuilder } from './core/altium/PcbInspectionReportBuilder.mjs'
 export { PcbNetMembershipReportBuilder } from './core/altium/PcbNetMembershipReportBuilder.mjs'
 export { PcbRouteAnalysisBuilder } from './core/altium/PcbRouteAnalysisBuilder.mjs'
+export { PcbRuleImpactReportBuilder } from './core/altium/PcbRuleImpactReportBuilder.mjs'
 export { PcbRuleParser } from './core/altium/PcbRuleParser.mjs'
 export { PcbSidecarRecordParser } from './core/altium/PcbSidecarRecordParser.mjs'
 export { PcbSpecialStringResolver } from './core/altium/PcbSpecialStringResolver.mjs'
@@ -113,8 +118,10 @@ export { SchLibStreamExtractor } from './core/altium/SchLibStreamExtractor.mjs'
 export { SchematicMultipartOwnerMatcher } from './core/altium/SchematicMultipartOwnerMatcher.mjs'
 export { SchematicCrossSheetConnectorParser } from './core/altium/SchematicCrossSheetConnectorParser.mjs'
 export { SchematicCodeSymbolParser } from './core/altium/SchematicCodeSymbolParser.mjs'
+export { SchematicConnectivityQaBuilder } from './core/altium/SchematicConnectivityQaBuilder.mjs'
 export { SchematicHarnessParser } from './core/altium/SchematicHarnessParser.mjs'
 export { SchematicImplementationParser } from './core/altium/SchematicImplementationParser.mjs'
+export { SchematicImageDiagnosticsBuilder } from './core/altium/SchematicImageDiagnosticsBuilder.mjs'
 export { SchematicOwnershipGraphParser } from './core/altium/SchematicOwnershipGraphParser.mjs'
 export { SchematicProjectParameterResolver } from './core/altium/SchematicProjectParameterResolver.mjs'
 export { SchematicQaReportBuilder } from './core/altium/SchematicQaReportBuilder.mjs'

package/src/styles/altium-renderers.css

@@ -142,6 +142,8 @@
     --pcb-via-hole-fill: #0f746c;
     --pcb-footprint-fill: rgba(247, 230, 117, 0.14);
     --pcb-footprint-track-color: rgba(237, 172, 36, 1);
+    --pcb-dimension-color: rgba(39, 88, 111, 0.78);
+    --pcb-dimension-text: #22343b;
     --pcb-text-knockout-fill: rgba(248, 246, 239, 0.96);
     --pcb-component-top-fill: rgba(244, 219, 198, 0.92);
     --pcb-component-bottom-fill: rgba(15, 116, 108, 0.84);
@@ -269,6 +271,40 @@
     stroke: var(--pcb-footprint-track-color);
 }
 
+.pcb-dimensions {
+    pointer-events: none;
+}
+
+.pcb-dimension__measure,
+.pcb-dimension__extension,
+.pcb-dimension__leader,
+.pcb-dimension__arc {
+    fill: none;
+    stroke: var(--pcb-dimension-color);
+    stroke-width: 5;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+.pcb-dimension__extension,
+.pcb-dimension__leader {
+    stroke-width: 3;
+    stroke-dasharray: 16 10;
+}
+
+.pcb-dimension__center {
+    fill: var(--pcb-dimension-color);
+}
+
+.pcb-dimension__label {
+    fill: var(--pcb-dimension-text);
+    font-family: Arial, sans-serif;
+    font-size: 30px;
+    font-weight: 700;
+    text-anchor: middle;
+    dominant-baseline: central;
+}
+
 .pcb-component__body {
     fill: var(--pcb-component-top-fill);
     stroke: var(--pcb-component-stroke);