winui-svelte 0.0.6 → 0.0.7

package/dist/progress/progress-source.d.ts

@@ -0,0 +1,46 @@
+import type { ProgressSnapshot, ProgressState } from "./progress-state.js";
+/** The event both an operation and the registry fire after any change of their snapshot. */
+export declare const CHANGE_EVENT = "change";
+/**
+ * Anything with a progress to show: one `ProgressOperation` or a
+ * `ProgressRegistry`. It is an `EventTarget` that fires `change`, a Svelte
+ * store (`$source`), and its getters are reactive in a component or `$effect`.
+ */
+export interface ProgressSource extends EventTarget {
+    /** The latest state; the same object until something changes. */
+    readonly snapshot: ProgressSnapshot;
+    /**
+     * Calls `run` with the snapshot now and after every change.
+     *
+     * @param run - The listener.
+     * @returns Stops the calls.
+     */
+    subscribe(run: (snapshot: ProgressSnapshot) => void): () => void;
+}
+/**
+ * The `subscribe` of a source: the store contract over its `change` event.
+ *
+ * @param options - The source and the listener.
+ * @returns Stops the calls.
+ */
+export declare function subscribeTo({ source, run }: {
+    source: ProgressSource;
+    run: (snapshot: ProgressSnapshot) => void;
+}): () => void;
+/**
+ * Makes a source getters reactive: call the result inside each getter.
+ * Outside an effect, and under Node, it does nothing.
+ *
+ * @param source - The source whose `change` events invalidate a reader.
+ * @returns The function to call before reading.
+ */
+export declare function reactiveReads(source: EventTarget): () => void;
+/** An operation as the registry sees it, whatever it resolves to. */
+export interface TrackedOperation extends ProgressSource {
+    readonly group: string | undefined;
+    readonly state: ProgressState;
+    readonly label: string | undefined;
+    /** Stops the operation. */
+    cancel(reason?: unknown): void;
+}
+//# sourceMappingURL=progress-source.d.ts.map

package/dist/progress/progress-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-source.d.ts","sourceRoot":"","sources":["../../src/progress/progress-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAG3E,4FAA4F;AAC5F,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC;;;;GAIG;AACH,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IAEpC;;;;;OAKG;IACH,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAClE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE;IAC3C,MAAM,EAAE,cAAc,CAAC;IACvB,GAAG,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC3C,cAQA;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,cAKhD;AAED,qEAAqE;AACrE,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC,2BAA2B;IAC3B,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAChC"}

package/dist/progress/progress-source.js

@@ -0,0 +1,31 @@
+import { createSubscriber } from "svelte/reactivity";
+/** The event both an operation and the registry fire after any change of their snapshot. */
+export const CHANGE_EVENT = "change";
+/**
+ * The `subscribe` of a source: the store contract over its `change` event.
+ *
+ * @param options - The source and the listener.
+ * @returns Stops the calls.
+ */
+export function subscribeTo({ source, run }) {
+    function listener() {
+        run(source.snapshot);
+    }
+    source.addEventListener(CHANGE_EVENT, listener);
+    run(source.snapshot);
+    return () => source.removeEventListener(CHANGE_EVENT, listener);
+}
+/**
+ * Makes a source getters reactive: call the result inside each getter.
+ * Outside an effect, and under Node, it does nothing.
+ *
+ * @param source - The source whose `change` events invalidate a reader.
+ * @returns The function to call before reading.
+ */
+export function reactiveReads(source) {
+    return createSubscriber(update => {
+        source.addEventListener(CHANGE_EVENT, update);
+        return () => source.removeEventListener(CHANGE_EVENT, update);
+    });
+}
+//# sourceMappingURL=progress-source.js.map

package/dist/progress/progress-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-source.js","sourceRoot":"","sources":["../../src/progress/progress-source.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,4FAA4F;AAC5F,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;AAoBrC;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,EAGxC;IACC,SAAS,QAAQ;QACf,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvB,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAChD,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACrB,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,MAAmB;IAC/C,OAAO,gBAAgB,CAAC,MAAM,CAAC,EAAE;QAC/B,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC9C,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/progress/progress-state.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Where an operation is, in the words WinUI's `ProgressBar` and the taskbar
+ * button use: running, paused, failed; `idle` before it starts.
+ */
+export declare const ProgressState: {
+    readonly IDLE: "idle";
+    readonly RUNNING: "running";
+    readonly PAUSED: "paused";
+    readonly COMPLETE: "complete";
+    readonly ERROR: "error";
+    readonly CANCELED: "canceled";
+};
+/** One of the values of `ProgressState`. */
+export type ProgressState = (typeof ProgressState)[keyof typeof ProgressState];
+/**
+ * What a subscriber reads from an operation or from the registry. The
+ * `value`, `isIndeterminate`, `showPaused` and `showError` members have the
+ * names and meaning of `ProgressBar`'s properties (with `maximum` of 1).
+ */
+export interface ProgressSnapshot {
+    readonly state: ProgressState;
+    /** How many operations are unfinished: 0 or 1 for one operation. */
+    readonly count: number;
+    /** Bytes (or units) done; summed over the operations that know their total, for the registry. */
+    readonly loaded: number;
+    /** The whole size, or undefined while unknown. */
+    readonly total: number | undefined;
+    /** How far along, 0 to 1; 1 once complete. */
+    readonly value: number;
+    /** True while the total is unknown: a marquee, not a bar. */
+    readonly isIndeterminate: boolean;
+    readonly showPaused: boolean;
+    readonly showError: boolean;
+    /** What the operation is, when exactly one is unfinished. */
+    readonly label: string | undefined;
+}
+/**
+ * Whether an operation has not reached a final state yet.
+ *
+ * @param state - The state to test.
+ * @returns True for idle, running and paused.
+ */
+export declare function isUnfinished(state: ProgressState): state is "idle" | "paused" | "running";
+/**
+ * How far along, clamped to 0..1.
+ *
+ * @param options - The work done and the whole size.
+ * @returns 0 when the total is unknown or zero.
+ */
+export declare function fractionOf({ loaded, total }: {
+    loaded: number;
+    total: number | undefined;
+}): number;
+//# sourceMappingURL=progress-state.d.ts.map

package/dist/progress/progress-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-state.d.ts","sourceRoot":"","sources":["../../src/progress/progress-state.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;CAOhB,CAAC;AAEX,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAE/E;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAE9B,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,iGAAiG;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,6DAA6D;IAC7D,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,0CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,UAOA"}

package/dist/progress/progress-state.js

@@ -0,0 +1,35 @@
+/**
+ * Where an operation is, in the words WinUI's `ProgressBar` and the taskbar
+ * button use: running, paused, failed; `idle` before it starts.
+ */
+export const ProgressState = {
+    IDLE: "idle",
+    RUNNING: "running",
+    PAUSED: "paused",
+    COMPLETE: "complete",
+    ERROR: "error",
+    CANCELED: "canceled"
+};
+/**
+ * Whether an operation has not reached a final state yet.
+ *
+ * @param state - The state to test.
+ * @returns True for idle, running and paused.
+ */
+export function isUnfinished(state) {
+    return state === ProgressState.IDLE || state === ProgressState.RUNNING || state === ProgressState.PAUSED;
+}
+/**
+ * How far along, clamped to 0..1.
+ *
+ * @param options - The work done and the whole size.
+ * @returns 0 when the total is unknown or zero.
+ */
+export function fractionOf({ loaded, total }) {
+    const isUnknown = total === undefined || total <= 0;
+    if (isUnknown) {
+        return 0;
+    }
+    return Math.min(1, Math.max(0, loaded / total));
+}
+//# sourceMappingURL=progress-state.js.map

package/dist/progress/progress-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-state.js","sourceRoot":"","sources":["../../src/progress/progress-state.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;CACZ,CAAC;AAkCX;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAoB;IAC/C,OAAO,KAAK,KAAK,aAAa,CAAC,IAAI,IAAI,KAAK,KAAK,aAAa,CAAC,OAAO,IAAI,KAAK,KAAK,aAAa,CAAC,MAAM,CAAC;AAC3G,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,EAGzC;IACC,MAAM,SAAS,GAAG,KAAK,KAAK,SAAS,IAAI,KAAK,IAAI,CAAC,CAAC;IACpD,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/dist/progress/progress-text.d.ts

@@ -0,0 +1,10 @@
+import type { ProgressSnapshot } from "./progress-state.js";
+/**
+ * A line for a menu or a status area: "setup.exe - 45%", "3 operations - 12%",
+ * "setup.exe - paused", "setup.exe - failed". A marquee has no percent.
+ *
+ * @param snapshot - The state to describe.
+ * @returns The text.
+ */
+export declare function progressText(snapshot: ProgressSnapshot): string;
+//# sourceMappingURL=progress-text.d.ts.map

package/dist/progress/progress-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-text.d.ts","sourceRoot":"","sources":["../../src/progress/progress-text.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,gBAAgB,UActD"}

package/dist/progress/progress-text.js

@@ -0,0 +1,23 @@
+import { ProgressState } from "./progress-state.js";
+const PERCENT = 100;
+/**
+ * A line for a menu or a status area: "setup.exe - 45%", "3 operations - 12%",
+ * "setup.exe - paused", "setup.exe - failed". A marquee has no percent.
+ *
+ * @param snapshot - The state to describe.
+ * @returns The text.
+ */
+export function progressText(snapshot) {
+    const { count, label, state, value, isIndeterminate } = snapshot;
+    const name = count > 1 ? `${count} operations` : label ?? "Working";
+    const isFailed = state === ProgressState.ERROR;
+    if (isFailed) {
+        return `${name} - failed`;
+    }
+    const isPaused = state === ProgressState.PAUSED;
+    if (isPaused) {
+        return `${name} - paused`;
+    }
+    return isIndeterminate ? name : `${name} - ${Math.round(value * PERCENT)}%`;
+}
+//# sourceMappingURL=progress-text.js.map

package/dist/progress/progress-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-text.js","sourceRoot":"","sources":["../../src/progress/progress-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,MAAM,OAAO,GAAG,GAAG,CAAC;AAEpB;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,QAA0B;IACrD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,GAAG,QAAQ,CAAC;IACjE,MAAM,IAAI,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC;IACpE,MAAM,QAAQ,GAAG,KAAK,KAAK,aAAa,CAAC,KAAK,CAAC;IAC/C,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,GAAG,IAAI,WAAW,CAAC;IAC5B,CAAC;IAED,MAAM,QAAQ,GAAG,KAAK,KAAK,aAAa,CAAC,MAAM,CAAC;IAChD,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,GAAG,IAAI,WAAW,CAAC;IAC5B,CAAC;IAED,OAAO,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC;AAC9E,CAAC"}

package/dist/progress/scoped-source.d.ts

@@ -0,0 +1,31 @@
+import type { ProgressRegistry } from "./progress-registry.js";
+import type { ProgressSource } from "./progress-source.js";
+/**
+ * The registry a component lists: `of` when given, else the operations of
+ * `group`, else every running operation.
+ *
+ * @param options - The `of` and `group` props.
+ * @returns The registry, and what to call when the component goes away.
+ */
+export declare function scopedRegistry({ of, group }: {
+    of: ProgressRegistry | undefined;
+    group: string | undefined;
+}): {
+    registry: ProgressRegistry;
+    dispose(): void;
+};
+/**
+ * The source a component shows: `of` when given (one operation or a
+ * registry), else the operations of `group`, else every running operation.
+ *
+ * @param options - The `of` and `group` props.
+ * @returns The source, and what to call when the component goes away.
+ */
+export declare function scopedSource({ of, group }: {
+    of: ProgressSource | undefined;
+    group: string | undefined;
+}): {
+    source: ProgressSource;
+    dispose(): void;
+};
+//# sourceMappingURL=scoped-source.d.ts.map

package/dist/progress/scoped-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-source.d.ts","sourceRoot":"","sources":["../../src/progress/scoped-source.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAC5C,EAAE,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACjC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;;;EAUA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAC1C,EAAE,EAAE,cAAc,GAAG,SAAS,CAAC;IAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;;;EAmBA"}

package/dist/progress/scoped-source.js

@@ -0,0 +1,46 @@
+import { defaultProgressRegistry } from "./progress-registry.js";
+/**
+ * The registry a component lists: `of` when given, else the operations of
+ * `group`, else every running operation.
+ *
+ * @param options - The `of` and `group` props.
+ * @returns The registry, and what to call when the component goes away.
+ */
+export function scopedRegistry({ of, group }) {
+    const registry = of ?? defaultProgressRegistry();
+    const isScoped = group !== undefined;
+    const scope = isScoped ? registry.where(group) : undefined;
+    return {
+        registry: scope ?? registry,
+        dispose() {
+            scope?.dispose();
+        }
+    };
+}
+/**
+ * The source a component shows: `of` when given (one operation or a
+ * registry), else the operations of `group`, else every running operation.
+ *
+ * @param options - The `of` and `group` props.
+ * @returns The source, and what to call when the component goes away.
+ */
+export function scopedSource({ of, group }) {
+    const isGiven = of !== undefined;
+    const scoped = scopedRegistry({
+        of: undefined,
+        group
+    });
+    if (isGiven) {
+        return {
+            source: of,
+            dispose() {
+                scoped.dispose();
+            }
+        };
+    }
+    return {
+        source: scoped.registry,
+        dispose: scoped.dispose
+    };
+}
+//# sourceMappingURL=scoped-source.js.map

package/dist/progress/scoped-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-source.js","sourceRoot":"","sources":["../../src/progress/scoped-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAIjE;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,EAAE,EAAE,EAAE,KAAK,EAGzC;IACC,MAAM,QAAQ,GAAG,EAAE,IAAI,uBAAuB,EAAE,CAAC;IACjD,MAAM,QAAQ,GAAG,KAAK,KAAK,SAAS,CAAC;IACrC,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3D,OAAO;QACL,QAAQ,EAAE,KAAK,IAAI,QAAQ;QAC3B,OAAO;YACL,KAAK,EAAE,OAAO,EAAE,CAAC;QACnB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,EAAE,EAAE,EAAE,KAAK,EAGvC;IACC,MAAM,OAAO,GAAG,EAAE,KAAK,SAAS,CAAC;IACjC,MAAM,MAAM,GAAG,cAAc,CAAC;QAC5B,EAAE,EAAE,SAAS;QACb,KAAK;KACN,CAAC,CAAC;IACH,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO;YACL,MAAM,EAAE,EAAE;YACV,OAAO;gBACL,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,CAAC;SACF,CAAC;IACJ,CAAC;IAED,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,QAAQ;QACvB,OAAO,EAAE,MAAM,CAAC,OAAO;KACxB,CAAC;AACJ,CAAC"}

package/dist/progress/taskbar-progress-props.d.ts

@@ -0,0 +1,15 @@
+import type { ProgressSource } from "./progress-source.js";
+import type { TaskbarProgressTarget } from "./taskbar-progress.js";
+import type { WindowHandle } from "../window/window-handle.js";
+/** The props of `TaskbarProgress`. */
+export interface TaskbarProgressProps {
+    /** What to show: an operation or a registry; every running operation (the app-wide registry) when left out. */
+    readonly of?: ProgressSource;
+    /** Shows only the operations of this group, when `of` is left out. */
+    readonly group?: string;
+    /** The window whose taskbar button shows it; the window this is mounted in when left out. */
+    readonly window?: WindowHandle;
+    /** A taskbar button to drive directly, such as one `handle.taskbar` gave. */
+    readonly taskbar?: TaskbarProgressTarget;
+}
+//# sourceMappingURL=taskbar-progress-props.d.ts.map

package/dist/progress/taskbar-progress-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskbar-progress-props.d.ts","sourceRoot":"","sources":["../../src/progress/taskbar-progress-props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,sCAAsC;AACtC,MAAM,WAAW,oBAAoB;IACnC,+GAA+G;IAC/G,QAAQ,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC;IAE7B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAE/B,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC;CAC1C"}

package/dist/progress/taskbar-progress-props.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=taskbar-progress-props.js.map

package/dist/progress/taskbar-progress-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskbar-progress-props.js","sourceRoot":"","sources":["../../src/progress/taskbar-progress-props.ts"],"names":[],"mappings":""}

package/dist/progress/taskbar-progress.d.ts

@@ -0,0 +1,44 @@
+import type { ProgressSource } from "./progress-source.js";
+import type { ProgressSnapshot } from "./progress-state.js";
+import type { TaskbarProgressOptions } from "../window/taskbar-calls.js";
+/** The part of a window taskbar button that a progress drives: `handle.taskbar` fits. */
+export interface TaskbarProgressTarget {
+    setProgress(options: TaskbarProgressOptions): void;
+}
+/**
+ * What the taskbar button shows for a snapshot, with the same meaning as a
+ * `ProgressBar`: a bar that fills, a marquee when the total is unknown, yellow
+ * when paused, red on error, gone when nothing is left.
+ *
+ * @param snapshot - The state to show.
+ * @returns The options for `setProgress`.
+ */
+export declare function taskbarOptionsOf(snapshot: ProgressSnapshot): {
+    state: "error";
+    value?: never;
+} | {
+    state: "paused";
+    value: number;
+} | {
+    state: "none";
+    value?: never;
+} | {
+    state: "indeterminate";
+    value?: never;
+} | {
+    state: "normal";
+    value: number;
+};
+/**
+ * Shows a source on a taskbar button until the returned function is called;
+ * the shell is told only when the bar moves by a step (a thousandth) or the
+ * state changes. `<TaskbarProgress />` is this in markup.
+ *
+ * @param options - The operation or registry, and the window taskbar button.
+ * @returns Stops following the source and clears the bar.
+ */
+export declare function bindTaskbarProgress({ source, taskbar }: {
+    source: ProgressSource;
+    taskbar: TaskbarProgressTarget;
+}): () => void;
+//# sourceMappingURL=taskbar-progress.d.ts.map

package/dist/progress/taskbar-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskbar-progress.d.ts","sourceRoot":"","sources":["../../src/progress/taskbar-progress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAK3E,yFAAyF;AACzF,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAAC;CACpD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB;;;;;;;;;;;;;;;EA4B1D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE;IACvD,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,qBAAqB,CAAC;CAChC,cAiBA"}

package/dist/progress/taskbar-progress.js

@@ -0,0 +1,62 @@
+import { ProgressState } from "./progress-state.js";
+import { TaskbarProgressState } from "../window/taskbar-calls.js";
+const PROGRESS_STEPS = 1000;
+/**
+ * What the taskbar button shows for a snapshot, with the same meaning as a
+ * `ProgressBar`: a bar that fills, a marquee when the total is unknown, yellow
+ * when paused, red on error, gone when nothing is left.
+ *
+ * @param snapshot - The state to show.
+ * @returns The options for `setProgress`.
+ */
+export function taskbarOptionsOf(snapshot) {
+    const { state, value, isIndeterminate } = snapshot;
+    const isFailed = state === ProgressState.ERROR;
+    if (isFailed) {
+        return { state: TaskbarProgressState.ERROR };
+    }
+    const isPaused = state === ProgressState.PAUSED;
+    if (isPaused) {
+        return {
+            state: TaskbarProgressState.PAUSED,
+            value
+        };
+    }
+    const isNotRunning = state !== ProgressState.RUNNING;
+    if (isNotRunning) {
+        return { state: TaskbarProgressState.NONE };
+    }
+    if (isIndeterminate) {
+        return { state: TaskbarProgressState.INDETERMINATE };
+    }
+    return {
+        state: TaskbarProgressState.NORMAL,
+        value
+    };
+}
+/**
+ * Shows a source on a taskbar button until the returned function is called;
+ * the shell is told only when the bar moves by a step (a thousandth) or the
+ * state changes. `<TaskbarProgress />` is this in markup.
+ *
+ * @param options - The operation or registry, and the window taskbar button.
+ * @returns Stops following the source and clears the bar.
+ */
+export function bindTaskbarProgress({ source, taskbar }) {
+    let lastKey = `${TaskbarProgressState.NONE}:0`;
+    const stop = source.subscribe(snapshot => {
+        const options = taskbarOptionsOf(snapshot);
+        const key = `${options.state}:${Math.floor(("value" in options ? options.value : 0) * PROGRESS_STEPS)}`;
+        const isSame = key === lastKey;
+        if (isSame) {
+            return;
+        }
+        lastKey = key;
+        taskbar.setProgress(options);
+    });
+    return () => {
+        stop();
+        taskbar.setProgress({ state: TaskbarProgressState.NONE });
+    };
+}
+//# sourceMappingURL=taskbar-progress.js.map

package/dist/progress/taskbar-progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskbar-progress.js","sourceRoot":"","sources":["../../src/progress/taskbar-progress.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,cAAc,GAAG,IAAI,CAAC;AAO5B;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAA0B;IACzD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,GAAG,QAAQ,CAAC;IACnD,MAAM,QAAQ,GAAG,KAAK,KAAK,aAAa,CAAC,KAAK,CAAC;IAC/C,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,EAAE,KAAK,EAAE,oBAAoB,CAAC,KAAK,EAAmC,CAAC;IAChF,CAAC;IAED,MAAM,QAAQ,GAAG,KAAK,KAAK,aAAa,CAAC,MAAM,CAAC;IAChD,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO;YACL,KAAK,EAAE,oBAAoB,CAAC,MAAM;YAClC,KAAK;SAC2B,CAAC;IACrC,CAAC;IAED,MAAM,YAAY,GAAG,KAAK,KAAK,aAAa,CAAC,OAAO,CAAC;IACrD,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,EAAE,KAAK,EAAE,oBAAoB,CAAC,IAAI,EAAmC,CAAC;IAC/E,CAAC;IAED,IAAI,eAAe,EAAE,CAAC;QACpB,OAAO,EAAE,KAAK,EAAE,oBAAoB,CAAC,aAAa,EAAmC,CAAC;IACxF,CAAC;IAED,OAAO;QACL,KAAK,EAAE,oBAAoB,CAAC,MAAM;QAClC,KAAK;KAC2B,CAAC;AACrC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAE,MAAM,EAAE,OAAO,EAGpD;IACC,IAAI,OAAO,GAAG,GAAG,oBAAoB,CAAC,IAAI,IAAI,CAAC;IAC/C,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;QACvC,MAAM,OAAO,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAC3C,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,EAAE,CAAC;QACxG,MAAM,MAAM,GAAG,GAAG,KAAK,OAAO,CAAC;QAC/B,IAAI,MAAM,EAAE,CAAC;YACX,OAAO;QACT,CAAC;QAED,OAAO,GAAG,GAAG,CAAC;QACd,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,EAAE;QACV,IAAI,EAAE,CAAC;QACP,OAAO,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC,CAAC;AACJ,CAAC"}

package/dist/progress/track-operation.d.ts

@@ -0,0 +1,36 @@
+import { ProgressOperation } from "./progress-operation.js";
+import type { ProgressOperationOptions } from "./progress-operation.js";
+/** What `trackOperation` takes: the operation options and the work. */
+export interface TrackOperationOptions<Result> extends ProgressOperationOptions {
+    /** The work; report with `operation.update`, stop when `operation.signal` aborts. */
+    readonly run: (operation: ProgressOperation<Result>) => Promise<Result>;
+}
+/** The part of an operation that the work reports through. */
+export interface ProgressReporter {
+    readonly signal: AbortSignal;
+    update(options: {
+        loaded: number;
+        total?: number | undefined;
+    }): void;
+}
+/**
+ * Runs `run` as a tracked operation: it starts at once, completes with what
+ * `run` returns, fails with what it throws and is canceled when it throws an
+ * `AbortError`. This is the whole lifecycle for any long work (a copy, an OCR
+ * pass, a decode), so an app wires it in one call.
+ *
+ * @param options - The work and the operation options.
+ * @returns The operation: await it for the result, bind it to a bar, cancel it.
+ */
+export declare function trackOperation<Result>({ run, ...options }: TrackOperationOptions<Result>): ProgressOperation<Result>;
+/**
+ * Passes a stream through and reports the bytes that went by.
+ *
+ * @param options - The stream and the operation to report to.
+ * @returns A stream with the same chunks.
+ */
+export declare function trackStream({ stream, operation }: {
+    stream: ReadableStream<Uint8Array>;
+    operation: ProgressReporter;
+}): ReadableStream<Uint8Array<ArrayBufferLike>>;
+//# sourceMappingURL=track-operation.d.ts.map

package/dist/progress/track-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-operation.d.ts","sourceRoot":"","sources":["../../src/progress/track-operation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAIxE,uEAAuE;AACvE,MAAM,WAAW,qBAAqB,CAAC,MAAM,CAAE,SAAQ,wBAAwB;IAC7E,qFAAqF;IACrF,QAAQ,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,iBAAiB,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACzE;AAED,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,MAAM,CAAC,OAAO,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KAC5B,GAAG,IAAI,CAAC;CACV;AAuBD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,OAAO,EAAE,EAAE,qBAAqB,CAAC,MAAM,CAAC,6BAQxF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE;IACjD,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACnC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,+CAWA"}

package/dist/progress/track-operation.js

@@ -0,0 +1,53 @@
+import { ProgressOperation } from "./progress-operation.js";
+const ABORT_ERROR = "AbortError";
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === ABORT_ERROR;
+}
+async function execute({ operation, run }) {
+    try {
+        operation.complete(await run(operation));
+    }
+    catch (error) {
+        const isCancel = isAbortError(error);
+        if (isCancel) {
+            operation.cancel(error);
+            return;
+        }
+        operation.fail(error);
+    }
+}
+/**
+ * Runs `run` as a tracked operation: it starts at once, completes with what
+ * `run` returns, fails with what it throws and is canceled when it throws an
+ * `AbortError`. This is the whole lifecycle for any long work (a copy, an OCR
+ * pass, a decode), so an app wires it in one call.
+ *
+ * @param options - The work and the operation options.
+ * @returns The operation: await it for the result, bind it to a bar, cancel it.
+ */
+export function trackOperation({ run, ...options }) {
+    const operation = new ProgressOperation(options);
+    operation.start();
+    void execute({
+        operation,
+        run
+    });
+    return operation;
+}
+/**
+ * Passes a stream through and reports the bytes that went by.
+ *
+ * @param options - The stream and the operation to report to.
+ * @returns A stream with the same chunks.
+ */
+export function trackStream({ stream, operation }) {
+    let loaded = 0;
+    return stream.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            loaded += chunk.byteLength;
+            operation.update({ loaded });
+            controller.enqueue(chunk);
+        }
+    }));
+}
+//# sourceMappingURL=track-operation.js.map

package/dist/progress/track-operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-operation.js","sourceRoot":"","sources":["../../src/progress/track-operation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,MAAM,WAAW,GAAG,YAAY,CAAC;AAiBjC,SAAS,YAAY,CAAC,KAAc;IAClC,OAAO,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC;AACrE,CAAC;AAED,KAAK,UAAU,OAAO,CAAS,EAAE,SAAS,EAAE,GAAG,EAG9C;IACC,IAAI,CAAC;QACH,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;IAC3C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,QAAQ,EAAE,CAAC;YACb,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACxB,OAAO;QACT,CAAC;QAED,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAS,EAAE,GAAG,EAAE,GAAG,OAAO,EAAiC;IACvF,MAAM,SAAS,GAAG,IAAI,iBAAiB,CAAS,OAAO,CAAC,CAAC;IACzD,SAAS,CAAC,KAAK,EAAE,CAAC;IAClB,KAAK,OAAO,CAAC;QACX,SAAS;QACT,GAAG;KACJ,CAAC,CAAC;IACH,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,EAAE,MAAM,EAAE,SAAS,EAG9C;IACC,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,OAAO,MAAM,CAAC,WAAW,CACvB,IAAI,eAAe,CAAyB;QAC1C,SAAS,CAAC,KAAK,EAAE,UAAU;YACzB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC;YAC3B,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAC7B,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/tray/menu-svelte/TrayMenuOperations.d.svelte.ts

@@ -0,0 +1,6 @@
+import type { TrayMenuOperationsProps } from "./menu-props.ts";
+import type { Component } from "svelte";
+
+declare const TrayMenuOperations: Component<TrayMenuOperationsProps, Record<string, never>, "">;
+// eslint-disable-next-line no-restricted-exports -- Svelte declares a component as the default export
+export default TrayMenuOperations;

package/dist/tray/menu-svelte/TrayMenuOperations.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+  import type { TrayMenuOperationsProps } from "./menu-props.js";
+  import { operationMenuId } from "./operation-ids.js";
+  import TrayMenuItem from "./TrayMenuItem.svelte";
+  import TrayMenuSubmenu from "./TrayMenuSubmenu.svelte";
+  import { progressText } from "../../progress/progress-text.js";
+  import { scopedRegistry } from "../../progress/scoped-source.js";
+
+  // A submenu with a line per running operation; picking a line cancels it.
+  const props: TrayMenuOperationsProps = $props();
+  const submenu = $derived.by(() => {
+    const { of, group, ...others } = props;
+    return others;
+  });
+  const scoped = $derived(
+    scopedRegistry({
+      of: props.of,
+      group: props.group
+    })
+  );
+
+  $effect(() => () => scoped.dispose());
+</script>
+
+<TrayMenuSubmenu {...submenu}>
+  {#each scoped.registry.operations as operation (operation)}
+    <TrayMenuItem
+      id={operationMenuId(operation)}
+      label={() => progressText(operation.snapshot)}
+      onselect={() => operation.cancel()}
+    />
+  {/each}
+</TrayMenuSubmenu>

package/dist/tray/menu-svelte/TrayMenuProgress.d.svelte.ts

@@ -0,0 +1,6 @@
+import type { TrayMenuProgressProps } from "./menu-props.ts";
+import type { Component } from "svelte";
+
+declare const TrayMenuProgress: Component<TrayMenuProgressProps, Record<string, never>, "">;
+// eslint-disable-next-line no-restricted-exports -- Svelte declares a component as the default export
+export default TrayMenuProgress;

package/dist/tray/menu-svelte/TrayMenuProgress.svelte

@@ -0,0 +1,28 @@
+<script lang="ts">
+  import type { TrayMenuProgressProps } from "./menu-props.js";
+  import TrayMenuItem from "./TrayMenuItem.svelte";
+  import { progressText } from "../../progress/progress-text.js";
+  import { scopedSource } from "../../progress/scoped-source.js";
+
+  // A line of the tray menu that reads "setup.exe - 45%" or "3 operations - 12%"
+  // and is left out while nothing runs. Picking it runs onselect, if any.
+  const props: TrayMenuProgressProps = $props();
+  const item = $derived.by(() => {
+    const { of, group, ...others } = props;
+    return others;
+  });
+  const scoped = $derived(
+    scopedSource({
+      of: props.of,
+      group: props.group
+    })
+  );
+
+  $effect(() => () => scoped.dispose());
+</script>
+
+<TrayMenuItem
+  {...item}
+  isVisible={() => scoped.source.snapshot.count > 0 || scoped.source.snapshot.showError}
+  label={() => progressText(scoped.source.snapshot)}
+/>