@tellegen/svelte 0.1.0

package/dist/state.svelte.js

@@ -0,0 +1,323 @@
+import { DEFAULT_FORMULATION } from '@tellegen/engine';
+/** A case is perturbed when any committed demand or rating delta is nonzero. Shared
+ * by both solvable case classes so the "perturbed" rule stays single-sourced. */
+const hasPerturbation = (edits) => Object.values(edits).some((mw) => mw !== 0);
+/** A case file parsed in the browser. Network cases can solve after they have
+ * coordinates; a .pwd display file has no case summary, substations only. A
+ * class with a stable identity and reactive fields, like CaseState: the solve
+ * and sensitivity flows mutate fields directly (each is $state, so the panel
+ * re-renders) and the seq tokens stay attached across overlapping async
+ * callbacks, so a stale solve can neither freeze the UI nor clobber a newer one. */
+export class LocalCase {
+    id;
+    label;
+    fileName;
+    /** Case stats; null for a .pwd display only entry. */
+    summary = $state.raw(null);
+    /** Raw powerio Network JSON for the browser solver branch. */
+    networkJson = $state.raw(undefined);
+    /** Topology for synthetic placement when the file has no coordinates. */
+    topology = $state.raw(undefined);
+    coordsKind = $state.raw(undefined);
+    /** Map geometry when the file carried or received coordinates. */
+    view = $state.raw(null);
+    syntheticCenter = $state.raw(undefined);
+    geoSource = $state.raw(undefined);
+    geoWarnings = $state.raw(undefined);
+    network = $state.raw(null);
+    baseSolution = $state.raw(null);
+    solution = $state.raw(null);
+    sensitivity = $state.raw(null);
+    deltas = $state.raw({});
+    /** Committed branch rating deltas (MW from base, keyed by branch). */
+    ratings = $state.raw({});
+    /** The OPF formulation the browser Study solves for this case: DC OPF (default),
+     * full AC OPF, or the SOCWR relaxation. Changing it rebuilds the Study. */
+    formulation = $state(DEFAULT_FORMULATION);
+    iterations = $state.raw([]);
+    solving = $state(false);
+    solveMs = $state(null);
+    solveBackend = $state(null);
+    solveFallbackReason = $state(null);
+    /** Monotone token: only the latest solve may write this case. */
+    solveSeq = 0;
+    /** Monotone token: only the latest sensitivity request may write this case. */
+    sensitivitySeq = 0;
+    predictedObjective = $state(null);
+    /** Present for a PowerWorld .pwd display only entry. */
+    substations = $state.raw(undefined);
+    constructor(init) {
+        this.id = init.id;
+        this.label = init.label;
+        this.fileName = init.fileName;
+        this.summary = init.summary ?? null;
+        this.networkJson = init.networkJson;
+        this.topology = init.topology;
+        this.coordsKind = init.coordsKind;
+        this.view = init.view ?? null;
+        this.substations = init.substations;
+    }
+    get perturbed() {
+        return hasPerturbation(this.deltas) || hasPerturbation(this.ratings);
+    }
+}
+/** One islanded network with its own solver state on the server. API
+ * payloads are reassigned wholesale, so $state.raw throughout. */
+export class CaseState {
+    id;
+    name;
+    network = $state.raw(null);
+    /** Raw powerio Network JSON for the browser solver; fetched lazily. */
+    networkJson = $state.raw(null);
+    /** Boot solution at base demand; never changes. */
+    baseSolution = $state.raw(null);
+    /** Exact solution at the current committed perturbation. */
+    solution = $state.raw(null);
+    sensitivity = $state.raw(null);
+    /** Committed demand deltas (MW from base, keyed by bus). */
+    deltas = $state.raw({});
+    /** Committed branch rating deltas (MW from base, keyed by branch). */
+    ratings = $state.raw({});
+    /** The OPF formulation the browser Study solves for this case: DC OPF (default),
+     * full AC OPF, or the SOCWR relaxation. Changing it rebuilds the Study. */
+    formulation = $state(DEFAULT_FORMULATION);
+    iterations = $state.raw([]);
+    solving = $state(false);
+    solveMs = $state(null);
+    solveBackend = $state(null);
+    solveFallbackReason = $state(null);
+    /** Monotone token: only the latest solve may write this case. */
+    solveSeq = 0;
+    /** Monotone token: only the latest sensitivity request may write this case. */
+    sensitivitySeq = 0;
+    /** Closer for this case's in-flight server solve stream, if any. Owned per
+     * case so closing one case's stream never strands another's solve. */
+    closeStream = null;
+    /** Objective change the gradient predicted for the last commit, to score
+     * the preview once the exact solve lands. */
+    predictedObjective = $state(null);
+    constructor(summary) {
+        this.id = summary.id;
+        this.name = summary.name;
+    }
+    get perturbed() {
+        return hasPerturbation(this.deltas) || hasPerturbation(this.ratings);
+    }
+}
+/** A multiconductor distribution case parsed in the browser, viewed only: no
+ * formulation, no sliders, no Study. It carries the bus/terminal graph, its
+ * placed map view, and the selected bus whose terminal detail expands. Fields
+ * are reactive like the solvable cases so the panel and map track them. */
+export class MulticonductorCase {
+    id;
+    label;
+    fileName;
+    /** Summary counts and coordinate provenance from the parse. */
+    summary = $state.raw(null);
+    /** The render-ready bus/terminal graph. */
+    graph = $state.raw(null);
+    /** Placement kind resolved at ingest from the case's coordinate space. */
+    coordsKind = $state.raw('synthetic');
+    /** The placed map view; null until placed (planar/synthetic await a center). */
+    view = $state.raw(null);
+    syntheticCenter = $state.raw(undefined);
+    /** The selected bus id, whose terminal stack and incident conductors expand;
+     * null when nothing is selected. String-keyed: distribution bus ids are names. */
+    selectedBusId = $state(null);
+    constructor(init) {
+        this.id = init.id;
+        this.label = init.label;
+        this.fileName = init.fileName;
+        this.summary = init.summary;
+        this.graph = init.graph;
+        this.coordsKind = init.coordsKind;
+        this.view = init.view ?? null;
+    }
+    /** Whether the case is placed and ready to render. */
+    get placed() {
+        return this.view !== null;
+    }
+    /** The selected bus's placed detail, or null. */
+    get selectedBus() {
+        if (this.selectedBusId === null)
+            return null;
+        return this.view?.buses.find((b) => b.id === this.selectedBusId) ?? null;
+    }
+}
+export class AppState {
+    cases = $state.raw([]);
+    activeCaseId = $state(null);
+    /** Selected bus in the active case. */
+    selectedBus = $state(null);
+    /** Selected branch in the active case; mutually exclusive with selectedBus. */
+    selectedBranch = $state(null);
+    /** Live slider value (MW from base) before commit; null when idle. */
+    previewDeltaMw = $state(null);
+    /** Live rating slider value (MW from base) before commit; null when idle. */
+    previewRatingMw = $state(null);
+    /** True while the demand control should keep the map in LMP preview mode. */
+    previewActive = $state(false);
+    /** Engine first-order LMP preview for the live drag: predicted change in LMP
+     * ($/MWh) per bus at the previewed edit, scoped to the case and selection
+     * target (bus or branch) it was computed for. Set by the Study path; null when
+     * no Study preview applies (the map then falls back to the JS
+     * sensitivity-times-step preview). Reassigned wholesale, so $state.raw. */
+    previewLmp = $state.raw(null);
+    demandRangeMode = $state('local');
+    displayMode = $state('lmp');
+    sensitivityLoading = $state(false);
+    #error = $state(null);
+    /** Re-runs the operation behind the current `error`, when one applies. Every
+     * write to `error` clears it, so a retry op can never outlive its message. */
+    errorRetry = $state.raw(null);
+    get error() {
+        return this.#error;
+    }
+    set error(message) {
+        this.#error = message;
+        this.errorRetry = null;
+    }
+    /** Case files parsed in the browser via the powerio wasm module. */
+    localCases = $state.raw([]);
+    /** Local case the panel shows; clicking a bundled case or a bus clears it. */
+    activeLocalId = $state(null);
+    placingLocalId = $state(null);
+    /** Multiconductor distribution cases parsed in the browser (viewing only). */
+    multiCases = $state.raw([]);
+    /** Multiconductor case the panel shows; mutually exclusive with the solvable
+     * active ids. */
+    activeMultiId = $state(null);
+    /** Multiconductor case awaiting placement on the map. */
+    placingMultiId = $state(null);
+    dragOver = $state(false);
+    parsingFile = $state(false);
+    /** Map framing request: bump seq so repeat targets still fly. `requestFrame`
+     * returns a promise the map resolves when the camera lands (or immediately
+     * when it cannot fly), so a caller can defer heavy work until the animation
+     * finishes. */
+    frameTarget = $state.raw('all');
+    frameSeq = $state(0);
+    #frameSettled = null;
+    get active() {
+        return this.cases.find((c) => c.id === this.activeCaseId) ?? null;
+    }
+    byId(id) {
+        return this.cases.find((c) => c.id === id) ?? null;
+    }
+    get activeLocal() {
+        return this.localCases.find((c) => c.id === this.activeLocalId) ?? null;
+    }
+    get activeMulti() {
+        return this.multiCases.find((c) => c.id === this.activeMultiId) ?? null;
+    }
+    /** Whether any case is awaiting a click-to-place on the map (local or multi). */
+    get placingId() {
+        return this.placingLocalId ?? this.placingMultiId;
+    }
+    addLocal(c) {
+        this.localCases = [...this.localCases, c];
+        this.activeLocalId = c.id;
+        this.placingLocalId = c.coordsKind === 'synthetic_pending' ? c.id : null;
+    }
+    /** Add a multiconductor case and make it active. A case that still needs a
+     * map center (planar/synthetic, no view yet) enters placement. */
+    addMulti(c) {
+        this.multiCases = [...this.multiCases, c];
+        this.activeCaseId = null;
+        this.activeLocalId = null;
+        this.activeMultiId = c.id;
+        this.placingLocalId = null;
+        this.placingMultiId = c.placed ? null : c.id;
+    }
+    removeMulti(id) {
+        const wasActive = this.activeMultiId === id;
+        this.multiCases = this.multiCases.filter((c) => c.id !== id);
+        if (this.placingMultiId === id)
+            this.placingMultiId = null;
+        if (!wasActive)
+            return { kind: 'none' };
+        this.activeMultiId = null;
+        if (this.activeCaseId !== null || this.activeLocalId !== null)
+            return { kind: 'none' };
+        return this.activateFallback();
+    }
+    removeCase(id) {
+        const wasActive = this.activeCaseId === id;
+        this.cases = this.cases.filter((c) => c.id !== id);
+        if (!wasActive)
+            return { kind: 'none' };
+        this.selectedBus = null;
+        this.selectedBranch = null;
+        this.previewDeltaMw = null;
+        this.previewRatingMw = null;
+        this.previewActive = false;
+        this.previewLmp = null;
+        this.demandRangeMode = 'local';
+        this.sensitivityLoading = false;
+        return this.activateFallback();
+    }
+    removeLocal(id) {
+        const wasActive = this.activeLocalId === id;
+        this.localCases = this.localCases.filter((c) => c.id !== id);
+        if (this.placingLocalId === id)
+            this.placingLocalId = null;
+        if (!wasActive)
+            return { kind: 'none' };
+        this.activeLocalId = null;
+        // A backend case can still be active; only pick a fallback when nothing is.
+        if (this.activeCaseId !== null)
+            return { kind: 'none' };
+        return this.activateFallback();
+    }
+    // Pick the next active case after a removal: the first remaining backend case,
+    // else a remaining local case that can render (a view or substations) or is
+    // awaiting placement, else the first remaining local. Frames whatever it picks.
+    activateFallback() {
+        this.activeCaseId = this.cases[0]?.id ?? null;
+        if (this.activeCaseId) {
+            this.requestFrame(this.activeCaseId);
+            return { kind: 'backend', id: this.activeCaseId };
+        }
+        const nextLocal = this.localCases.find((c) => c.view || c.substations || c.coordsKind === 'synthetic_pending') ??
+            this.localCases[0] ??
+            null;
+        if (nextLocal) {
+            this.activeLocalId = nextLocal.id;
+            this.placingLocalId = nextLocal.coordsKind === 'synthetic_pending' ? nextLocal.id : null;
+            if (nextLocal.view || nextLocal.substations)
+                this.requestFrame(nextLocal.id);
+            else
+                this.requestFrame('all');
+            return { kind: 'local', id: nextLocal.id };
+        }
+        this.activeLocalId = null;
+        this.placingLocalId = null;
+        // A multiconductor case is viewing only, so no hydration target: activate
+        // it, frame whatever is placed, and report `none`.
+        const nextMulti = this.multiCases[0] ?? null;
+        this.activeMultiId = nextMulti?.id ?? null;
+        this.placingMultiId = nextMulti && !nextMulti.placed ? nextMulti.id : null;
+        if (nextMulti?.placed)
+            this.requestFrame(nextMulti.id);
+        else
+            this.requestFrame('all');
+        return { kind: 'none' };
+    }
+    requestFrame(target) {
+        // A superseded request settles immediately; the new request owns the camera.
+        this.settleFrame();
+        this.frameTarget = target;
+        this.frameSeq++;
+        return new Promise((resolve) => {
+            this.#frameSettled = resolve;
+        });
+    }
+    /** The map calls this when the requested camera move has landed. */
+    settleFrame() {
+        this.#frameSettled?.();
+        this.#frameSettled = null;
+    }
+}
+export function createAppState() {
+    return new AppState();
+}

package/dist/study-package.d.ts

@@ -0,0 +1,9 @@
+/** Client-side helper for saved study packages (`.pio.json`). The engine owns
+ * parsing, restoring, and exporting; classification of a dropped file lives in
+ * `drop-classify.ts` (the single owner). This module covers the one remaining
+ * frontend decision around a package: which commit an export targets. */
+/** The commit index for a saved package's current committed state: its last study
+ * commit, or 0 when it carries none (export then writes the base network). Tolerant of
+ * malformed input, returning 0 rather than throwing. */
+export declare function studyCommitIndex(packageJson: string): number;
+//# sourceMappingURL=study-package.d.ts.map

package/dist/study-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"study-package.d.ts","sourceRoot":"","sources":["../src/lib/study-package.ts"],"names":[],"mappings":"AAAA;;;yEAGyE;AAEzE;;wDAEwD;AACxD,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQ5D"}

package/dist/study-package.js

@@ -0,0 +1,17 @@
+/** Client-side helper for saved study packages (`.pio.json`). The engine owns
+ * parsing, restoring, and exporting; classification of a dropped file lives in
+ * `drop-classify.ts` (the single owner). This module covers the one remaining
+ * frontend decision around a package: which commit an export targets. */
+/** The commit index for a saved package's current committed state: its last study
+ * commit, or 0 when it carries none (export then writes the base network). Tolerant of
+ * malformed input, returning 0 rather than throwing. */
+export function studyCommitIndex(packageJson) {
+    try {
+        const commits = JSON.parse(packageJson).study?.commits
+            ?.length;
+        return Math.max(0, (commits ?? 0) - 1);
+    }
+    catch {
+        return 0;
+    }
+}