smithkit 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,11 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+import { SmithDrawOptions } from './SmithDrawOptions.js';
+export declare class SmithGroup extends SmithShape {
+    constructor(options?: SmithDrawOptions);
+    get Element(): d3.Selection<SVGElement, unknown, null, undefined>;
+    attr(name: string, value: Parameters<d3.Selection<SVGElement, unknown, null, undefined>['attr']>[1]): SmithGroup;
+    show(): SmithGroup;
+    hide(): SmithGroup;
+    append(el: SmithShape | null): SmithGroup;
+}

package/dist/lib/draw/SmithGroup.js

@@ -0,0 +1,31 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export class SmithGroup extends SmithShape {
+    constructor(options) {
+        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'g')));
+        if (options) {
+            this.setDrawOptions(options);
+        }
+    }
+    get Element() {
+        return this.element;
+    }
+    attr(name, value) {
+        this.element.attr(name, value);
+        return this;
+    }
+    show() {
+        this.element.attr('opacity', null);
+        return this;
+    }
+    hide() {
+        this.element.attr('opacity', '0');
+        return this;
+    }
+    append(el) {
+        if (el !== null) {
+            this.element.append(() => el.Node);
+        }
+        return this;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Point } from '../shapes/Point.js';
+import { SmithShape } from './SmithShape.js';
+import { SmithDrawOptions } from './SmithDrawOptions.js';
+export declare class SmithLine extends SmithShape {
+    constructor(p1: Point, p2: Point, options?: SmithDrawOptions);
+    move(p1: Point, p2: Point): SmithLine;
+    hide(): void;
+    show(): void;
+    nonScalingStroke(): void;
+    setStrokeLinecap(linecap: string): void;
+}

package/dist/lib/draw/SmithLine.js

@@ -0,0 +1,27 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export class SmithLine extends SmithShape {
+    constructor(p1, p2, options) {
+        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'line')));
+        if (options) {
+            this.setDrawOptions(options);
+        }
+        this.move(p1, p2);
+    }
+    move(p1, p2) {
+        this.element.attr('x1', p1[0]).attr('y1', p1[1]).attr('x2', p2[0]).attr('y2', p2[1]);
+        return this;
+    }
+    hide() {
+        this.Element.attr('opacity', '0');
+    }
+    show() {
+        this.Element.attr('opacity', null);
+    }
+    nonScalingStroke() {
+        this.Element.attr('vector-effect', 'non-scaling-stroke');
+    }
+    setStrokeLinecap(linecap) {
+        this.Element.attr('stroke-linecap', linecap);
+    }
+}

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

@@ -0,0 +1,25 @@
+import { SmithShape } from './SmithShape.js';
+import { Point } from '../shapes/Point.js';
+export declare class SmithMarker extends SmithShape {
+    private dragStateHandler;
+    private readonly size;
+    private mouseGesture;
+    private activeDrags;
+    private destroyed;
+    private triangle;
+    private inner;
+    private text;
+    private rc;
+    private dragHandler;
+    constructor(marker: number, color: string, dragStateHandler?: ((dragging: boolean) => void) | null);
+    destroy(): void;
+    cancelDrag(): void;
+    setColor(color: string): void;
+    private onDrag;
+    get Position(): Point;
+    move(p: Point): void;
+    zoom(k: number): void;
+    show(): void;
+    hide(): void;
+    setDragHandler(handler: (p: Point) => void): void;
+}

package/dist/lib/draw/SmithMarker.js

@@ -0,0 +1,122 @@
+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/draw/SmithPath.d.ts

@@ -0,0 +1,8 @@
+import { SmithShape } from './SmithShape.js';
+import { SmithDrawOptions } from './SmithDrawOptions.js';
+export declare class SmithPath extends SmithShape {
+    constructor(options?: SmithDrawOptions);
+    move(d: string): SmithPath;
+    hide(): void;
+    show(): void;
+}

package/dist/lib/draw/SmithPath.js

@@ -0,0 +1,20 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export class SmithPath extends SmithShape {
+    constructor(options) {
+        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'path')));
+        if (options) {
+            this.setDrawOptions(options);
+        }
+    }
+    move(d) {
+        this.element.attr('d', d);
+        return this;
+    }
+    hide() {
+        this.Element.attr('opacity', '0');
+    }
+    show() {
+        this.Element.attr('opacity', null);
+    }
+}

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

@@ -0,0 +1,19 @@
+import * as d3 from 'd3';
+import { Circle } from '../shapes/Circle.js';
+import { Point } from '../shapes/Point.js';
+import { Line } from '../shapes/Line.js';
+import { Arc } from '../shapes/Arc.js';
+export declare class SmithScaler {
+    readonly x: d3.ScaleLinear<number, number>;
+    readonly y: d3.ScaleLinear<number, number>;
+    readonly r: d3.ScaleLinear<number, number>;
+    constructor(x: d3.ScaleLinear<number, number>, y: d3.ScaleLinear<number, number>, r: d3.ScaleLinear<number, number>);
+    point(p: Readonly<Point>): Point;
+    pointInvert(p: Readonly<Point>): Point;
+    line(l: Line): Line;
+    lineInvert(l: Line): Line;
+    circle(c: Circle): Circle;
+    circleInvert(c: Circle): Circle;
+    arc(a: Arc): Arc;
+    arcInvert(a: Arc): Arc;
+}

package/dist/lib/draw/SmithScaler.js

@@ -0,0 +1,48 @@
+export class SmithScaler {
+    x;
+    y;
+    r;
+    constructor(x, y, r) {
+        this.x = x;
+        this.y = y;
+        this.r = r;
+    }
+    point(p) {
+        return [this.x(p[0]), this.y(p[1])];
+    }
+    pointInvert(p) {
+        return [this.x.invert(p[0]), this.y.invert(p[1])];
+    }
+    line(l) {
+        return { p1: this.point(l.p1), p2: this.point(l.p2) };
+    }
+    lineInvert(l) {
+        return { p1: this.pointInvert(l.p1), p2: this.pointInvert(l.p2) };
+    }
+    circle(c) {
+        return {
+            p: this.point(c.p),
+            r: this.r(c.r),
+        };
+    }
+    circleInvert(c) {
+        return {
+            p: this.pointInvert(c.p),
+            r: this.r.invert(c.r),
+        };
+    }
+    arc(a) {
+        return {
+            p1: this.point(a.p1),
+            p2: this.point(a.p2),
+            r: this.r(a.r),
+        };
+    }
+    arcInvert(a) {
+        return {
+            p1: this.pointInvert(a.p1),
+            p2: this.pointInvert(a.p2),
+            r: this.r.invert(a.r),
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import * as d3 from 'd3';
+import { SmithDrawOptions } from './SmithDrawOptions.js';
+export declare class SmithShape {
+    protected element: d3.Selection<SVGElement, unknown, null, undefined>;
+    constructor(element: d3.Selection<SVGElement, unknown, null, undefined>);
+    setDrawOptions(opts: SmithDrawOptions): SmithShape;
+    set Stroke(color: string);
+    get Stroke(): string;
+    set StrokeWidth(width: string);
+    get StrokeWidth(): string;
+    set Fill(color: string);
+    get Fill(): string;
+    get Node(): SVGElement | null;
+    get Element(): d3.Selection<SVGElement, unknown, null, undefined>;
+}

package/dist/lib/draw/SmithShape.js

@@ -0,0 +1,42 @@
+export class SmithShape {
+    element;
+    constructor(element) {
+        this.element = element;
+    }
+    setDrawOptions(opts) {
+        if (opts.stroke) {
+            this.Stroke = opts.stroke;
+        }
+        if (opts.strokeWidth) {
+            this.StrokeWidth = opts.strokeWidth;
+        }
+        if (opts.fill) {
+            this.Fill = opts.fill;
+        }
+        return this;
+    }
+    set Stroke(color) {
+        this.element.attr('stroke', color);
+    }
+    get Stroke() {
+        return this.element.attr('stroke');
+    }
+    set StrokeWidth(width) {
+        this.element.attr('stroke-width', width);
+    }
+    get StrokeWidth() {
+        return this.element.attr('stroke-width');
+    }
+    set Fill(color) {
+        this.element.attr('fill', color);
+    }
+    get Fill() {
+        return this.element.attr('fill');
+    }
+    get Node() {
+        return this.element.node();
+    }
+    get Element() {
+        return this.element;
+    }
+}

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

@@ -0,0 +1,9 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export declare class SmithSvg {
+    private container;
+    constructor(size: number);
+    get Node(): SVGElement | null;
+    append(el: SmithShape | null): SmithSvg;
+    get Element(): d3.Selection<SVGElement, unknown, null, undefined>;
+}

package/dist/lib/draw/SmithSvg.js

@@ -0,0 +1,27 @@
+import * as d3 from 'd3';
+export class SmithSvg {
+    container;
+    constructor(size) {
+        this.container = d3
+            .select(document.createElementNS('http://www.w3.org/2000/svg', 'svg'))
+            .attr('version', '1.1')
+            .attr('xmlns', 'http://www.w3.org/2000/svg')
+            .attr('width', '100%')
+            .attr('height', '100%')
+            .attr('viewBox', `0 0 ${size} ${size}`)
+            .style('overflow', 'hidden')
+            .attr('preserveAspectRatio', 'xMidYMid meet');
+    }
+    get Node() {
+        return this.container.node();
+    }
+    append(el) {
+        if (el !== null) {
+            this.container.append(() => el.Node);
+        }
+        return this;
+    }
+    get Element() {
+        return this.container;
+    }
+}

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

@@ -0,0 +1,22 @@
+import { Point } from '../shapes/Point.js';
+import { SmithShape } from './SmithShape.js';
+interface TextOptions {
+    dx?: string;
+    dy?: string;
+    stroke?: string;
+    fill?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    textAnchor?: string;
+    rotate?: number;
+    dominantBaseline?: string;
+}
+export declare class SmithText extends SmithShape {
+    private p;
+    constructor(p: Point, text: string, opts?: TextOptions);
+    move(p: Point): SmithText;
+    text(text: string): SmithText;
+    setTextOptions(opts: TextOptions): SmithText;
+    setDominantBaseline(db: string): void;
+}
+export {};

package/dist/lib/draw/SmithText.js

@@ -0,0 +1,56 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export class SmithText extends SmithShape {
+    p;
+    constructor(p, text, opts) {
+        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'text')));
+        this.p = p;
+        this.element.attr('pointer-events', 'none').text(text);
+        if (opts) {
+            this.setTextOptions(opts);
+        }
+        this.move(p);
+    }
+    move(p) {
+        this.element.attr('x', p[0]).attr('y', p[1]);
+        this.p = p;
+        return this;
+    }
+    text(text) {
+        this.element.text(text);
+        return this;
+    }
+    setTextOptions(opts) {
+        if (opts.dx) {
+            this.element.attr('dx', opts.dx);
+        }
+        if (opts.dy) {
+            this.element.attr('dy', opts.dy);
+        }
+        if (opts.stroke) {
+            this.element.attr('stroke', opts.stroke);
+        }
+        if (opts.fill) {
+            this.element.attr('fill', opts.fill);
+        }
+        if (opts.fontFamily) {
+            this.element.attr('font-family', opts.fontFamily);
+        }
+        if (opts.fontSize) {
+            this.element.attr('font-size', opts.fontSize);
+        }
+        if (opts.textAnchor) {
+            this.element.attr('text-anchor', opts.textAnchor);
+        }
+        if (opts.dominantBaseline) {
+            this.element.attr('dominant-baseline', opts.dominantBaseline);
+        }
+        if (opts.rotate !== undefined) {
+            this.element.attr('transform', `rotate(${opts.rotate}, ${this.p[0]}, ${this.p[1]})`);
+        }
+        return this;
+    }
+    setDominantBaseline(db) {
+        this.element.attr('dominant-baseline', db);
+    }
+}

package/dist/lib/formatting.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,16 @@
+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

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

package/dist/lib/grid/definitions.js

@@ -0,0 +1,123 @@
+function 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],
+    ]));
+}
+function 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],
+        ],
+    ]));
+}
+const 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],
+];
+const 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],
+];
+const 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],
+];
+const 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],
+];
+/** Build fresh definitions so callers cannot mutate another chart's grid. */
+export function createGridDefinitions() {
+    return {
+        resistance: {
+            major: { lines: [], circles: [10, 50], arcs: resistanceArcs(resistanceMajor) },
+            minor: { lines: [], circles: [], arcs: resistanceArcs(resistanceMinor) },
+        },
+        reactance: {
+            major: {
+                lines: [{ p1: [-1, 0], p2: [1, 0] }],
+                circles: [],
+                arcs: [
+                    ...reactanceArcs(reactanceMajor),
+                    [
+                        50,
+                        [
+                            [0, 0],
+                            [0, 1],
+                        ],
+                        [false, false],
+                    ],
+                    [
+                        -50,
+                        [
+                            [0, 1],
+                            [0, 0],
+                        ],
+                        [false, true],
+                    ],
+                ],
+            },
+            minor: { lines: [], circles: [], arcs: reactanceArcs(reactanceMinor) },
+        },
+    };
+}