smithkit 0.3.0 → 0.5.0

package/dist/lib/OptionsValidation.js

@@ -0,0 +1,172 @@
+import { Theme } from './appearance/Theme.js';
+/** Shared validation for initial configuration, patches, and individual controls. */
+export class OptionsValidation {
+    constructor() { }
+    static object(value, name, keys) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new TypeError(`${name} must be an object.`);
+        }
+        if (keys) {
+            for (const key of Object.keys(value)) {
+                if (!keys.includes(key)) {
+                    throw new TypeError(`Unknown ${name} option: ${key}.`);
+                }
+            }
+        }
+    }
+    static boolean(value, name) {
+        if (typeof value !== 'boolean') {
+            throw new TypeError(`${name} must be a boolean.`);
+        }
+    }
+    static detail(value) {
+        if (!['basic', 'standard', 'detailed'].includes(value)) {
+            throw new RangeError('Grid detail must be basic, standard, or detailed.');
+        }
+    }
+    static lengths(style, keys) {
+        for (const key of keys) {
+            const value = style[key];
+            if (value !== undefined &&
+                (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
+                throw new RangeError(`${String(key)} must be a positive finite number.`);
+            }
+        }
+    }
+    static strings(style, keys) {
+        for (const key of keys) {
+            if (style[key] !== undefined && typeof style[key] !== 'string') {
+                throw new TypeError(`${String(key)} must be a CSS string.`);
+            }
+        }
+    }
+    static gridStyle(style) {
+        OptionsValidation.object(style, 'Grid style', [
+            'stroke',
+            'majorWidth',
+            'minorWidth',
+            'textColor',
+            'textFontFamily',
+            'textFontSize',
+        ]);
+        OptionsValidation.lengths(style, ['majorWidth', 'minorWidth', 'textFontSize']);
+        OptionsValidation.strings(style, ['stroke', 'textColor', 'textFontFamily']);
+    }
+    static circleStyle(style) {
+        OptionsValidation.object(style, 'Circle style', ['stroke', 'strokeWidth']);
+        OptionsValidation.lengths(style, ['strokeWidth']);
+        OptionsValidation.strings(style, ['stroke']);
+    }
+    static circleValue(value, minimum) {
+        if (!Number.isFinite(value) || value < minimum || value <= 0) {
+            throw new RangeError(`Circle value must be finite, positive, and at least ${minimum}.`);
+        }
+    }
+    static circleValues(values, minimum) {
+        if (!Array.isArray(values)) {
+            throw new TypeError('Circle values must be an array.');
+        }
+        for (const value of values) {
+            OptionsValidation.circleValue(value, minimum);
+        }
+    }
+    static chart(options) {
+        OptionsValidation.object(options, 'Smith options', [
+            'referenceImpedanceOhms',
+            'appearance',
+            'interaction',
+            'grid',
+            'circles',
+            'peripheralScales',
+        ]);
+        if (options.referenceImpedanceOhms !== undefined &&
+            (!Number.isFinite(options.referenceImpedanceOhms) || options.referenceImpedanceOhms <= 0)) {
+            throw new RangeError('Reference impedance must be positive and finite.');
+        }
+        if (options.appearance !== undefined) {
+            Theme.resolve(options.appearance);
+        }
+        if (options.interaction !== undefined) {
+            OptionsValidation.object(options.interaction, 'Interaction', ['zoom', 'cursor']);
+            for (const name of ['zoom', 'cursor']) {
+                const value = options.interaction[name];
+                if (value !== undefined) {
+                    OptionsValidation.boolean(value, name);
+                }
+            }
+        }
+        if (options.peripheralScales !== undefined) {
+            const keys = ['visible', 'captionsVisible', 'tickLabelsVisible'];
+            OptionsValidation.object(options.peripheralScales, 'Peripheral scales', keys);
+            for (const key of keys) {
+                const value = options.peripheralScales[key];
+                if (value !== undefined) {
+                    OptionsValidation.boolean(value, `Peripheral scales ${key}`);
+                }
+            }
+        }
+        if (options.grid !== undefined) {
+            OptionsValidation.object(options.grid, 'Grid', [
+                'detail',
+                'labelsVisible',
+                'style',
+                'layers',
+            ]);
+            if (options.grid.layers !== undefined) {
+                OptionsValidation.object(options.grid.layers, 'Grid layers', [
+                    'resistance',
+                    'reactance',
+                    'conductance',
+                    'susceptance',
+                ]);
+            }
+            for (const name of ['resistance', 'reactance', 'conductance', 'susceptance']) {
+                const layer = options.grid.layers?.[name];
+                if (layer !== undefined) {
+                    OptionsValidation.object(layer, 'Grid layer', [
+                        'detail',
+                        'labelsVisible',
+                        'style',
+                        'visible',
+                    ]);
+                    if (layer.visible !== undefined) {
+                        OptionsValidation.boolean(layer.visible, 'Grid visibility');
+                    }
+                }
+            }
+            for (const grid of [options.grid, ...Object.values(options.grid.layers ?? {})]) {
+                if (grid === undefined) {
+                    continue;
+                }
+                if (grid.detail !== undefined) {
+                    OptionsValidation.detail(grid.detail);
+                }
+                if (grid.labelsVisible !== undefined) {
+                    OptionsValidation.boolean(grid.labelsVisible, 'Grid labels visibility');
+                }
+                if (grid.style !== undefined) {
+                    OptionsValidation.gridStyle(grid.style);
+                }
+            }
+        }
+        if (options.circles !== undefined) {
+            OptionsValidation.object(options.circles, 'Circles', ['q', 'vswr']);
+            for (const name of ['q', 'vswr']) {
+                const circle = options.circles[name];
+                if (circle === undefined) {
+                    continue;
+                }
+                OptionsValidation.object(circle, 'Circle', ['visible', 'values', 'style']);
+                if (circle.visible !== undefined) {
+                    OptionsValidation.boolean(circle.visible, 'Circle visibility');
+                }
+                if (circle.style !== undefined) {
+                    OptionsValidation.circleStyle(circle.style);
+                }
+                if (circle.values !== undefined) {
+                    OptionsValidation.circleValues(circle.values, name === 'vswr' ? 1 : 0);
+                }
+            }
+        }
+    }
+}

package/dist/lib/Smith.d.ts

@@ -1,7 +1,8 @@
+import type { SmithOptions } from './options.js';
 import type { SmithImageExportOptions } from './svg/export.js';
 import type { SmithAppearance } from './appearance/types.js';
-import type { TraceSamples } from './samples.js';
-import type { ChartLayers, PeripheralScales } from './layers.js';
+import type { TraceInput, TraceSamples, TraceTuple } from './samples.js';
+import type { ChartLayers, GridDetail, PeripheralScales } from './layers.js';
 import type { SmithReading } from './rf/RfCalculations.js';
 import type { TraceOptions, TraceUpdateOptions, TraceInfo, MarkerSnapshot, MarkerComparison } from './measurements.js';
 export declare enum SmithEventType {
@@ -19,8 +20,8 @@ export type SmithEvent = {
     data: MarkerSnapshot;
 };
 export declare class Smith {
-    private referenceOhms;
     private theme;
+    private referenceOhms;
     private readonly renderer;
     private data;
     private destroyed;
@@ -33,12 +34,18 @@ export declare class Smith {
     private listeners;
     readonly layers: ChartLayers;
     readonly peripheralScales: PeripheralScales;
-    constructor(referenceOhms?: number, appearance?: SmithAppearance);
+    constructor(options?: SmithOptions);
+    /** Apply a validated patch. Omitted fields retain their current settings. */
+    setOptions(options: SmithOptions): void;
+    private applyOptions;
     /** Replace the appearance while retaining explicit layer styles and trace colors. */
     setAppearance(appearance: SmithAppearance): void;
     draw(target: string | HTMLElement): void;
+    /** Set the same detail level on all impedance and admittance grid layers. */
+    setGridDetail(detail: GridDetail): void;
     /** Export the current mounted view as standalone SVG with its configured background. */
     toSvg(options?: SmithImageExportOptions): string;
+    private validateExportOptions;
     private exportLegend;
     /** Export the mounted view as PNG, optionally with radial scales and a trace legend. */
     toPng(options?: SmithImageExportOptions): Promise<Blob>;
@@ -50,9 +57,14 @@ export declare class Smith {
     get cursorReading(): SmithReading;
     /** Enable or disable wheel, double-click, and mouse/touch zoom/pan. Keeps the current view. */
     setZoomEnabled(enabled: boolean): void;
+    /** Enable or disable the cursor overlay and readings independently of zoom and markers. */
+    setCursorEnabled(enabled: boolean): void;
     resetView(): void;
-    /** Add a named trace with one initial marker. Returns a chart-local, stable ID. */
+    /** Add a named trace without markers. Use addMarker to create markers explicitly. Returns a chart-local, stable ID. */
     addTrace(values: TraceSamples, options?: TraceOptions): string;
+    addTrace(values: readonly TraceTuple[], options?: TraceOptions): string;
+    addTrace(values: Float64Array, options?: TraceOptions): string;
+    addTrace(values: TraceInput, options?: TraceOptions): string;
     /** Detached metadata snapshots; IDs and marker display numbers survive removals. */
     getTraces(): TraceInfo[];
     private traceIndex;
@@ -62,6 +74,9 @@ export declare class Smith {
     setTraceOptions(id: string, options: TraceOptions): boolean;
     /** Replace samples; by default each marker follows its nearest measured frequency. */
     updateTrace(id: string, values: TraceSamples, options?: TraceUpdateOptions): boolean;
+    updateTrace(id: string, values: readonly TraceTuple[], options?: TraceUpdateOptions): boolean;
+    updateTrace(id: string, values: Float64Array, options?: TraceUpdateOptions): boolean;
+    updateTrace(id: string, values: TraceInput, options?: TraceUpdateOptions): boolean;
     removeTrace(id: string): boolean;
     /** Place a marker on an existing sample; no interpolation is performed. */
     addMarker(traceId: string, sampleIndex?: number): string | undefined;

package/dist/lib/Smith.js

@@ -1,3 +1,4 @@
+import { OptionsValidation } from './OptionsValidation.js';
 import { MarkerLegend } from './svg/MarkerLegend.js';
 import { ImageExporter } from './svg/ImageExporter.js';
 import { Theme } from './appearance/Theme.js';
@@ -15,8 +16,8 @@ export var SmithEventType;
     SmithEventType["MarkerDragEnd"] = "marker-drag-end";
 })(SmithEventType || (SmithEventType = {}));
 export class Smith {
-    referenceOhms;
     theme;
+    referenceOhms;
     renderer;
     data = [];
     destroyed = false;
@@ -29,12 +30,14 @@ export class Smith {
     listeners = new Set();
     layers;
     peripheralScales;
-    constructor(referenceOhms = 50, appearance = {}) {
-        this.referenceOhms = referenceOhms;
-        if (!Number.isFinite(referenceOhms) || referenceOhms <= 0) {
+    constructor(options = {}) {
+        OptionsValidation.chart(options);
+        this.referenceOhms =
+            options.referenceImpedanceOhms === undefined ? 50 : options.referenceImpedanceOhms;
+        if (!Number.isFinite(this.referenceOhms) || this.referenceOhms <= 0) {
             throw new RangeError('Reference impedance must be positive and finite.');
         }
-        this.theme = Theme.resolve(appearance);
+        this.theme = Theme.resolve(options.appearance);
         this.renderer = new SvgChartRenderer((position) => {
             this.emit({
                 type: SmithEventType.Cursor,
@@ -44,6 +47,82 @@ export class Smith {
         this.renderer.setTheme(this.theme);
         this.layers = this.renderer.layers;
         this.peripheralScales = this.renderer.peripheralScales;
+        try {
+            this.applyOptions(options);
+        }
+        catch (error) {
+            // Invalid constructor options must not retain observers or event handlers.
+            this.renderer.destroy();
+            throw error;
+        }
+    }
+    /** Apply a validated patch. Omitted fields retain their current settings. */
+    setOptions(options) {
+        this.assertAlive();
+        OptionsValidation.chart(options);
+        // Renormalization can reject otherwise valid options for the loaded samples.
+        // Do it before presentation changes so rejection preserves the entire chart.
+        if (options.referenceImpedanceOhms !== undefined) {
+            this.renormalize(options.referenceImpedanceOhms);
+        }
+        if (options.appearance !== undefined) {
+            this.setAppearance(options.appearance);
+        }
+        this.applyOptions(options);
+    }
+    applyOptions(options) {
+        if (options.interaction?.zoom !== undefined) {
+            this.setZoomEnabled(options.interaction.zoom);
+        }
+        if (options.interaction?.cursor !== undefined) {
+            this.setCursorEnabled(options.interaction.cursor);
+        }
+        if (options.peripheralScales?.visible !== undefined) {
+            this.peripheralScales.setVisible(options.peripheralScales.visible);
+        }
+        if (options.peripheralScales?.captionsVisible !== undefined) {
+            this.peripheralScales.setCaptionsVisible(options.peripheralScales.captionsVisible);
+        }
+        if (options.peripheralScales?.tickLabelsVisible !== undefined) {
+            this.peripheralScales.setTickLabelsVisible(options.peripheralScales.tickLabelsVisible);
+        }
+        for (const name of ['resistance', 'reactance', 'conductance', 'susceptance']) {
+            const layer = this.layers[name];
+            for (const settings of [options.grid, options.grid?.layers?.[name]]) {
+                if (settings === undefined) {
+                    continue;
+                }
+                if (settings.detail !== undefined) {
+                    layer.setDetail(settings.detail);
+                }
+                if (settings.labelsVisible !== undefined) {
+                    layer.setLabelsVisible(settings.labelsVisible);
+                }
+                if (settings.style !== undefined) {
+                    layer.setStyle(settings.style);
+                }
+            }
+            const visible = options.grid?.layers?.[name]?.visible;
+            if (visible !== undefined) {
+                layer.setVisible(visible);
+            }
+        }
+        for (const name of ['q', 'vswr']) {
+            const settings = options.circles?.[name];
+            if (settings === undefined) {
+                continue;
+            }
+            const layer = this.layers[name];
+            if (settings.values !== undefined) {
+                layer.setValues(settings.values);
+            }
+            if (settings.style !== undefined) {
+                layer.setStyle(settings.style);
+            }
+            if (settings.visible !== undefined) {
+                layer.setVisible(settings.visible);
+            }
+        }
     }
     /** Replace the appearance while retaining explicit layer styles and trace colors. */
     setAppearance(appearance) {
@@ -62,10 +141,18 @@ export class Smith {
         this.assertAlive();
         this.renderer.draw(target);
     }
+    /** Set the same detail level on all impedance and admittance grid layers. */
+    setGridDetail(detail) {
+        this.assertAlive();
+        for (const name of ['resistance', 'reactance', 'conductance', 'susceptance']) {
+            this.layers[name].setDetail(detail);
+        }
+    }
     /** Export the current mounted view as standalone SVG with its configured background. */
     toSvg(options) {
         this.assertAlive();
-        const source = this.renderer.toSvg();
+        this.validateExportOptions(options);
+        const source = this.renderer.toSvg(options?.lineDetail ?? 'full');
         if (options === undefined) {
             return source;
         }
@@ -75,6 +162,14 @@ export class Smith {
         }
         return ImageExporter.svg(sources, options, this.exportLegend(options));
     }
+    validateExportOptions(options) {
+        if (options?.lineDetail !== undefined && !['full', 'view'].includes(options.lineDetail)) {
+            throw new TypeError('Export line detail must be full or view.');
+        }
+        if (options?.scaleReadout !== undefined && !options.scales) {
+            throw new TypeError('Scale readout requires included radial scales.');
+        }
+    }
     exportLegend(options) {
         const traces = this.getTraces();
         return {
@@ -90,7 +185,9 @@ export class Smith {
     }
     /** Export the mounted view as PNG, optionally with radial scales and a trace legend. */
     async toPng(options = {}) {
-        const sources = [this.toSvg()];
+        this.assertAlive();
+        this.validateExportOptions(options);
+        const sources = [this.renderer.toSvg(options.lineDetail ?? 'full')];
         if (options.scales) {
             sources.push(options.scales.toSvg({ readout: options.scaleReadout }));
         }
@@ -124,9 +221,6 @@ export class Smith {
             return;
         }
         this.renderer.setMarkerDragging(isDragging);
-        if (isDragging) {
-            this.emit({ type: SmithEventType.Cursor, data: undefined });
-        }
     }
     /** Last cursor position. Use cursor events to detect pointer leave. */
     get cursorReading() {
@@ -137,11 +231,15 @@ export class Smith {
         this.assertAlive();
         this.renderer.setZoomEnabled(enabled);
     }
+    /** Enable or disable the cursor overlay and readings independently of zoom and markers. */
+    setCursorEnabled(enabled) {
+        this.assertAlive();
+        this.renderer.setCursorEnabled(enabled);
+    }
     resetView() {
         this.assertAlive();
         this.renderer.resetView();
     }
-    /** Add a named trace with one initial marker. Returns a chart-local, stable ID. */
     addTrace(values, options = {}) {
         this.assertAlive();
         this.validateTraceOptions(options);
@@ -195,6 +293,10 @@ export class Smith {
         if (options.mode !== undefined && !['points', 'line', 'both'].includes(options.mode)) {
             throw new TypeError('Trace mode must be points, line, or both.');
         }
+        if (options.lineTolerancePx !== undefined &&
+            (!Number.isFinite(options.lineTolerancePx) || options.lineTolerancePx < 0)) {
+            throw new RangeError('Line tolerance must be finite and non-negative.');
+        }
         for (const key of ['lineWidth', 'pointRadius']) {
             const value = options[key];
             if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
@@ -233,7 +335,6 @@ export class Smith {
         }
         return true;
     }
-    /** Replace samples; by default each marker follows its nearest measured frequency. */
     updateTrace(id, values, options = {}) {
         this.assertAlive();
         const data = this.data[this.traceIndex(id)];
@@ -329,12 +430,11 @@ export class Smith {
         if (referenceImpedanceOhms === this.referenceOhms) {
             return;
         }
-        const samples = this.data.map((data) => RfCalculations.renormalizeSamples(data.Samples, this.referenceOhms, referenceImpedanceOhms));
+        const samples = this.data.map((data) => data.Samples.renormalize(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'));
         this.renderer.hideCursor();
-        this.emit({ type: SmithEventType.Cursor, data: undefined });
     }
     clearTraces() {
         this.assertAlive();
@@ -373,7 +473,6 @@ export class Smith {
                 this.emit({ type: SmithEventType.Marker, data: snapshot });
             }
         });
-        data.addMarker();
         return data;
     }
     /** Subscribe to chart events. The returned function removes this subscription. */

package/dist/lib/appearance/Theme.js

@@ -6,6 +6,11 @@ export class Theme {
         if (!appearance || typeof appearance !== 'object' || Array.isArray(appearance)) {
             throw new TypeError('Appearance must be an object.');
         }
+        for (const key of Object.keys(appearance)) {
+            if (key !== 'theme' && key !== 'overrides') {
+                throw new TypeError(`Unknown appearance option: ${key}.`);
+            }
+        }
         const name = appearance.theme === undefined ? 'light' : appearance.theme;
         if (name !== 'light' && name !== 'dark') {
             throw new TypeError('Theme must be light or dark.');

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

@@ -9,7 +9,7 @@ export declare class CircleLayerControl extends LayerControl implements CircleLa
     constructor(layer: ConstQCircles | ConstSwrCircles, minimum: number, assertAlive: () => void);
     setVisible(visible: boolean): void;
     setStyle(style: Partial<CircleStyle>): void;
+    setValues(values: readonly number[]): void;
     addValue(value: number): void;
     removeValue(value: number): void;
-    private validateValue;
 }

package/dist/lib/grid/CircleLayerControl.js

@@ -1,3 +1,4 @@
+import { OptionsValidation } from '../OptionsValidation.js';
 import { LayerControl } from './LayerControl.js';
 /** Exposes Q/VSWR circle controls without exposing the SVG renderer. */
 export class CircleLayerControl extends LayerControl {
@@ -10,11 +11,12 @@ export class CircleLayerControl extends LayerControl {
     }
     setVisible(visible) {
         this.assertAlive();
+        OptionsValidation.boolean(visible, 'Circle visibility');
         this.layer.visibility(visible);
     }
     setStyle(style) {
         this.assertAlive();
-        this.validateLengths(style, ['strokeWidth']);
+        OptionsValidation.circleStyle(style);
         if (style.stroke !== undefined) {
             this.layer.Stroke = style.stroke;
         }
@@ -22,19 +24,19 @@ export class CircleLayerControl extends LayerControl {
             this.layer.StrokeWidth = String(style.strokeWidth);
         }
     }
+    setValues(values) {
+        this.assertAlive();
+        OptionsValidation.circleValues(values, this.minimum);
+        this.layer.setValues(values);
+    }
     addValue(value) {
         this.assertAlive();
-        this.validateValue(value);
+        OptionsValidation.circleValue(value, this.minimum);
         this.layer.append(value);
     }
     removeValue(value) {
         this.assertAlive();
-        this.validateValue(value);
+        OptionsValidation.circleValue(value, this.minimum);
         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/grid/ConstQCircles.d.ts

@@ -24,6 +24,7 @@ export declare class ConstQCircles {
     show(): void;
     hide(): void;
     append(Q: number): void;
+    setValues(values: readonly number[]): void;
     remove(Q: number): void;
 }
 export {};

package/dist/lib/grid/ConstQCircles.js

@@ -74,6 +74,11 @@ export class ConstQCircles {
         this.circles.push(Q);
         this.drawConstQCircle(Q);
     }
+    setValues(values) {
+        this.circles = [...new Set(values)];
+        this.container.Element.selectAll('*').remove();
+        this.drawConstQCircles(this.circles);
+    }
     remove(Q) {
         const index = this.circles.indexOf(Q);
         if (index === -1) {

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

@@ -24,6 +24,7 @@ export declare class ConstSwrCircles {
     show(): void;
     hide(): void;
     append(swr: number): void;
+    setValues(values: readonly number[]): void;
     remove(swr: number): void;
 }
 export {};

package/dist/lib/grid/ConstSwrCircles.js

@@ -73,6 +73,11 @@ export class ConstSwrCircles {
         this.circles.push(swr);
         this.drawConstSwrCircle(swr);
     }
+    setValues(values) {
+        this.circles = [...new Set(values)];
+        this.container.Element.selectAll('*').remove();
+        this.drawConstSwrCircles(this.circles);
+    }
     remove(swr) {
         const index = this.circles.indexOf(swr);
         if (index === -1) {

package/dist/lib/grid/GridLayerControl.js

@@ -1,3 +1,4 @@
+import { OptionsValidation } from '../OptionsValidation.js';
 import { LayerControl } from './LayerControl.js';
 /** Exposes grid controls without exposing the SVG renderer. */
 export class GridLayerControl extends LayerControl {
@@ -10,25 +11,25 @@ export class GridLayerControl extends LayerControl {
     }
     setVisible(visible) {
         this.assertAlive();
+        OptionsValidation.boolean(visible, 'Grid visibility');
         this.layer.visibility(visible);
         this.changed();
     }
     setLabelsVisible(visible) {
         this.assertAlive();
+        OptionsValidation.boolean(visible, 'Grid visibility');
         this.layer.setLabelsVisible(visible);
         this.changed();
     }
     setDetail(detail) {
         this.assertAlive();
-        if (!['basic', 'standard', 'detailed'].includes(detail)) {
-            throw new RangeError('Grid detail must be basic, standard, or detailed.');
-        }
+        OptionsValidation.detail(detail);
         this.layer.setDetail(detail);
         this.changed();
     }
     setStyle(style) {
         this.assertAlive();
-        this.validateLengths(style, ['majorWidth', 'minorWidth', 'textFontSize']);
+        OptionsValidation.gridStyle(style);
         const properties = {
             stroke: 'Stroke',
             majorWidth: 'MajorWidth',

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

@@ -1,6 +1,5 @@
-/** Shared lifecycle and style validation for chart layer adapters. */
+/** Shared lifecycle guard for chart layer adapters. */
 export declare abstract class LayerControl {
     protected readonly assertAlive: () => void;
     protected constructor(assertAlive: () => void);
-    protected validateLengths<T>(style: T, keys: readonly (keyof T)[]): void;
 }

package/dist/lib/grid/LayerControl.js

@@ -1,16 +1,7 @@
-/** Shared lifecycle and style validation for chart layer adapters. */
+/** Shared lifecycle guard for chart layer adapters. */
 export class LayerControl {
     assertAlive;
     constructor(assertAlive) {
         this.assertAlive = assertAlive;
     }
-    validateLengths(style, keys) {
-        for (const key of keys) {
-            const value = style[key];
-            if (value !== undefined &&
-                (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
-                throw new RangeError(`${String(key)} must be a positive finite number.`);
-            }
-        }
-    }
 }

package/dist/lib/index.d.ts

@@ -1,9 +1,9 @@
 export { Smith, SmithEventType } from './Smith.js';
 export type { SmithEvent } from './Smith.js';
 export { Complex } from './math/Complex.js';
-export type { TraceSamples, TraceSample } from './samples.js';
+export type { TraceSamples, TraceSample, TraceTuple, TraceInput } from './samples.js';
 export { Touchstone } from './io/Touchstone.js';
-export type { TouchstoneData } from './io/Touchstone.js';
+export type { TouchstoneData, TouchstoneParseOptions, TouchstoneWriteOptions } from './io/types.js';
 export { SmithScales } from './scales/SmithScales.js';
 export { MarkerMeasurements } from './MarkerMeasurements.js';
 export type { TraceOptions, TraceUpdateOptions, MarkerSelectionStrategy, TraceStyle, TraceRenderMode, TraceInfo, MarkerInfo, MarkerSnapshot, MarkerComparison, } from './measurements.js';
@@ -14,3 +14,4 @@ export { SmithFormatter } from './SmithFormatter.js';
 export type { ReactiveComponent } from './rf/RfCalculations.js';
 export type { SmithAppearance, SmithTheme, SmithThemeOverrides } from './appearance/types.js';
 export type { MarkerLegendField, MarkerLegendOptions, ImageExportOptions, SmithImageExportOptions, ScaleImageExportOptions, ScaleExportReadout, } from './svg/export.js';
+export type { SmithOptions, GridOptions, GridLayerOptions, CircleLayerOptions, CircleOptions, InteractionOptions, PeripheralScalesOptions, } from './options.js';