smithkit 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,63 @@
+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';
+export interface ArcData {
+    p1: Point;
+    p2: Point;
+    r: number;
+    largeArc: string;
+    sweep: string;
+}
+export interface Shapes {
+    lines: Line[];
+    circles: Circle[];
+    arcs: ArcData[];
+}
+export interface ConstCirclesDrawOptions {
+    stroke: string;
+    minorWidth: string;
+    majorWidth: string;
+    textColor: string;
+    textFontFamily: string;
+    textFontSize: string;
+}
+export declare abstract class ConstCircles {
+    protected scaler: SmithScaler;
+    protected calcs: SmithConstantCircle;
+    protected container: SmithGroup;
+    protected opts: ConstCirclesDrawOptions;
+    protected abstract major: SmithGroup;
+    protected abstract minor: SmithGroup;
+    protected abstract texts: SmithGroup;
+    constructor(scaler: SmithScaler);
+    visibility(visible: boolean): void;
+    show(): void;
+    hide(): void;
+    displayMinor(display: boolean): void;
+    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);
+    get Stroke(): string;
+    set MajorWidth(width: string);
+    get MajorWidth(): string;
+    set MinorWidth(width: string);
+    get MinorWidth(): string;
+    set TextColor(color: string);
+    get TextColor(): string;
+    set TextFontFamily(family: string);
+    get TextFontFamily(): string;
+    set TextFontSize(size: string);
+    get TextFontSize(): string;
+    protected defaultDrawingOptions(): ConstCirclesDrawOptions;
+    protected scaleArc(scaler: SmithScaler, d: [Point, Point, number, boolean, boolean]): ArcData;
+    protected drawShapes(g: d3.Selection<SVGElement, unknown, null, undefined>, color: string, width: string, shapes: Shapes): void;
+}

package/dist/lib/draw/ConstCircles.js

@@ -0,0 +1,158 @@
+import { SmithGroup } from './SmithGroup.js';
+import { SmithConstantCircle } from '../SmithConstantCircle.js';
+export class ConstCircles {
+    scaler;
+    calcs = new SmithConstantCircle();
+    container;
+    opts;
+    constructor(scaler) {
+        this.scaler = scaler;
+        this.container = new SmithGroup();
+        this.opts = this.defaultDrawingOptions();
+    }
+    visibility(visible) {
+        if (visible) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
+    show() {
+        this.container.show();
+        this.texts.show();
+    }
+    hide() {
+        this.container.hide();
+        this.texts.hide();
+    }
+    displayMinor(display) {
+        if (display) {
+            this.minor.show();
+        }
+        else {
+            this.minor.hide();
+        }
+    }
+    showMinor() {
+        this.minor.show();
+    }
+    hideMinor() {
+        this.minor.hide();
+    }
+    build() {
+        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;
+    }
+    setDrawOptions(opts) {
+        this.opts = opts;
+        this.Stroke = opts.stroke;
+        this.major.StrokeWidth = opts.majorWidth;
+        this.minor.StrokeWidth = opts.minorWidth;
+        this.texts
+            .attr('fill', opts.textColor)
+            .attr('font-family', opts.textFontFamily)
+            .attr('font-size', opts.textFontSize);
+    }
+    set Stroke(stroke) {
+        this.opts.stroke = stroke;
+        this.container.Stroke = stroke;
+        this.major.Stroke = stroke;
+        this.minor.Stroke = stroke;
+    }
+    get Stroke() {
+        return this.opts.stroke;
+    }
+    set MajorWidth(width) {
+        this.opts.majorWidth = width;
+        this.major.StrokeWidth = width;
+    }
+    get MajorWidth() {
+        return this.opts.majorWidth;
+    }
+    set MinorWidth(width) {
+        this.opts.minorWidth = width;
+        this.minor.StrokeWidth = width;
+    }
+    get MinorWidth() {
+        return this.opts.minorWidth;
+    }
+    set TextColor(color) {
+        this.opts.textColor = color;
+        this.texts.Fill = color;
+    }
+    get TextColor() {
+        return this.opts.textColor;
+    }
+    set TextFontFamily(family) {
+        this.opts.textFontFamily = family;
+        this.texts.attr('font-family', family);
+    }
+    get TextFontFamily() {
+        return this.opts.textFontFamily;
+    }
+    set TextFontSize(size) {
+        this.opts.textFontSize = size;
+        this.texts.attr('font-size', size);
+    }
+    get TextFontSize() {
+        return this.opts.textFontSize;
+    }
+    defaultDrawingOptions() {
+        return {
+            // Keep curved grid strokes visible at normal browser zoom and low pixel density.
+            stroke: '#64748b',
+            majorWidth: '1',
+            minorWidth: '0.6',
+            textColor: 'black',
+            textFontFamily: 'Verdana',
+            textFontSize: '1',
+        };
+    }
+    scaleArc(scaler, d) {
+        const { p1, p2, r } = scaler.arc({ p1: d[0], p2: d[1], r: d[2] });
+        const largeArc = d[3] ? '1' : '0';
+        const sweep = d[4] ? '0' : '1';
+        return { p1, p2, r, largeArc, sweep };
+    }
+    drawShapes(g, color, width, shapes) {
+        // Shapes inherit styling so changing a layer updates all of its geometry.
+        g.attr('stroke', color).attr('stroke-width', width);
+        g.selectAll('line')
+            .data(shapes.lines)
+            .enter()
+            .append('line')
+            .attr('x1', (d) => d.p1[0])
+            .attr('y1', (d) => d.p1[1])
+            .attr('x2', (d) => d.p2[0])
+            .attr('y2', (d) => d.p2[1])
+            .attr('fill', 'none')
+            .attr('vector-effect', 'non-scaling-stroke');
+        g.selectAll('circle')
+            .data(shapes.circles)
+            .enter()
+            .append('circle')
+            .attr('cx', (d) => d.p[0])
+            .attr('cy', (d) => d.p[1])
+            .attr('r', (d) => d.r)
+            .attr('fill', 'none')
+            .attr('vector-effect', 'non-scaling-stroke');
+        g.selectAll('path')
+            .data(shapes.arcs)
+            .enter()
+            .append('path')
+            .attr('fill', 'none')
+            .attr('vector-effect', 'non-scaling-stroke')
+            .attr('d', (d) => {
+            const { p1, p2, r, largeArc, sweep } = d;
+            return `M${p1[0]},${p1[1]} A${r},${r} 0 ${largeArc},${sweep} ${p2[0]},${p2[1]}`;
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SmithGridLayer, type GridLayerParams } from './SmithGridLayer.js';
+export declare class ConstConductance extends SmithGridLayer {
+    constructor(params: GridLayerParams);
+}

package/dist/lib/draw/ConstConductance.js

@@ -0,0 +1,6 @@
+import { SmithGridLayer } from './SmithGridLayer.js';
+export class ConstConductance extends SmithGridLayer {
+    constructor(params) {
+        super(params, 'conductance');
+    }
+}

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

@@ -0,0 +1,29 @@
+import { SmithGroup } from './SmithGroup.js';
+import { SmithScaler } from './SmithScaler.js';
+interface ConstQDrawOptions {
+    stroke: string;
+    strokeWidth: string;
+}
+export declare class ConstQCircles {
+    private scaler;
+    private calcs;
+    private circles;
+    private opts;
+    private container;
+    constructor(scaler: SmithScaler);
+    private drawConstQCircles;
+    private drawConstQCircle;
+    private getDefaultDrawOptions;
+    setDrawOptions(opts: ConstQDrawOptions): void;
+    set Stroke(stroke: string);
+    get Stroke(): string;
+    set StrokeWidth(width: string);
+    get StrokeWidth(): string;
+    draw(): SmithGroup;
+    visibility(visible: boolean): ConstQCircles;
+    show(): void;
+    hide(): void;
+    append(Q: number): void;
+    remove(Q: number): void;
+}
+export {};

package/dist/lib/draw/ConstQCircles.js

@@ -0,0 +1,86 @@
+import { SmithGroup } from './SmithGroup.js';
+import { SmithArc } from './SmithArc.js';
+import { SmithConstantCircle } from '../SmithConstantCircle.js';
+export class ConstQCircles {
+    scaler;
+    calcs = new SmithConstantCircle();
+    circles = [0.5, 1, 2, 5, 10];
+    opts;
+    container;
+    constructor(scaler) {
+        this.scaler = scaler;
+        this.container = new SmithGroup().attr('fill', 'none').hide();
+        this.drawConstQCircles(this.circles);
+        this.opts = this.getDefaultDrawOptions();
+        this.setDrawOptions(this.opts);
+    }
+    drawConstQCircles(Qs) {
+        Qs.forEach((Q) => this.drawConstQCircle(Q));
+    }
+    drawConstQCircle(Q) {
+        const r = this.calcs.constQCircle(Q).r;
+        const a = this.scaler.arc({ p1: [-1, 0], p2: [1, 0], r });
+        const a1 = new SmithArc(a.p1, a.p2, a.r, false, false);
+        a1.nonScalingStroke();
+        this.container.append(a1);
+        const a2 = new SmithArc(a.p1, a.p2, a.r, false, true);
+        a2.nonScalingStroke();
+        this.container.append(a2);
+    }
+    getDefaultDrawOptions() {
+        return { stroke: 'blue', strokeWidth: '1' };
+    }
+    setDrawOptions(opts) {
+        this.opts = opts;
+        this.container.setDrawOptions(opts);
+    }
+    set Stroke(stroke) {
+        this.opts.stroke = stroke;
+        this.container.Stroke = stroke;
+    }
+    get Stroke() {
+        return this.opts.stroke;
+    }
+    set StrokeWidth(width) {
+        this.opts.strokeWidth = width;
+        this.container.StrokeWidth = width;
+    }
+    get StrokeWidth() {
+        return this.opts.strokeWidth;
+    }
+    draw() {
+        return this.container;
+    }
+    visibility(visible) {
+        if (visible) {
+            this.container.show();
+        }
+        else {
+            this.container.hide();
+        }
+        return this;
+    }
+    show() {
+        this.container.show();
+    }
+    hide() {
+        this.container.hide();
+    }
+    append(Q) {
+        const index = this.circles.indexOf(Q);
+        if (index !== -1) {
+            return;
+        }
+        this.circles.push(Q);
+        this.drawConstQCircle(Q);
+    }
+    remove(Q) {
+        const index = this.circles.indexOf(Q);
+        if (index === -1) {
+            return;
+        }
+        this.circles.splice(index, 1);
+        this.container.Element.selectAll('*').remove();
+        this.drawConstQCircles(this.circles);
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SmithGridLayer, type GridLayerParams } from './SmithGridLayer.js';
+export declare class ConstReactance extends SmithGridLayer {
+    constructor(params: GridLayerParams);
+}

package/dist/lib/draw/ConstReactance.js

@@ -0,0 +1,6 @@
+import { SmithGridLayer } from './SmithGridLayer.js';
+export class ConstReactance extends SmithGridLayer {
+    constructor(params) {
+        super(params, 'reactance');
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SmithGridLayer, type GridLayerParams } from './SmithGridLayer.js';
+export declare class ConstResistance extends SmithGridLayer {
+    constructor(params: GridLayerParams);
+}

package/dist/lib/draw/ConstResistance.js

@@ -0,0 +1,6 @@
+import { SmithGridLayer } from './SmithGridLayer.js';
+export class ConstResistance extends SmithGridLayer {
+    constructor(params) {
+        super(params, 'resistance');
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SmithGridLayer, type GridLayerParams } from './SmithGridLayer.js';
+export declare class ConstSusceptance extends SmithGridLayer {
+    constructor(params: GridLayerParams);
+}

package/dist/lib/draw/ConstSusceptance.js

@@ -0,0 +1,6 @@
+import { SmithGridLayer } from './SmithGridLayer.js';
+export class ConstSusceptance extends SmithGridLayer {
+    constructor(params) {
+        super(params, 'susceptance');
+    }
+}

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

@@ -0,0 +1,29 @@
+import { SmithGroup } from './SmithGroup.js';
+import { SmithScaler } from './SmithScaler.js';
+interface ConstSwrDrawOptions {
+    stroke: string;
+    strokeWidth: string;
+}
+export declare class ConstSwrCircles {
+    private scaler;
+    private calcs;
+    private circles;
+    private opts;
+    private container;
+    constructor(scaler: SmithScaler);
+    private drawConstSwrCircles;
+    private drawConstSwrCircle;
+    private getDefaultDrawOptions;
+    setDrawOptions(opts: ConstSwrDrawOptions): void;
+    set Stroke(stroke: string);
+    get Stroke(): string;
+    set StrokeWidth(width: string);
+    get StrokeWidth(): string;
+    draw(): SmithGroup;
+    visibility(visible: boolean): ConstSwrCircles;
+    show(): void;
+    hide(): void;
+    append(swr: number): void;
+    remove(swr: number): void;
+}
+export {};

package/dist/lib/draw/ConstSwrCircles.js

@@ -0,0 +1,85 @@
+import { SmithGroup } from './SmithGroup.js';
+import { SmithCircle } from './SmithCircle.js';
+import { SmithConstantCircle } from '../SmithConstantCircle.js';
+export class ConstSwrCircles {
+    scaler;
+    calcs = new SmithConstantCircle();
+    circles = [1.2, 1.5, 2, 3, 5, 10];
+    opts;
+    container;
+    constructor(scaler) {
+        this.scaler = scaler;
+        this.container = new SmithGroup().attr('fill', 'none').hide();
+        this.drawConstSwrCircles(this.circles);
+        this.opts = this.getDefaultDrawOptions();
+        this.setDrawOptions(this.opts);
+    }
+    drawConstSwrCircles(swrs) {
+        swrs.forEach((swr) => this.drawConstSwrCircle(swr));
+    }
+    drawConstSwrCircle(swr) {
+        const c = this.scaler.circle({
+            p: [0, 0],
+            r: this.calcs.swrToRflCoeffEOrI(swr),
+        });
+        const circle = new SmithCircle(c);
+        circle.nonScalingStroke();
+        this.container.append(circle);
+    }
+    getDefaultDrawOptions() {
+        return { stroke: 'orange', strokeWidth: '1' };
+    }
+    setDrawOptions(opts) {
+        this.opts = opts;
+        this.container.setDrawOptions(opts);
+    }
+    set Stroke(stroke) {
+        this.opts.stroke = stroke;
+        this.container.Stroke = stroke;
+    }
+    get Stroke() {
+        return this.opts.stroke;
+    }
+    set StrokeWidth(width) {
+        this.opts.strokeWidth = width;
+        this.container.StrokeWidth = width;
+    }
+    get StrokeWidth() {
+        return this.opts.strokeWidth;
+    }
+    draw() {
+        return this.container;
+    }
+    visibility(visible) {
+        if (visible) {
+            this.container.show();
+        }
+        else {
+            this.container.hide();
+        }
+        return this;
+    }
+    show() {
+        this.container.show();
+    }
+    hide() {
+        this.container.hide();
+    }
+    append(swr) {
+        const index = this.circles.indexOf(swr);
+        if (index !== -1) {
+            return;
+        }
+        this.circles.push(swr);
+        this.drawConstSwrCircle(swr);
+    }
+    remove(swr) {
+        const index = this.circles.indexOf(swr);
+        if (index === -1) {
+            return;
+        }
+        this.circles.splice(index, 1);
+        this.container.Element.selectAll('*').remove();
+        this.drawConstSwrCircles(this.circles);
+    }
+}

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

@@ -0,0 +1,6 @@
+/** Release only window listeners belonging to this chart's active mouse gesture. */
+export declare class MouseGesture {
+    private release;
+    capture(event: MouseEvent, namespace: 'zoom' | 'drag'): void;
+    destroy(): void;
+}

package/dist/lib/draw/MouseGesture.js

@@ -0,0 +1,26 @@
+import { select, dragEnable } from 'd3';
+/** Release only window listeners belonging to this chart's active mouse gesture. */
+export class MouseGesture {
+    release;
+    capture(event, namespace) {
+        if (event.type !== 'mousedown' || !event.view) {
+            return;
+        }
+        const view = event.view;
+        const selection = select(view);
+        const move = `mousemove.${namespace}`;
+        const up = `mouseup.${namespace}`;
+        const listener = selection.on(move);
+        this.release = () => {
+            // A different chart may have started a gesture since this one ended.
+            if (listener && selection.on(move) === listener) {
+                selection.on(`${move} ${up}`, null);
+                dragEnable(view, false);
+            }
+        };
+    }
+    destroy() {
+        this.release?.();
+        this.release = undefined;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Point } from '../shapes/Point.js';
+import { SmithShape } from './SmithShape.js';
+import { SmithDrawOptions } from './SmithDrawOptions.js';
+export declare class SmithArc extends SmithShape {
+    constructor(p1: Point, p2: Point, r: number, largeArc: boolean, sweep: boolean, options?: SmithDrawOptions);
+    move(p1: Point, p2: Point, r: number, largeArc: boolean, sweep: boolean): SmithArc;
+    hide(): void;
+    show(): void;
+    nonScalingStroke(): void;
+}

package/dist/lib/draw/SmithArc.js

@@ -0,0 +1,26 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export class SmithArc extends SmithShape {
+    constructor(p1, p2, r, largeArc, sweep, options) {
+        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'path')));
+        if (options) {
+            this.setDrawOptions(options);
+        }
+        this.move(p1, p2, r, largeArc, sweep);
+    }
+    move(p1, p2, r, largeArc, sweep) {
+        const la = largeArc ? '1' : '0';
+        const s = sweep ? '1' : '0';
+        this.element.attr('d', `M${p1[0]},${p1[1]} A${r},${r} 0 ${la},${s} ${p2[0]},${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');
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Circle } from '../shapes/Circle.js';
+import { SmithShape } from './SmithShape.js';
+import { SmithDrawOptions } from './SmithDrawOptions.js';
+export declare class SmithCircle extends SmithShape {
+    constructor(c: Circle, options?: SmithDrawOptions);
+    move(c: Circle): SmithCircle;
+    hide(): void;
+    show(): void;
+    nonScalingStroke(): void;
+}

package/dist/lib/draw/SmithCircle.js

@@ -0,0 +1,24 @@
+import * as d3 from 'd3';
+import { SmithShape } from './SmithShape.js';
+export class SmithCircle extends SmithShape {
+    constructor(c, options) {
+        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'circle')));
+        if (options) {
+            this.setDrawOptions(options);
+        }
+        this.move(c);
+    }
+    move(c) {
+        this.element.attr('cx', c.p[0]).attr('cy', c.p[1]).attr('r', c.r);
+        return this;
+    }
+    hide() {
+        this.Element.attr('opacity', '0');
+    }
+    show() {
+        this.Element.attr('opacity', null);
+    }
+    nonScalingStroke() {
+        this.Element.attr('vector-effect', 'non-scaling-stroke');
+    }
+}

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

@@ -0,0 +1,49 @@
+import { SmithGroup } from './SmithGroup.js';
+import { SmithScaler } from './SmithScaler.js';
+import { Complex } from '../complex/Complex.js';
+interface DrawOptions {
+    point: {
+        radius: number;
+        color: string;
+    };
+    impedance: {
+        width: number;
+        color: string;
+    };
+    admittance: {
+        width: number;
+        color: string;
+    };
+}
+export declare class SmithCursor {
+    private scaler;
+    private epsilon;
+    private pendingMove;
+    private drawingOpts;
+    private calcs;
+    private zClipCircle;
+    private yClipCircle;
+    private rc;
+    private group;
+    private point;
+    private impedance;
+    private admittance;
+    private moveHandler;
+    constructor(scaler: SmithScaler);
+    private appendAll;
+    get Group(): SmithGroup;
+    get Position(): Complex;
+    set Position(rc: Complex);
+    private isWithinPlot;
+    private movePoint;
+    private moveResistance;
+    private moveReactance;
+    private moveConductance;
+    private moveSusceptance;
+    show(): void;
+    hide(): void;
+    private cancelPendingMove;
+    setMoveHandler(handler: ((rc: Complex) => void) | null): void;
+    setDrawOptions(opts: DrawOptions): void;
+}
+export {};