@tellegen/svelte 0.4.2 → 0.4.4

package/dist/diagram/colour-modes.js

@@ -0,0 +1,33 @@
+import { priceColor, sensColor } from '../colors.js';
+export const COLOUR_MODES = {
+    none: { label: 'Equipment / topology', continuous: false },
+    voltage: { label: 'Voltage limits', continuous: false },
+    'voltage-band': { label: 'Voltage within band', continuous: true },
+    loading: { label: 'Loading thresholds', continuous: false },
+    'loading-heat': { label: 'Loading (continuous)', continuous: true }
+};
+/** Threshold and continuous variants of one quantity share issue focus, warnings and presets. */
+export function colourFamily(mode) {
+    return mode.startsWith('voltage') ? 'voltage' : mode.startsWith('loading') ? 'loading' : 'none';
+}
+/** Position in the declared band: −1 at min, 0 mid-band, +1 at max; beyond ±1 is a violation. */
+export function bandPosition(p) {
+    if (p.min === null || p.max === null || !(p.max > p.min))
+        return null;
+    return (2 * p.volts - p.min - p.max) / (p.max - p.min);
+}
+/** The pair nearest a limit decides a bus colour, so a violation can never be averaged away. */
+export function worstBand(pairs) {
+    let worst = null;
+    for (const p of pairs) {
+        const t = bandPosition(p);
+        if (t !== null && (worst === null || Math.abs(t) > Math.abs(worst)))
+            worst = t;
+    }
+    return worst;
+}
+/** The application's sequential ramp; light loads start part-way up so they stay visible on paper. */
+export const loadingColour = (loading) => priceColor(0.15 + 0.85 * Math.min(1, Math.max(0, loading / 100)));
+/** The application's diverging ramp over the declared band, clamped at the limits. */
+export const bandColour = (t) => sensColor(Math.max(-1, Math.min(1, t)));
+export const MISSING_COLOUR = [128, 128, 128, 170];

package/dist/diagram/connections.d.ts

@@ -0,0 +1,30 @@
+import type { DistConnection, DistGraph, DistWindingDetail } from '@tellegen/engine';
+import type { Glyph } from './schematic-equipment.js';
+/** How a transformer is built, as the drawing tells it: single-phase, split-phase (a centre-tapped
+ * secondary: PowerIO models its halves as two windings on one bus), or polyphase. */
+export type TransformerKind = 'single' | 'split' | 'poly';
+export interface TransformerInfo {
+    kind: TransformerKind;
+    /** The windings at the edge's from and to buses (the first, for a split secondary). */
+    from: DistWindingDetail | null;
+    to: DistWindingDetail | null;
+    /** "Dyn · 500 kVA", "1φ split · 25 kVA": vector group without its clock number, and rating. */
+    label: string;
+}
+/** What kind of transformer edge `k` belongs to, and its windings at either end. Null when the
+ * edge carries no winding detail (a graph from before connections were exported). */
+export declare function transformerInfo(graph: DistGraph, k: number): TransformerInfo | null;
+/** A winding connection mark centred on the origin, `r` across: Δ, Y, or Y with a neutral tail. */
+export declare function connectionMark(w: DistWindingDetail, phases: number, r: number): Glyph;
+/** The transformer symbol: two overlapping winding circles on the line. A polyphase unit carries
+ * each winding's connection inside its circle; a split-phase unit a tap brought out below its
+ * secondary; a single-phase unit plain circles. The from winding is drawn at −x. */
+export declare function transformerGlyph(info: TransformerInfo | null, phases: number, leads?: boolean): Glyph;
+/** Terminals as a compact label: "b–n" across two terminals, else the names run together when all
+ * are single characters ("123n") and dotted otherwise; a wye or delta connection leads ("Y 123n"). */
+export declare function terminalLabel(terminals: string[], connection?: DistConnection): string;
+/** Phase conductors and whether the neutral is among `terminals`, at a bus with `neutral`. */
+export declare function terminalConductors(terminals: string[], neutral: string | null | undefined): {
+    phases: number;
+    neutral: boolean;
+};

package/dist/diagram/connections.js

@@ -0,0 +1,129 @@
+const ring = (cx, cy, r, steps = 20) => Array.from({ length: steps + 1 }, (_, i) => {
+    const a = (2 * Math.PI * i) / steps;
+    return [cx + r * Math.cos(a), cy + r * Math.sin(a)];
+});
+const sameBus = (a, b) => a.toLowerCase() === b.toLowerCase();
+function formatVa(va) {
+    if (!(va > 0))
+        return '';
+    return va >= 1e6
+        ? `${Number((va / 1e6).toPrecision(3))} MVA`
+        : `${Number((va / 1e3).toPrecision(3))} kVA`;
+}
+/** A winding's IEC letter: D or Y, N when its neutral is brought out; lower case for the lower
+ * voltage side. */
+function windingLetters(w, phases, high) {
+    const letter = w.connection === 'delta' ? 'D' : w.connection === 'wye' ? 'Y' : '?';
+    const neutral = w.connection === 'wye' && w.terminals.length > phases ? 'N' : '';
+    const out = letter + neutral;
+    return high ? out : out.toLowerCase();
+}
+/** What kind of transformer edge `k` belongs to, and its windings at either end. Null when the
+ * edge carries no winding detail (a graph from before connections were exported). */
+export function transformerInfo(graph, k) {
+    const edge = graph.edges[k];
+    const windings = edge.windings;
+    if (edge.kind !== 'transformer' || !windings?.length)
+        return null;
+    const phases = edge.n_phases;
+    const shared = windings.some((w, i) => windings.some((v, j) => j > i && sameBus(w.bus, v.bus)));
+    const kind = phases >= 2 ? 'poly' : shared ? 'split' : 'single';
+    const from = windings.find((w) => sameBus(w.bus, edge.from)) ?? null;
+    const to = windings.find((w) => sameBus(w.bus, edge.to) && w !== from) ??
+        windings.find((w) => sameBus(w.bus, edge.to)) ??
+        null;
+    const rating = formatVa(Math.max(...windings.map((w) => w.s_rating)));
+    let group;
+    if (kind === 'poly') {
+        const sorted = [...new Set([from, to].filter((w) => !!w))].sort((a, b) => b.v_ref - a.v_ref);
+        group = sorted.map((w, i) => windingLetters(w, phases, i === 0)).join('');
+    }
+    else
+        group = kind === 'split' ? '1φ split' : '1φ';
+    return { kind, from, to, label: rating ? `${group} · ${rating}` : group };
+}
+/** A winding connection mark centred on the origin, `r` across: Δ, Y, or Y with a neutral tail. */
+export function connectionMark(w, phases, r) {
+    const h = 0.866 * r;
+    if (w.connection === 'delta')
+        return [
+            [
+                [0, -r],
+                [h, r / 2],
+                [-h, r / 2],
+                [0, -r]
+            ]
+        ];
+    if (w.connection !== 'wye')
+        return [];
+    const y = [
+        [
+            [0, 0],
+            [0, -r]
+        ],
+        [
+            [0, 0],
+            [h, r / 2]
+        ],
+        [
+            [0, 0],
+            [-h, r / 2]
+        ]
+    ];
+    if (w.terminals.length > phases)
+        y.push([
+            [0, 0],
+            [0, r * 1.15]
+        ]);
+    return y;
+}
+/** The transformer symbol: two overlapping winding circles on the line. A polyphase unit carries
+ * each winding's connection inside its circle; a split-phase unit a tap brought out below its
+ * secondary; a single-phase unit plain circles. The from winding is drawn at −x. */
+export function transformerGlyph(info, phases, leads = true) {
+    const circles = [ring(-0.45, 0, 0.7), ring(0.45, 0, 0.7)];
+    const out = leads
+        ? [
+            [
+                [-1.4, 0],
+                [-1.15, 0]
+            ],
+            ...circles,
+            [
+                [1.15, 0],
+                [1.4, 0]
+            ]
+        ]
+        : circles;
+    if (!info)
+        return out;
+    const place = (glyph, dx) => glyph.map((line) => line.map(([x, y]) => [x + dx, y]));
+    if (info.kind === 'poly') {
+        if (info.from)
+            out.push(...place(connectionMark(info.from, phases, 0.3), -0.68));
+        if (info.to)
+            out.push(...place(connectionMark(info.to, phases, 0.3), 0.68));
+    }
+    else if (info.kind === 'split')
+        out.push([
+            [0.45, 0.7],
+            [0.45, 1.05]
+        ], ring(0.45, 1.13, 0.08, 8));
+    return out;
+}
+/** Terminals as a compact label: "b–n" across two terminals, else the names run together when all
+ * are single characters ("123n") and dotted otherwise; a wye or delta connection leads ("Y 123n"). */
+export function terminalLabel(terminals, connection) {
+    if (!terminals.length)
+        return '';
+    if (terminals.length === 2 && connection !== 'wye' && connection !== 'delta')
+        return `${terminals[0]}–${terminals[1]}`;
+    const names = terminals.every((t) => t.length === 1) ? terminals.join('') : terminals.join('·');
+    const lead = connection === 'wye' ? 'Y ' : connection === 'delta' ? 'Δ ' : '';
+    return lead + names;
+}
+/** Phase conductors and whether the neutral is among `terminals`, at a bus with `neutral`. */
+export function terminalConductors(terminals, neutral) {
+    const hasNeutral = !!neutral && terminals.includes(neutral);
+    return { phases: terminals.length - (hasNeutral ? 1 : 0), neutral: hasNeutral };
+}

package/dist/diagram/display-tree.d.ts

@@ -0,0 +1,21 @@
+import type { DistGraph } from '@tellegen/engine';
+/** A breadth-first spanning forest over closed edges, rooted at source buses. It orders the drawing
+ * and the voltage profile; it is not a claim about a unique electrical path through a mesh. */
+export interface DisplayTree {
+    /** Parent bus index; a root is its own parent. Unreached buses are their own root too. */
+    parent: Int32Array;
+    /** Edge index from the parent, or −1 for roots. */
+    parentEdge: Int32Array;
+    depth: Int32Array;
+    /** Component index, one per root. */
+    component: Int32Array;
+    roots: number[];
+}
+/** Roots are source buses in graph order; any bus a source cannot reach starts its own component,
+ * so every bus has a depth and nothing is silently dropped. Open switches are not traversed. */
+export declare function displayTree(graph: DistGraph): DisplayTree;
+/** Root-to-bus path as bus and edge indices, root first. */
+export declare function treePath(tree: DisplayTree, bus: number): {
+    buses: number[];
+    edges: number[];
+};

package/dist/diagram/display-tree.js

@@ -0,0 +1,65 @@
+/** Roots are source buses in graph order; any bus a source cannot reach starts its own component,
+ * so every bus has a depth and nothing is silently dropped. Open switches are not traversed. */
+export function displayTree(graph) {
+    const n = graph.buses.length;
+    const index = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    const adjacency = Array.from({ length: n }, () => []);
+    graph.edges.forEach((e, k) => {
+        const a = index.get(e.from.toLowerCase());
+        const b = index.get(e.to.toLowerCase());
+        if (!e.closed || a === undefined || b === undefined || a === b)
+            return;
+        adjacency[a].push({ to: b, edge: k });
+        adjacency[b].push({ to: a, edge: k });
+    });
+    const parent = new Int32Array(n).fill(-1);
+    const parentEdge = new Int32Array(n).fill(-1);
+    const depth = new Int32Array(n).fill(-1);
+    const component = new Int32Array(n).fill(-1);
+    const roots = [];
+    const queue = new Int32Array(n);
+    const grow = (root) => {
+        const c = roots.length;
+        roots.push(root);
+        parent[root] = root;
+        depth[root] = 0;
+        component[root] = c;
+        let head = 0;
+        let tail = 0;
+        queue[tail++] = root;
+        while (head < tail) {
+            const u = queue[head++];
+            for (const { to, edge } of adjacency[u]) {
+                if (depth[to] >= 0)
+                    continue;
+                parent[to] = u;
+                parentEdge[to] = edge;
+                depth[to] = depth[u] + 1;
+                component[to] = c;
+                queue[tail++] = to;
+            }
+        }
+    };
+    graph.buses.forEach((b, i) => {
+        if (b.has_source && depth[i] < 0)
+            grow(i);
+    });
+    for (let i = 0; i < n; i++)
+        if (depth[i] < 0)
+            grow(i);
+    return { parent, parentEdge, depth, component, roots };
+}
+/** Root-to-bus path as bus and edge indices, root first. */
+export function treePath(tree, bus) {
+    const buses = [bus];
+    const edges = [];
+    let u = bus;
+    while (tree.parent[u] !== u) {
+        edges.push(tree.parentEdge[u]);
+        u = tree.parent[u];
+        buses.push(u);
+        if (buses.length > tree.parent.length)
+            throw new Error('Display tree has a cycle');
+    }
+    return { buses: buses.reverse(), edges: edges.reverse() };
+}

package/dist/diagram/energisation.d.ts

@@ -0,0 +1,10 @@
+import type { DistGraph } from '@tellegen/engine';
+/** Which buses and branches are connected to a source through closed branches. Transformers carry
+ * energisation; an open switch is live when either side is. */
+export interface Energisation {
+    buses: Uint8Array;
+    edges: Uint8Array;
+    /** Buses not reached from any source. */
+    deadBuses: number;
+}
+export declare function energisation(graph: DistGraph): Energisation;

package/dist/diagram/energisation.js

@@ -0,0 +1,31 @@
+export function energisation(graph) {
+    const n = graph.buses.length;
+    const index = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    const ends = graph.edges.map((e) => [
+        index.get(e.from.toLowerCase()) ?? -1,
+        index.get(e.to.toLowerCase()) ?? -1
+    ]);
+    const adjacent = Array.from({ length: n }, () => []);
+    ends.forEach(([a, b], k) => {
+        if (a < 0 || b < 0 || !graph.edges[k].closed)
+            return;
+        adjacent[a].push(b);
+        adjacent[b].push(a);
+    });
+    const buses = new Uint8Array(n);
+    const queue = [];
+    graph.buses.forEach((b, i) => {
+        if (b.has_source) {
+            buses[i] = 1;
+            queue.push(i);
+        }
+    });
+    for (let head = 0; head < queue.length; head++)
+        for (const j of adjacent[queue[head]])
+            if (!buses[j]) {
+                buses[j] = 1;
+                queue.push(j);
+            }
+    const edges = Uint8Array.from(ends, ([a, b]) => (buses[a] || buses[b] ? 1 : 0));
+    return { buses, edges, deadBuses: n - queue.length };
+}

package/dist/diagram/feeders.d.ts

@@ -0,0 +1,30 @@
+import type { DistGraph } from '@tellegen/engine';
+import type { DisplayTree } from './display-tree.js';
+import type { GalvanicZones } from './galvanic-zones.js';
+/** A feeder: everything a network supplies through one branch leaving its supply bus. On MV that
+ * is a feeder leaving the substation bus; on LV a circuit leaving the transformer's LV bus. Read
+ * from the display tree, so through a closed loop it is the drawn feeder, not a unique one. */
+export interface Feeder {
+    /** The galvanic zone (network) it belongs to. */
+    zone: number;
+    /** The branch leaving the supply bus. */
+    head: number;
+    /** The supply bus: a source bus, or the bus a transformer feeds the network at. */
+    supply: number;
+    /** Its number among the feeders leaving the same supply bus, from 1, in graph order. */
+    number: number;
+    buses: number[];
+    edges: number[];
+}
+export interface Feeders {
+    feeders: Feeder[];
+    /** Per bus: its feeder, or −1 for a supply bus (it belongs to its network, not one feeder). */
+    busFeeder: Int32Array;
+    /** Per edge: its feeder. A transformer is equipment on the feeder upstream of it; −1 where none. */
+    edgeFeeder: Int32Array;
+}
+/** Feeders of every network. A bus starts a feeder when its tree parent is a supply bus (a root, or
+ * entered through a transformer) and the branch between them is not a transformer. */
+export declare function feeders(graph: DistGraph, tree: DisplayTree, zones: GalvanicZones): Feeders;
+/** Edges on the drawn path from bus `i` back to its source, across transformers. */
+export declare function pathToSource(tree: DisplayTree, i: number): number[];

package/dist/diagram/feeders.js

@@ -0,0 +1,57 @@
+/** Feeders of every network. A bus starts a feeder when its tree parent is a supply bus (a root, or
+ * entered through a transformer) and the branch between them is not a transformer. */
+export function feeders(graph, tree, zones) {
+    const n = graph.buses.length;
+    const index = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    const busFeeder = new Int32Array(n).fill(-1);
+    const edgeFeeder = new Int32Array(graph.edges.length).fill(-1);
+    const list = [];
+    const isSupply = (i) => {
+        const k = tree.parentEdge[i];
+        return k < 0 || graph.edges[k].kind === 'transformer';
+    };
+    // Parents before children: buses in order of depth.
+    const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => tree.depth[a] - tree.depth[b]);
+    const perSupply = new Map();
+    for (const i of order) {
+        if (isSupply(i))
+            continue;
+        const p = tree.parent[i];
+        if (isSupply(p)) {
+            const number = (perSupply.get(p) ?? 0) + 1;
+            perSupply.set(p, number);
+            busFeeder[i] = list.length;
+            list.push({
+                zone: zones.busZone[i],
+                head: tree.parentEdge[i],
+                supply: p,
+                number,
+                buses: [],
+                edges: []
+            });
+        }
+        else
+            busFeeder[i] = busFeeder[p];
+        list[busFeeder[i]].buses.push(i);
+    }
+    graph.edges.forEach((e, k) => {
+        const a = index.get(e.from.toLowerCase()) ?? -1;
+        const b = index.get(e.to.toLowerCase()) ?? -1;
+        if (a < 0 || b < 0)
+            return;
+        const [up, down] = tree.depth[a] <= tree.depth[b] ? [a, b] : [b, a];
+        // A transformer sits on the feeder that reaches it; a branch belongs where its far end does.
+        const f = e.kind === 'transformer' ? busFeeder[up] : busFeeder[down];
+        edgeFeeder[k] = f;
+        if (f >= 0)
+            list[f].edges.push(k);
+    });
+    return { feeders: list, busFeeder, edgeFeeder };
+}
+/** Edges on the drawn path from bus `i` back to its source, across transformers. */
+export function pathToSource(tree, i) {
+    const out = [];
+    for (let at = i; at >= 0 && tree.parentEdge[at] >= 0; at = tree.parent[at])
+        out.push(tree.parentEdge[at]);
+    return out;
+}

package/dist/diagram/galvanic-zones.d.ts

@@ -0,0 +1,60 @@
+import type { DistGraph } from '@tellegen/engine';
+import type { DisplayTree } from './display-tree.js';
+import type { ResultSnapshot } from './snapshot.js';
+/** A galvanic zone: buses joined by lines and closed switches, separated from the rest only by
+ * transformers. On a distribution feeder the zones without a source are the LV networks. */
+export interface GalvanicZone {
+    buses: number[];
+    /** Branches inside the zone. */
+    edges: number[];
+    /** Transformers with a winding in the zone; the feeding one first when the display tree has it. */
+    transformers: number[];
+    hasSource: boolean;
+}
+export interface GalvanicZones {
+    zones: GalvanicZone[];
+    /** Zone index per bus. */
+    busZone: Int32Array;
+}
+/** Connected components over closed non-transformer branches. */
+export declare function galvanicZones(graph: DistGraph, tree?: DisplayTree): GalvanicZones;
+export type ZoneState = 'normal' | 'warning' | 'violation' | 'missing';
+/** A zone's worst state: a voltage outside its band or a branch over its rating is a violation,
+ * loading at or above the warning threshold a warning. Its transformers count. */
+export declare function zoneState(zone: GalvanicZone, snapshot: ResultSnapshot | null): ZoneState;
+/** The outline of a zone in a schematic layout: one band per drawing column (depth), from the
+ * zone's highest bus to the lowest attachment symbol below it, joined into a staircase. Tidy and
+ * leaf-order layouts keep each subtree's rows contiguous per column, so neighbouring zones'
+ * outlines do not overlap; a zone nested inside another sits inside its outline. */
+export declare function zoneOutline(zone: GalvanicZone, positions: ArrayLike<number>, below: ArrayLike<number>, options: {
+    dx: number;
+    pad: number;
+}): [number, number][];
+/** A zone's corridor, for source positions: the segments of its own branches and its buses, to be
+ * drawn as a band of fixed screen width. Unlike a hull it covers only where the network runs, so
+ * networks that interleave along streets stay apart; every bus belongs to exactly one zone. */
+export interface ZoneCorridor {
+    z: number;
+    /** Segment indices into the drawing's sources, targets and segmentEdge. */
+    segments: number[];
+    buses: number[];
+    /** Bounding box of its buses: [x0, y0, x1, y1]. */
+    bounds: [number, number, number, number];
+}
+export declare function zoneCorridors(zones: GalvanicZones, geometry: {
+    positions: ArrayLike<number>;
+    segmentEdge: ArrayLike<number>;
+}, include: (zone: GalvanicZone) => boolean): ZoneCorridor[];
+/** A zone's voltage level in volts: the declared rating of a winding or source in it (the
+ * largest), else its declared limits (midpoint of the band; a phase–neutral or phase–ground band
+ * times √3), else its solved voltages, as the median over its buses. Null when none is known. */
+export declare function zoneVoltage(zone: GalvanicZone, graph: DistGraph, snapshot: ResultSnapshot | null): number | null;
+/** `mv` from 1 kV phase–phase up (drawn heavier), else `lv`. Without a known voltage the source
+ * zone counts as `mv`, others as `lv`. */
+export declare function zoneLevel(zone: GalvanicZone, volts: number | null): 'mv' | 'lv';
+/** One-line zone summary for its label: lowest phase–neutral (else phase–ground, else
+ * phase–phase) voltage and highest loading among its branches and transformers, when solved. */
+export declare function zoneSummary(zone: GalvanicZone, snapshot: ResultSnapshot | null): {
+    minVolts: number | null;
+    maxLoading: number | null;
+};