smithkit 0.1.1 → 0.3.0

package/dist/lib/draw/SmithData.js

@@ -1,366 +0,0 @@
-import { SmithGroup } from './SmithGroup.js';
-import { line } from 'd3';
-import { SmithMarker } from './SmithMarker.js';
-export class SmithData {
-    data;
-    color;
-    transform;
-    fgContainer;
-    scaler;
-    markerDragHandler;
-    markerContainer;
-    style;
-    viewportScale = 1;
-    destroyed = false;
-    visible = true;
-    pendingEvents = new Map();
-    group;
-    markersCount = 0;
-    markers = [];
-    handler = null;
-    constructor(data, color, transform, fgContainer, scaler, markerDragHandler, markerContainer = fgContainer, style = {}) {
-        this.data = data;
-        this.color = color;
-        this.transform = transform;
-        this.fgContainer = fgContainer;
-        this.scaler = scaler;
-        this.markerDragHandler = markerDragHandler;
-        this.markerContainer = markerContainer;
-        this.style = {
-            mode: style.mode ?? 'points',
-            lineWidth: style.lineWidth ?? 2,
-            pointRadius: style.pointRadius ?? 2,
-        };
-        this.data = this.copySamples(data);
-        this.group = this.drawTrace(this.data);
-        this.group.attr('pointer-events', 'none');
-        this.fgContainer.append(this.group);
-        this.zoomDataPoints();
-    }
-    drawTrace(data) {
-        const group = new SmithGroup({
-            stroke: 'none',
-            strokeWidth: 'none',
-            fill: this.color,
-        });
-        group.attr('data-role', 'samples');
-        group.attr('data-mode', this.style.mode);
-        if (this.style.mode !== 'points') {
-            const path = line()
-                .x((sample) => this.scaler.x(sample.reflectionCoefficient[0]))
-                .y((sample) => this.scaler.y(sample.reflectionCoefficient[1]));
-            group.Element.append('path')
-                .attr('class', 'trace-line')
-                .attr('d', path(data))
-                .attr('fill', 'none')
-                .attr('stroke', this.color)
-                .attr('stroke-width', this.style.lineWidth)
-                .attr('vector-effect', 'non-scaling-stroke')
-                .attr('stroke-linejoin', 'round')
-                .attr('stroke-linecap', 'round');
-        }
-        if (this.style.mode !== 'line') {
-            this.renderPoints(group, data);
-        }
-        return group;
-    }
-    renderPoints(group, data) {
-        let visible = data;
-        if (data.length > 5000) {
-            const cells = new Set();
-            const cellSize = Math.max(0.5, this.style.pointRadius) / this.viewportScale;
-            const extent = this.scaler.x(1);
-            const margin = this.style.pointRadius / this.viewportScale;
-            visible = data.filter((sample) => {
-                const x = this.scaler.x(sample.reflectionCoefficient[0]) * this.transform.k + this.transform.x;
-                const y = this.scaler.y(sample.reflectionCoefficient[1]) * this.transform.k + this.transform.y;
-                if (x < -margin || y < -margin || x > extent + margin || y > extent + margin) {
-                    return false;
-                }
-                const cell = `${Math.floor(x / cellSize)},${Math.floor(y / cellSize)}`;
-                if (cells.has(cell)) {
-                    return false;
-                }
-                cells.add(cell);
-                return true;
-            });
-        }
-        group.Element.selectAll('circle')
-            .data(visible)
-            .join('circle')
-            .attr('cx', (sample) => this.scaler.x(sample.reflectionCoefficient[0]))
-            .attr('cy', (sample) => this.scaler.y(sample.reflectionCoefficient[1]))
-            .attr('r', this.style.pointRadius / (this.transform.k * this.viewportScale));
-    }
-    setViewportScale(scale) {
-        if (scale === this.viewportScale || !Number.isFinite(scale) || scale <= 0) {
-            return;
-        }
-        this.viewportScale = scale;
-        this.zoomDataPoints();
-    }
-    zoom(transform) {
-        if (this.destroyed) {
-            return;
-        }
-        this.transform = transform;
-        this.zoomDataPoints();
-        this.zoomAllMarkers();
-    }
-    zoomDataPoints() {
-        const k = this.transform.k;
-        if (this.style.mode === 'line') {
-            return;
-        }
-        if (this.data.length > 5000) {
-            this.renderPoints(this.group, this.data);
-        }
-        else {
-            this.group.Element.selectAll('circle').attr('r', this.style.pointRadius / (k * this.viewportScale));
-        }
-    }
-    zoomAllMarkers() {
-        const k = this.transform.k;
-        for (const marker of this.markers) {
-            const entry = marker.selectedPoint;
-            if (entry) {
-                marker.marker.zoom(k);
-            }
-        }
-    }
-    addMarker(sampleIndex = 0) {
-        if (this.destroyed) {
-            throw new Error('This dataset has been removed.');
-        }
-        this.validateSampleIndex(sampleIndex);
-        const markerIndex = this.markersCount++;
-        const marker = new SmithMarker(markerIndex + 1, this.color, (dragging) => this.markerDragHandler?.(marker, dragging));
-        const markerDesc = {
-            marker,
-            selectedPoint: this.data[sampleIndex],
-            number: markerIndex + 1,
-        };
-        this.markers.push(markerDesc);
-        marker.Element.attr('data-role', 'marker');
-        this.markerContainer.append(marker);
-        marker.setDragHandler((mp) => {
-            const dp = this.findClosestPointTo(this.scaler.pointInvert(mp));
-            if (markerDesc.selectedPoint === dp) {
-                return;
-            }
-            markerDesc.selectedPoint = dp;
-            marker.move(this.scaler.point(dp.reflectionCoefficient));
-            marker.zoom(this.transform.k);
-            this.notifyMarker(markerDesc);
-        });
-        marker.zoom(this.transform.k);
-        marker.show();
-        marker.move(this.scaler.point(markerDesc.selectedPoint.reflectionCoefficient));
-        marker.Element.style('display', () => (this.visible ? null : 'none'));
-        this.notifyMarker(markerDesc);
-        return this.markers.length - 1;
-    }
-    removeMarker(index) {
-        const entry = this.markers[index];
-        if (!entry) {
-            return false;
-        }
-        clearTimeout(this.pendingEvents.get(entry));
-        this.pendingEvents.delete(entry);
-        entry.marker.destroy();
-        this.markers.splice(index, 1);
-        return true;
-    }
-    setMarkerSample(index, sampleIndex) {
-        const entry = this.markers[index];
-        if (!entry) {
-            return false;
-        }
-        this.validateSampleIndex(sampleIndex);
-        entry.selectedPoint = this.data[sampleIndex];
-        entry.marker.move(this.scaler.point(entry.selectedPoint.reflectionCoefficient));
-        this.notifyMarker(entry);
-        return true;
-    }
-    setMarkerFrequency(index, frequencyHz) {
-        if (!this.markers[index]) {
-            return false;
-        }
-        if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
-            throw new RangeError('Marker frequency must be finite and non-negative.');
-        }
-        return this.setMarkerSample(index, this.nearestFrequencyIndex(frequencyHz));
-    }
-    nearestFrequencyIndex(frequencyHz) {
-        let closest = 0;
-        let distance = Math.abs(this.data[0].frequencyHz - frequencyHz);
-        for (let i = 1; i < this.data.length; i++) {
-            const nextDistance = Math.abs(this.data[i].frequencyHz - frequencyHz);
-            if (nextDistance < distance) {
-                closest = i;
-                distance = nextDistance;
-            }
-        }
-        return closest;
-    }
-    validateSampleIndex(index) {
-        if (!Number.isInteger(index) || index < 0 || index >= this.data.length) {
-            throw new RangeError('Sample index is outside this trace.');
-        }
-    }
-    get Samples() {
-        return this.data;
-    }
-    get SampleCount() {
-        return this.data.length;
-    }
-    get Color() {
-        return this.color;
-    }
-    get Visible() {
-        return this.visible;
-    }
-    markerSampleIndex(index) {
-        const entry = this.markers[index];
-        return entry ? this.data.indexOf(entry.selectedPoint) : -1;
-    }
-    setColor(color) {
-        this.color = color;
-        this.group.attr('fill', color);
-        this.group.Element.select('.trace-line').attr('stroke', color);
-        this.markers.forEach(({ marker }) => marker.setColor(color));
-    }
-    get Style() {
-        return { ...this.style };
-    }
-    setStyle(options) {
-        const next = {
-            mode: options.mode ?? this.style.mode,
-            lineWidth: options.lineWidth ?? this.style.lineWidth,
-            pointRadius: options.pointRadius ?? this.style.pointRadius,
-        };
-        if (next.mode === this.style.mode &&
-            next.lineWidth === this.style.lineWidth &&
-            next.pointRadius === this.style.pointRadius) {
-            return;
-        }
-        const modeChanged = next.mode !== this.style.mode;
-        this.style = next;
-        if (modeChanged) {
-            this.redraw();
-        }
-        else {
-            this.group.Element.select('.trace-line').attr('stroke-width', next.lineWidth);
-            this.zoomDataPoints();
-        }
-    }
-    redraw() {
-        const group = this.drawTrace(this.data).attr('pointer-events', 'none');
-        // Replace in place to retain trace ordering beneath the separate marker layer.
-        this.group.Node.replaceWith(group.Node);
-        this.group = group;
-        this.group.Element.style('display', () => (this.visible ? null : 'none'));
-    }
-    setVisible(visible) {
-        this.visible = visible;
-        this.group.Element.style('display', () => (visible ? null : 'none'));
-        this.markers.forEach(({ marker }) => {
-            if (!visible) {
-                marker.cancelDrag();
-            }
-            marker.Element.style('display', () => (visible ? null : 'none'));
-        });
-    }
-    copySamples(values) {
-        if (!values.length ||
-            values.some(({ frequencyHz, reflectionCoefficient }) => !Number.isFinite(frequencyHz) ||
-                frequencyHz < 0 ||
-                reflectionCoefficient.length !== 2 ||
-                !reflectionCoefficient.every(Number.isFinite))) {
-            throw new RangeError('A dataset requires samples with a non-negative finite frequency and two finite coordinates.');
-        }
-        return values.map(({ frequencyHz, reflectionCoefficient }) => ({
-            frequencyHz,
-            reflectionCoefficient: [reflectionCoefficient[0], reflectionCoefficient[1]],
-        }));
-    }
-    notifyMarker(entry) {
-        if (this.pendingEvents.has(entry)) {
-            return;
-        }
-        const timer = setTimeout(() => {
-            this.pendingEvents.delete(entry);
-            const index = this.markers.indexOf(entry);
-            if (!this.destroyed && index >= 0) {
-                this.handler?.(index, entry.selectedPoint);
-            }
-        }, 0);
-        this.pendingEvents.set(entry, timer);
-    }
-    cancelEvents() {
-        this.pendingEvents.forEach((timer) => clearTimeout(timer));
-        this.pendingEvents.clear();
-    }
-    update(values, strategy = 'frequency') {
-        if (this.destroyed) {
-            throw new Error('This dataset has been removed.');
-        }
-        const samples = this.copySamples(values);
-        const selectedIndices = this.markers.map((entry) => this.data.indexOf(entry.selectedPoint));
-        this.cancelEvents();
-        this.data = samples;
-        const group = this.drawTrace(samples).attr('pointer-events', 'none');
-        this.group.Element.remove();
-        this.group = group;
-        this.group.Element.style('display', () => (this.visible ? null : 'none'));
-        this.fgContainer.append(group);
-        this.zoomDataPoints();
-        this.markers.forEach((entry, index) => {
-            if (strategy === 'sample-index') {
-                entry.selectedPoint = samples[Math.min(selectedIndices[index], samples.length - 1)];
-            }
-            else if (strategy === 'reflection') {
-                entry.selectedPoint = this.findClosestPointTo(entry.selectedPoint.reflectionCoefficient);
-            }
-            else {
-                entry.selectedPoint = samples[this.nearestFrequencyIndex(entry.selectedPoint.frequencyHz)];
-            }
-            entry.marker.move(this.scaler.point(entry.selectedPoint.reflectionCoefficient));
-            this.notifyMarker(entry);
-        });
-    }
-    destroy() {
-        if (this.destroyed) {
-            return;
-        }
-        this.destroyed = true;
-        this.cancelEvents();
-        this.handler = null;
-        this.markers.forEach(({ marker }) => marker.destroy());
-        this.markers = [];
-        this.markerDragHandler = undefined;
-        this.data = [];
-        this.group.Element.remove();
-    }
-    getMarker(index) {
-        return this.markers[index];
-    }
-    get Markers() {
-        return this.markers.slice();
-    }
-    setMarkerMoveHandler(handler) {
-        this.handler = handler;
-    }
-    findClosestPointTo(p) {
-        const dist = (p1, p2) => {
-            const xd = p1[0] - p2[0];
-            const yd = p1[1] - p2[1];
-            return Math.hypot(xd, yd);
-        };
-        return this.data.reduce((prev, curr) => {
-            const d1 = dist(p, prev.reflectionCoefficient);
-            const d2 = dist(p, curr.reflectionCoefficient);
-            return d1 <= d2 ? prev : curr;
-        });
-    }
-}

package/dist/lib/draw/SmithGridLayer.d.ts

@@ -1,19 +0,0 @@
-import { ConstCircles } from './ConstCircles.js';
-import { SmithGroup } from './SmithGroup.js';
-import type { SmithScaler } from './SmithScaler.js';
-import type { SmithTicksData } from '../grid/types.js';
-import { type GridKind } from '../grid/geometry.js';
-export interface GridLayerParams {
-    scaler: SmithScaler;
-    showMinor: boolean;
-    data: SmithTicksData;
-}
-/** SVG adapter shared by the four constant impedance/admittance layers. */
-export declare class SmithGridLayer extends ConstCircles {
-    private kind;
-    protected major: SmithGroup;
-    protected minor: SmithGroup;
-    protected texts: SmithGroup;
-    constructor(params: GridLayerParams, kind: GridKind);
-    private drawGrid;
-}

package/dist/lib/draw/SmithGridLayer.js

@@ -1,48 +0,0 @@
-import { ConstCircles } from './ConstCircles.js';
-import { SmithGroup } from './SmithGroup.js';
-import { SmithText } from './SmithText.js';
-import { gridGeometry, gridLabel } from '../grid/geometry.js';
-import { resistanceLabels, reactanceLabels } from '../grid/labels.js';
-/** SVG adapter shared by the four constant impedance/admittance layers. */
-export class SmithGridLayer extends ConstCircles {
-    kind;
-    major;
-    minor;
-    texts;
-    constructor(params, kind) {
-        super(params.scaler);
-        this.kind = kind;
-        const real = kind === 'resistance' || kind === 'conductance';
-        const definitions = params.data[real ? 'resistance' : 'reactance'];
-        this.major = this.drawGrid(definitions.major, this.opts.majorWidth);
-        this.minor = this.drawGrid(definitions.minor, this.opts.minorWidth);
-        this.texts = new SmithGroup()
-            .attr('stroke', 'none')
-            .attr('font-size', '7')
-            .attr('font-family', 'Verdana');
-        for (const tick of real ? resistanceLabels() : reactanceLabels()) {
-            const label = gridLabel(kind, tick.definition);
-            this.texts.append(new SmithText(this.scaler.point(label.point), label.text, {
-                rotate: label.rotate,
-                dx: this.scaler.r(label.dx).toString(),
-                dy: this.scaler.r(label.dy).toString(),
-                textAnchor: label.textAnchor,
-                dominantBaseline: label.dominantBaseline,
-            }));
-        }
-        this.build();
-        if (!params.showMinor) {
-            this.minor.hide();
-        }
-    }
-    drawGrid(definitions, width) {
-        const geometry = gridGeometry(this.kind, definitions);
-        const group = new SmithGroup();
-        this.drawShapes(group.Element, this.opts.stroke, width, {
-            lines: geometry.lines.map((line) => this.scaler.line(line)),
-            circles: geometry.circles.map((circle) => this.scaler.circle(circle)),
-            arcs: geometry.arcs.map((arc) => this.scaleArc(this.scaler, arc)),
-        });
-        return group;
-    }
-}

package/dist/lib/draw/SmithMarker.js

@@ -1,122 +0,0 @@
-import * as d3 from 'd3';
-import { MouseGesture } from './MouseGesture.js';
-import { SmithShape } from './SmithShape.js';
-export class SmithMarker extends SmithShape {
-    dragStateHandler;
-    size = 18;
-    mouseGesture = new MouseGesture();
-    activeDrags = new Set();
-    destroyed = false;
-    triangle;
-    inner;
-    text;
-    rc = [0, 0];
-    dragHandler = null;
-    constructor(marker, color, dragStateHandler = null) {
-        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'g')));
-        this.dragStateHandler = dragStateHandler;
-        const g = this.Element.style('cursor', 'var(--smithkit-marker-cursor, grab)');
-        this.triangle = g
-            .append('polygon')
-            .attr('stroke', 'none')
-            .attr('fill', 'gray')
-            .attr('transform', 'translate(0,0)');
-        this.inner = g
-            .append('polygon')
-            .attr('stroke', 'none')
-            .attr('fill', color)
-            .attr('transform', 'translate(0,0)');
-        this.text = g
-            .append('text')
-            .attr('pointer-events', 'none')
-            .attr('transform', 'translate(0,0)')
-            .attr('font-family', 'Verdana')
-            .attr('font-weight', 'normal')
-            .attr('text-anchor', 'middle')
-            .attr('dominant-baseline', 'middle')
-            .attr('x', '0')
-            .attr('y', '0')
-            .attr('fill', 'white')
-            .text(marker.toString());
-        this.zoom(1);
-        const drag = d3
-            .drag()
-            .on('start', (event) => {
-            if (this.destroyed) {
-                return;
-            }
-            this.mouseGesture.capture(event.sourceEvent, 'drag');
-            const wasIdle = this.activeDrags.size === 0;
-            this.activeDrags.add(event.identifier);
-            if (wasIdle) {
-                this.dragStateHandler?.(true);
-            }
-        })
-            .on('drag', (event) => this.onDrag(event))
-            .on('end', (event) => {
-            if (this.activeDrags.delete(event.identifier) && this.activeDrags.size === 0) {
-                this.dragStateHandler?.(false);
-            }
-        });
-        this.triangle.call(drag);
-        this.inner.call(drag);
-    }
-    destroy() {
-        if (this.destroyed) {
-            return;
-        }
-        this.destroyed = true;
-        this.dragHandler = null;
-        this.cancelDrag();
-        this.dragStateHandler = null;
-        this.Element.selectAll('*').on('.drag', null).interrupt();
-        this.Element.remove();
-    }
-    cancelDrag() {
-        if (this.activeDrags.size > 0) {
-            this.activeDrags.clear();
-            this.dragStateHandler?.(false);
-        }
-        this.mouseGesture.destroy();
-    }
-    setColor(color) {
-        this.inner.attr('fill', color);
-    }
-    onDrag(event) {
-        if (this.dragHandler) {
-            this.dragHandler([event.x, event.y]);
-        }
-    }
-    get Position() {
-        return this.rc;
-    }
-    move(p) {
-        this.rc = p;
-        this.triangle.attr('transform', `translate(${p[0]},${p[1]})`);
-        this.inner.attr('transform', `translate(${p[0]},${p[1]})`);
-        this.text.attr('x', `${p[0]}`).attr('y', `${p[1]}`);
-    }
-    zoom(k) {
-        const size = this.size / k;
-        const h = size / 12;
-        const dy = -size / 1.6;
-        const fs = size / 1.8;
-        // calculate inner triangle
-        const alpha = Math.atan(1 / 2);
-        const beta = Math.PI / 2 - alpha;
-        const x = h / Math.sin(alpha);
-        const y = h / Math.sin(beta) + h / Math.tan(beta);
-        this.triangle.attr('points', `0,0 ${size / 2},${-size} ${-size / 2},${-size}`);
-        this.inner.attr('points', `0,${-x} ${size / 2 - y},${-size + h} ${-size / 2 + y},${-size + h}`);
-        this.text.attr('font-size', `${fs}`).attr('dy', `${dy}`);
-    }
-    show() {
-        this.Element.attr('opacity', null);
-    }
-    hide() {
-        this.Element.attr('opacity', '0');
-    }
-    setDragHandler(handler) {
-        this.dragHandler = handler;
-    }
-}

package/dist/lib/formatting.d.ts

@@ -1,7 +0,0 @@
-import type { Complex } from './complex/Complex.js';
-/** Format with three significant digits and an SI prefix; includes spacing before the unit. */
-export declare function formatNumber(value: number): string;
-/** Format Cartesian components to decimalPlaces fractional digits. */
-export declare function formatComplex(value: Complex, unit?: string, decimalPlaces?: number): string;
-/** Format magnitude and phase in degrees to decimalPlaces fractional digits. */
-export declare function formatComplexPolar(value: Complex, unit?: string, decimalPlaces?: number): string;

package/dist/lib/formatting.js

@@ -1,16 +0,0 @@
-import { format } from 'd3';
-/** Format with three significant digits and an SI prefix; includes spacing before the unit. */
-export function formatNumber(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. */
-export function formatComplex(value, unit = '', decimalPlaces = 3) {
-    return `${value.toString(decimalPlaces)} ${unit === '' ? '' : `[${unit}]`}`;
-}
-/** Format magnitude and phase in degrees to decimalPlaces fractional digits. */
-export function formatComplexPolar(value, unit = '', decimalPlaces = 3) {
-    return `${value.abs().toFixed(decimalPlaces)} ${unit} ∠${((value.arg() * 180) / Math.PI).toFixed(decimalPlaces)}°`;
-}

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

@@ -1,3 +0,0 @@
-import type { SmithTicksData } from './types.js';
-/** Build fresh definitions so callers cannot mutate another chart's grid. */
-export declare function createGridDefinitions(): SmithTicksData;