smithkit 0.1.0 → 0.2.0

package/dist/lib/Smith.js

@@ -1,29 +1,32 @@
 import * as d3 from 'd3';
-import { MouseGesture } from './draw/MouseGesture.js';
-import { SmithSvg } from './draw/SmithSvg.js';
-import { SmithGroup } from './draw/SmithGroup.js';
-import { SmithCircle } from './draw/SmithCircle.js';
-import { SmithData } from './draw/SmithData.js';
-import { SmithCursor } from './draw/SmithCursor.js';
-import { ConstResistance } from './draw/ConstResistance.js';
-import { ConstReactance } from './draw/ConstReactance.js';
-import { ConstConductance } from './draw/ConstConductance.js';
-import { ConstSusceptance } from './draw/ConstSusceptance.js';
-import { ConstQCircles } from './draw/ConstQCircles.js';
-import { ConstSwrCircles } from './draw/ConstSwrCircles.js';
-import { SmithScaler } from './draw/SmithScaler.js';
-import { SmithConstantCircle } from './SmithConstantCircle.js';
-import { SmithArcsDefs } from './SmithArcsDefs.js';
-import { Complex } from './complex/Complex.js';
+import { MouseGesture } from './interaction/MouseGesture.js';
+import { SmithSvg } from './svg/SmithSvg.js';
+import { LabelLayout } from './svg/LabelLayout.js';
+import { SvgExporter } from './svg/SvgExporter.js';
+import { SmithGroup } from './svg/SmithGroup.js';
+import { SmithCircle } from './svg/SmithCircle.js';
+import { SmithData } from './traces/SmithData.js';
+import { SmithCursor } from './interaction/SmithCursor.js';
+import { ConstResistance } from './grid/ConstResistance.js';
+import { ConstReactance } from './grid/ConstReactance.js';
+import { ConstConductance } from './grid/ConstConductance.js';
+import { ConstSusceptance } from './grid/ConstSusceptance.js';
+import { ConstQCircles } from './grid/ConstQCircles.js';
+import { ConstSwrCircles } from './grid/ConstSwrCircles.js';
+import { SmithScaler } from './svg/SmithScaler.js';
+import { SmithConstantCircle } from './rf/SmithConstantCircle.js';
+import { GridDefinitions } from './grid/GridDefinitions.js';
+import { Complex } from './math/Complex.js';
 import { SmithPeripheralScales } from './scales/SmithPeripheralScales.js';
-import { gridLayer, circleLayer } from './layers.js';
-import { renormalizeSamples } from './renormalization.js';
-import { readReflection } from './rf.js';
-import { compareMarkerReadings } from './measurements.js';
+import { GridLayerControl } from './grid/GridLayerControl.js';
+import { CircleLayerControl } from './grid/CircleLayerControl.js';
+import { RfCalculations } from './rf/RfCalculations.js';
+import { MarkerMeasurements } from './MarkerMeasurements.js';
 export var SmithEventType;
 (function (SmithEventType) {
     SmithEventType["Cursor"] = "cursor";
     SmithEventType["Marker"] = "marker";
+    SmithEventType["MarkerSelect"] = "marker-select";
     SmithEventType["MarkerDragStart"] = "marker-drag-start";
     SmithEventType["MarkerDragEnd"] = "marker-drag-end";
 })(SmithEventType || (SmithEventType = {}));
@@ -31,12 +34,14 @@ export class Smith {
     referenceOhms;
     calcs = new SmithConstantCircle();
     scalers;
+    defaultTransform = d3.zoomIdentity.translate(62.5, 62.5).scale(0.75);
     transform = d3.zoomIdentity;
     zoomEnabled = true;
     applyingView = false;
     zoomBehavior = d3.zoom();
     svg;
     resizeObserver;
+    labelLayout;
     container;
     dataContainer;
     markerContainer;
@@ -68,7 +73,7 @@ export class Smith {
             throw new RangeError('Reference impedance must be positive and finite.');
         }
         const viewBoxSize = 500;
-        const gridData = SmithArcsDefs.getData();
+        const gridData = GridDefinitions.create();
         this.scalers = this.createScalers(viewBoxSize);
         this.svg = new SmithSvg(viewBoxSize);
         this.container = new SmithGroup();
@@ -122,15 +127,27 @@ export class Smith {
         this.container.append(this.reactanceAxis);
         this.container.append(cursorContainer);
         this.container.append(this.dataContainer);
+        const labels = new SmithGroup().attr('data-layer', 'labels').attr('pointer-events', 'none');
+        for (const [name, layer] of [
+            ['conductance', this.constConductance],
+            ['susceptance', this.constSusceptance],
+            ['resistance', this.constResistance],
+            ['reactance', this.constReactance],
+        ]) {
+            labels.append(layer.labels.attr('data-label-layer', name));
+        }
+        labels.append(this.peripheralScaleRenderer.labels);
+        this.container.append(labels);
         this.container.append(this.markerContainer);
+        this.labelLayout = new LabelLayout(this.svg.Node, labels.Node, this.defaultTransform);
         const assertAlive = () => this.assertAlive();
         this.layers = {
-            resistance: gridLayer(this.constResistance, assertAlive),
-            reactance: gridLayer(this.constReactance, assertAlive),
-            conductance: gridLayer(this.constConductance, assertAlive),
-            susceptance: gridLayer(this.constSusceptance, assertAlive),
-            q: circleLayer(this.constQCircles, 0, assertAlive),
-            vswr: circleLayer(this.constSwrCircles, 1, assertAlive),
+            resistance: new GridLayerControl(this.constResistance, assertAlive, () => this.labelLayout.update(true)),
+            reactance: new GridLayerControl(this.constReactance, assertAlive, () => this.labelLayout.update(true)),
+            conductance: new GridLayerControl(this.constConductance, assertAlive, () => this.labelLayout.update(true)),
+            susceptance: new GridLayerControl(this.constSusceptance, assertAlive, () => this.labelLayout.update(true)),
+            q: new CircleLayerControl(this.constQCircles, 0, assertAlive),
+            vswr: new CircleLayerControl(this.constSwrCircles, 1, assertAlive),
         };
         this.peripheralScales = {
             setVisible: (visible) => {
@@ -141,6 +158,7 @@ export class Smith {
                 else {
                     this.peripheralScaleRenderer.hide();
                 }
+                this.labelLayout.update(true);
             },
             update: (gamma) => {
                 assertAlive();
@@ -160,6 +178,11 @@ export class Smith {
         host.appendChild(this.svg.Node);
         this.updateViewportScale();
     }
+    /** Export the current mounted view as standalone SVG with a transparent background. */
+    toSvg() {
+        this.assertAlive();
+        return SvgExporter.chart(this.svg.Node);
+    }
     /** Remove this chart and release its event handlers. Safe to call more than once. */
     destroy() {
         if (this.destroyed) {
@@ -185,6 +208,7 @@ export class Smith {
             const scale = Math.hypot(matrix.a, matrix.b);
             this.data.forEach((trace) => trace.setViewportScale(scale));
         }
+        this.labelLayout.update();
     }
     assertAlive() {
         if (this.destroyed) {
@@ -241,19 +265,22 @@ export class Smith {
     }
     /** Last cursor position. Use cursor events to detect pointer leave. */
     get cursorReading() {
-        return readReflection(this.cursor.Position, this.referenceImpedanceOhms);
+        return RfCalculations.readReflection(this.cursor.Position, this.referenceImpedanceOhms);
     }
     initializeZoom() {
         const zoom = this.zoomBehavior
             .scaleExtent([0.6, 1000])
-            .filter((event) => this.zoomEnabled && (!event.ctrlKey || event.type === 'wheel') && !event.button)
+            .filter((event) => this.zoomEnabled &&
+            this.draggedMarkers.size === 0 &&
+            (!event.ctrlKey || event.type === 'wheel') &&
+            !event.button)
             .on('start', (event) => {
             if (event.sourceEvent) {
                 this.mouseGesture.capture(event.sourceEvent, 'zoom');
             }
         })
             .on('zoom', (event) => {
-            if (!this.zoomEnabled && !this.applyingView) {
+            if ((!this.zoomEnabled || this.draggedMarkers.size > 0) && !this.applyingView) {
                 // An already active mouse/touch gesture still needs its normal end event.
                 // Restore D3's view through its public API while that gesture finishes.
                 this.applyView(this.transform);
@@ -289,7 +316,7 @@ export class Smith {
     }
     resetView() {
         this.assertAlive();
-        const transform = d3.zoomIdentity.translate(62.5, 62.5).scale(0.75);
+        const transform = this.defaultTransform;
         this.applyView(transform);
     }
     onZoom(transform) {
@@ -400,6 +427,7 @@ export class Smith {
         data.setStyle(options);
         if (options.name !== undefined) {
             this.traceMetadata.get(data).name = options.name.trim();
+            data.setName(options.name.trim());
         }
         if (options.color !== undefined) {
             data.setColor(options.color);
@@ -448,6 +476,14 @@ export class Smith {
         const location = this.findMarker(id);
         return location ? this.data[location.datasetNo].removeMarker(location.markerNo) : false;
     }
+    /** Focus a mounted, visible marker for keyboard interaction. */
+    focusMarker(id) {
+        this.assertAlive();
+        const location = this.findMarker(id);
+        return location
+            ? this.data[location.datasetNo].Markers[location.markerNo].marker.focus()
+            : false;
+    }
     setMarkerSample(id, sampleIndex) {
         this.assertAlive();
         const location = this.findMarker(id);
@@ -471,7 +507,7 @@ export class Smith {
         const data = this.data[location.datasetNo];
         const marker = data.Markers[location.markerNo];
         return {
-            ...readReflection(Complex.from(...marker.selectedPoint.reflectionCoefficient), this.referenceImpedanceOhms),
+            ...RfCalculations.readReflection(Complex.from(...marker.selectedPoint.reflectionCoefficient), this.referenceImpedanceOhms),
             frequencyHz: marker.selectedPoint.frequencyHz,
             traceId: this.traceMetadata.get(data).id,
             markerId: id,
@@ -483,7 +519,7 @@ export class Smith {
     compareMarkers(a, b) {
         const first = this.getMarker(a);
         const second = this.getMarker(b);
-        return first && second ? compareMarkerReadings(first, second) : undefined;
+        return first && second ? MarkerMeasurements.compare(first, second) : undefined;
     }
     /** Current positive real reference impedance, in ohms. */
     get referenceImpedanceOhms() {
@@ -493,11 +529,11 @@ export class Smith {
     renormalize(referenceImpedanceOhms) {
         this.assertAlive();
         // Validate even with no traces, and prepare every result before changing any state.
-        renormalizeSamples([], this.referenceOhms, referenceImpedanceOhms);
+        RfCalculations.renormalizeSamples([], this.referenceOhms, referenceImpedanceOhms);
         if (referenceImpedanceOhms === this.referenceOhms) {
             return;
         }
-        const samples = this.data.map((data) => renormalizeSamples(data.Samples, this.referenceOhms, referenceImpedanceOhms));
+        const samples = this.data.map((data) => RfCalculations.renormalizeSamples(data.Samples, this.referenceOhms, referenceImpedanceOhms));
         this.data.forEach((data) => data.Markers.forEach((entry) => entry.marker.cancelDrag()));
         this.referenceOhms = referenceImpedanceOhms;
         this.data.forEach((data, index) => data.update(samples[index], 'sample-index'));
@@ -523,6 +559,13 @@ export class Smith {
         }, this.markerContainer, options);
         const number = this.nextTraceId++;
         this.traceMetadata.set(data, { id: `trace-${number}`, name: `Trace ${number}` });
+        data.setName(`Trace ${number}`);
+        data.setMarkerSelectHandler((marker) => {
+            const snapshot = this.getMarker(this.markerId(marker));
+            if (snapshot) {
+                this.emit({ type: SmithEventType.MarkerSelect, data: snapshot });
+            }
+        });
         data.setMarkerMoveHandler((index) => {
             const marker = data.Markers[index];
             const snapshot = marker && this.getMarker(this.markerId(marker.marker));

package/dist/lib/SmithFormatter.d.ts

@@ -0,0 +1,10 @@
+import type { Complex } from './math/Complex.js';
+export declare class SmithFormatter {
+    private constructor();
+    /** Format with three significant digits and an SI prefix; includes spacing before the unit. */
+    static number(value: number): string;
+    /** Format Cartesian components to decimalPlaces fractional digits. */
+    static complex(value: Complex, unit?: string, decimalPlaces?: number): string;
+    /** Format magnitude and phase in degrees to decimalPlaces fractional digits. */
+    static polar(value: Complex, unit?: string, decimalPlaces?: number): string;
+}

package/dist/lib/SmithFormatter.js

@@ -0,0 +1,19 @@
+import { format } from 'd3';
+export class SmithFormatter {
+    constructor() { }
+    /** Format with three significant digits and an SI prefix; includes spacing before the unit. */
+    static number(value) {
+        const formatted = format('.3~s')(value);
+        return Number.isFinite(value) && /[a-zA-Zµ]$/.test(formatted)
+            ? formatted.replace(/([a-zA-Zµ])$/, ' $1')
+            : formatted + ' ';
+    }
+    /** Format Cartesian components to decimalPlaces fractional digits. */
+    static complex(value, unit = '', decimalPlaces = 3) {
+        return `${value.toString(decimalPlaces)} ${unit === '' ? '' : `[${unit}]`}`;
+    }
+    /** Format magnitude and phase in degrees to decimalPlaces fractional digits. */
+    static polar(value, unit = '', decimalPlaces = 3) {
+        return `${value.abs().toFixed(decimalPlaces)} ${unit} ∠${((value.arg() * 180) / Math.PI).toFixed(decimalPlaces)}°`;
+    }
+}

package/dist/lib/grid/CircleLayerControl.d.ts

@@ -0,0 +1,15 @@
+import type { ConstQCircles } from './ConstQCircles.js';
+import type { ConstSwrCircles } from './ConstSwrCircles.js';
+import type { CircleLayer, CircleStyle } from '../layers.js';
+import { LayerControl } from './LayerControl.js';
+/** Exposes Q/VSWR circle controls without exposing the SVG renderer. */
+export declare class CircleLayerControl extends LayerControl implements CircleLayer {
+    private readonly layer;
+    private readonly minimum;
+    constructor(layer: ConstQCircles | ConstSwrCircles, minimum: number, assertAlive: () => void);
+    setVisible(visible: boolean): void;
+    setStyle(style: Partial<CircleStyle>): void;
+    addValue(value: number): void;
+    removeValue(value: number): void;
+    private validateValue;
+}

package/dist/lib/grid/CircleLayerControl.js

@@ -0,0 +1,40 @@
+import { LayerControl } from './LayerControl.js';
+/** Exposes Q/VSWR circle controls without exposing the SVG renderer. */
+export class CircleLayerControl extends LayerControl {
+    layer;
+    minimum;
+    constructor(layer, minimum, assertAlive) {
+        super(assertAlive);
+        this.layer = layer;
+        this.minimum = minimum;
+    }
+    setVisible(visible) {
+        this.assertAlive();
+        this.layer.visibility(visible);
+    }
+    setStyle(style) {
+        this.assertAlive();
+        this.validateLengths(style, ['strokeWidth']);
+        if (style.stroke !== undefined) {
+            this.layer.Stroke = style.stroke;
+        }
+        if (style.strokeWidth !== undefined) {
+            this.layer.StrokeWidth = String(style.strokeWidth);
+        }
+    }
+    addValue(value) {
+        this.assertAlive();
+        this.validateValue(value);
+        this.layer.append(value);
+    }
+    removeValue(value) {
+        this.assertAlive();
+        this.validateValue(value);
+        this.layer.remove(value);
+    }
+    validateValue(value) {
+        if (!Number.isFinite(value) || value < this.minimum || value <= 0) {
+            throw new RangeError(`Circle value must be finite, positive, and at least ${this.minimum}.`);
+        }
+    }
+}

package/dist/lib/{draw → grid}/ConstCircles.d.ts

@@ -1,10 +1,8 @@
 import type * as d3 from 'd3';
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
-import { Line } from '../shapes/Line.js';
-import { Circle } from '../shapes/Circle.js';
-import { Point } from '../shapes/Point.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
+import type { Line, Circle, Point } from '../math/geometry.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export interface ArcData {
     p1: Point;
     p2: Point;
@@ -41,6 +39,8 @@ export declare abstract class ConstCircles {
     showMinor(): void;
     hideMinor(): void;
     protected build(): SmithGroup;
+    /** Mount labels separately so every grid line is painted before any label. */
+    get labels(): SmithGroup;
     draw(): SmithGroup;
     setDrawOptions(opts: ConstCirclesDrawOptions): void;
     set Stroke(stroke: string);

package/dist/lib/{draw → grid}/ConstCircles.js

@@ -1,5 +1,5 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export class ConstCircles {
     scaler;
     calcs = new SmithConstantCircle();
@@ -12,17 +12,19 @@ export class ConstCircles {
     }
     visibility(visible) {
         if (visible) {
-            this.container.show();
+            this.show();
         }
         else {
-            this.container.hide();
+            this.hide();
         }
     }
     show() {
         this.container.show();
+        this.texts.show();
     }
     hide() {
         this.container.hide();
+        this.texts.hide();
     }
     displayMinor(display) {
         if (display) {
@@ -39,7 +41,12 @@ export class ConstCircles {
         this.minor.hide();
     }
     build() {
-        return this.container.append(this.minor).append(this.major).append(this.texts).hide();
+        this.texts.hide();
+        return this.container.append(this.minor).append(this.major).hide();
+    }
+    /** Mount labels separately so every grid line is painted before any label. */
+    get labels() {
+        return this.texts;
     }
     draw() {
         return this.container;

package/dist/lib/{draw → grid}/ConstQCircles.d.ts

@@ -1,5 +1,5 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
 interface ConstQDrawOptions {
     stroke: string;
     strokeWidth: string;

package/dist/lib/{draw → grid}/ConstQCircles.js

@@ -1,6 +1,6 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithArc } from './SmithArc.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithArc } from '../svg/SmithArc.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export class ConstQCircles {
     scaler;
     calcs = new SmithConstantCircle();

package/dist/lib/{draw → grid}/ConstSwrCircles.d.ts

@@ -1,5 +1,5 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
 interface ConstSwrDrawOptions {
     stroke: string;
     strokeWidth: string;

package/dist/lib/{draw → grid}/ConstSwrCircles.js

@@ -1,6 +1,6 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithCircle } from './SmithCircle.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithCircle } from '../svg/SmithCircle.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export class ConstSwrCircles {
     scaler;
     calcs = new SmithConstantCircle();

package/dist/lib/grid/GridDefinitions.d.ts

@@ -0,0 +1,12 @@
+import type { SmithTicksData } from './types.js';
+export declare class GridDefinitions {
+    private constructor();
+    private static readonly resistanceMajor;
+    private static readonly resistanceMinor;
+    private static readonly reactanceMajor;
+    private static readonly reactanceMinor;
+    private static resistanceArcs;
+    private static reactanceArcs;
+    /** Build fresh definitions so callers cannot mutate another chart's grid. */
+    static create(): SmithTicksData;
+}

package/dist/lib/grid/GridDefinitions.js

@@ -0,0 +1,138 @@
+export class GridDefinitions {
+    constructor() { }
+    static resistanceMajor = [
+        [[0.05, 0.15], 0.2, -0.2, false],
+        [[0.1, 0.3, 0.5, 0.7, 0.9], 2, -2, true],
+        [[0.2, 0.4, 0.6, 0.8, 1.2, 1.4, 1.6, 1.8], 5, -5, true],
+        [[1, 3, 5], 10, -10, true],
+        [[2, 4], 20, -20, true],
+        [[20], 50, -50, true],
+    ];
+    static resistanceMinor = [
+        [[0.02, 0.04, 0.06, 0.08, 0.12, 0.14, 0.16, 0.18], 0.2, 0.5, false],
+        [[0.02, 0.04, 0.06, 0.08, 0.12, 0.14, 0.16, 0.18], -0.2, -0.5, false],
+        [[0.05, 0.15, 0.25, 0.35, 0.45], 0.5, 1, false],
+        [[0.05, 0.15, 0.25, 0.35, 0.45], -0.5, -1, false],
+        [
+            [
+                0.01, 0.02, 0.03, 0.04, 0.06, 0.07, 0.08, 0.09, 0.11, 0.12, 0.13, 0.14, 0.16, 0.17, 0.18,
+                0.19,
+            ],
+            0.2,
+            -0.2,
+            false,
+        ],
+        [[0.22, 0.24, 0.26, 0.28, 0.32, 0.34, 0.36, 0.38, 0.42, 0.44, 0.46, 0.48], 0.5, -0.5, false],
+        [[0.55, 0.65, 0.75, 0.85, 0.95], 2, -2, true],
+        [[1.1, 1.3, 1.5, 1.7, 1.9], 2, -2, false],
+        [[2.2, 2.4, 2.6, 2.8, 3.2, 3.4, 3.6, 3.8], 5, -5, true],
+        [[4.2, 4.4, 4.6, 4.8], 5, -5, false],
+        [[6, 8, 12, 14, 16, 18], 20, -20, true],
+        [[7, 9], 10, -10, true],
+        [[30, 40], 50, -50, true],
+    ];
+    static reactanceMajor = [
+        [[0.05, 0.15], 0.2, 0],
+        [[0.1, 0.3, 0.5, 0.7, 0.9], 2, 0],
+        [[0.2, 0.4, 0.6, 0.8, 1.2, 1.4, 1.6, 1.8], 5, 0],
+        [[1, 3, 5], 10, 0],
+        [[2, 4, 10], 20, 0],
+        [[20], 50, 0],
+    ];
+    static reactanceMinor = [
+        [
+            [
+                0.01, 0.02, 0.03, 0.04, 0.06, 0.07, 0.08, 0.09, 0.11, 0.12, 0.13, 0.14, 0.16, 0.17, 0.18,
+                0.19,
+            ],
+            0.2,
+            0,
+        ],
+        [[0.02, 0.04, 0.06, 0.08, 0.12, 0.14, 0.16, 0.18], 0.5, 0.2],
+        [[0.22, 0.24, 0.26, 0.28, 0.32, 0.34, 0.36, 0.38, 0.42, 0.44, 0.46, 0.48], 0.5, 0],
+        [[0.05, 0.15, 0.25, 0.35, 0.45], 1, 0.5],
+        [[0.55, 0.65, 0.75, 0.85, 0.95], 1, 0],
+        [[1.1, 1.3, 1.5, 1.7, 1.9], 2, 0],
+        [[2.2, 2.4, 2.6, 2.8, 3.2, 3.4, 3.6, 3.8, 4.2, 4.4, 4.6, 4.8], 5, 0],
+        [[6, 8, 14, 16, 18], 20, 0],
+        [[7, 9], 10, 0],
+        [[12, 30, 40], 50, 0],
+    ];
+    static resistanceArcs(bands) {
+        return bands.flatMap(([values, from, to, largeArc]) => values.map((value) => [
+            value,
+            [
+                [from, from < 0 ? 1 : 0],
+                [to, to < 0 ? 1 : 0],
+            ],
+            [largeArc, from > to],
+        ]));
+    }
+    static reactanceArcs(bands) {
+        return bands.flatMap(([values, outer, inner]) => values.flatMap((value) => [
+            [
+                value,
+                [
+                    [outer, 1],
+                    [inner, 1],
+                ],
+                [false, false],
+            ],
+            [
+                -value,
+                [
+                    [outer, 0],
+                    [inner, 0],
+                ],
+                [false, true],
+            ],
+        ]));
+    }
+    /** Build fresh definitions so callers cannot mutate another chart's grid. */
+    static create() {
+        return {
+            resistance: {
+                major: {
+                    lines: [],
+                    circles: [10, 50],
+                    arcs: GridDefinitions.resistanceArcs(GridDefinitions.resistanceMajor),
+                },
+                minor: {
+                    lines: [],
+                    circles: [],
+                    arcs: GridDefinitions.resistanceArcs(GridDefinitions.resistanceMinor),
+                },
+            },
+            reactance: {
+                major: {
+                    lines: [{ p1: [-1, 0], p2: [1, 0] }],
+                    circles: [],
+                    arcs: [
+                        ...GridDefinitions.reactanceArcs(GridDefinitions.reactanceMajor),
+                        [
+                            50,
+                            [
+                                [0, 0],
+                                [0, 1],
+                            ],
+                            [false, false],
+                        ],
+                        [
+                            -50,
+                            [
+                                [0, 1],
+                                [0, 0],
+                            ],
+                            [false, true],
+                        ],
+                    ],
+                },
+                minor: {
+                    lines: [],
+                    circles: [],
+                    arcs: GridDefinitions.reactanceArcs(GridDefinitions.reactanceMinor),
+                },
+            },
+        };
+    }
+}

package/dist/lib/grid/GridGeometry.d.ts

@@ -0,0 +1,26 @@
+import type { TickDefRequired } from './Tick.js';
+import type { SmithTicksShapes } from './types.js';
+import type { Point } from '../math/geometry.js';
+export type GridKind = 'resistance' | 'reactance' | 'conductance' | 'susceptance';
+export type GridArc = [Point, Point, number, boolean, boolean];
+export declare class GridGeometry {
+    private constructor();
+    private static readonly calcs;
+    private static readonly circles;
+    private static readonly clipping;
+    /** Normalized geometry only: no DOM, D3, or pixel coordinates. */
+    static shapes(kind: GridKind, data: SmithTicksShapes): {
+        lines: import("../math/geometry.js").Line[];
+        circles: import("../math/geometry.js").Circle[];
+        arcs: GridArc[];
+    };
+    static label(kind: GridKind, definition: TickDefRequired): {
+        point: [number, number];
+        text: string;
+        rotate: number;
+        dx: number;
+        dy: number;
+        textAnchor: string;
+        dominantBaseline: string;
+    };
+}