@wow-two-beta/ui-vue 0.0.2

package/dist/foundation/uploads/UploadQueue.d.ts

@@ -0,0 +1,79 @@
+import { RetryPolicy } from '../resilience';
+import { UploadStatus, UploadItem } from './UploadItem';
+import { UploadTransport } from './UploadTransport';
+/** The default number of uploads in flight at once — enough to saturate a connection without starving the rest of the app. */
+export declare const DefaultUploadConcurrency = 3;
+/** Notified after any queue mutation — admission, status change, progress, removal. Carries no payload; re-read the queue. */
+export type UploadQueueListener = () => void;
+/** Configures a queue at creation. Only `transport` is required. */
+export interface UploadQueueOptions<TResult = unknown> {
+    /** How a file is actually sent. The queue never assumes `fetch` or `XMLHttpRequest`; see {@link UploadTransport}. */
+    readonly transport: UploadTransport<TResult>;
+    /** Max uploads in flight. Defaults to {@link DefaultUploadConcurrency}; values below `1` are clamped up. */
+    readonly concurrency?: number;
+    /** An `accept`-attribute list (`image/*,.pdf`) admitted files must match, via `foundation/files`' `matchesAccept`. */
+    readonly accept?: string;
+    /** The largest admitted file, in bytes. A larger file is rejected up front rather than queued. */
+    readonly maxSize?: number;
+    /** The retry policy for failed attempts, or `false` to fail on the first error. Defaults to `DefaultRetryPolicy`. */
+    readonly retry?: RetryPolicy | false;
+}
+/** Describes the queue as a whole — what a summary bar renders without walking the item list. */
+export interface UploadQueueState {
+    /** How many items the queue holds, in any status. */
+    readonly total: number;
+    /** How many items sit in each status. A file rejected up front counts under `failed`. */
+    readonly counts: Readonly<Record<UploadStatus, number>>;
+    /** Aggregate progress `0`–`1`, byte-weighted over in-play items. `0` when nothing is in play. */
+    readonly progress: number;
+    /** Total bytes uploaded across in-play items. */
+    readonly bytesUploaded: number;
+    /**
+     * Total bytes of in-play items — everything except cancelled items and files rejected up front, whose bytes
+     * will never arrive and would otherwise pin `progress` below `1` forever.
+     */
+    readonly totalBytes: number;
+    /** Whether any item is still queued or uploading. */
+    readonly isUploading: boolean;
+}
+/** The headless upload store — admission, scheduling, cancellation, retry, and change notification. */
+export interface UploadQueue<TResult = unknown> {
+    /**
+     * Admits one file or many, returning the new item ids in the order given. Always returns an array, including
+     * for a single file. A file failing `accept` / `maxSize` still gets an id — as a `failed` item carrying a
+     * `rejection` — so the caller can render why. Never throws.
+     */
+    readonly add: (input: File | readonly File[]) => readonly string[];
+    /**
+     * Aborts an item. A queued item flips to `cancelled` immediately; an uploading one is aborted through its
+     * signal and settles `cancelled` once the transport unwinds (asynchronously). Reports whether anything was
+     * cancellable — `false` for an unknown id or an already-terminal item.
+     */
+    readonly cancel: (id: string) => boolean;
+    /** Aborts every queued and uploading item. In-flight ones settle asynchronously, as with {@link cancel}. */
+    readonly cancelAll: () => void;
+    /**
+     * Re-queues a `failed` or `cancelled` item for another run; `attempt` continues from where it stopped.
+     * Refuses (`false`) an item rejected up front — re-sending an oversized file cannot change the verdict.
+     */
+    readonly retry: (id: string) => boolean;
+    /** Drops an item, aborting it first when in flight (nothing would be listening for its result). */
+    readonly remove: (id: string) => boolean;
+    /** Drops every item, cancelling anything still in flight. */
+    readonly clear: () => void;
+    /** Every item in admission order. Fresh array per call — never track it directly; track `version()` instead. */
+    readonly items: () => readonly UploadItem<TResult>[];
+    /** Looks up one item — `undefined` when absent. Item identity is stable between changes to that item. */
+    readonly get: (id: string) => UploadItem<TResult> | undefined;
+    /** The aggregate snapshot — counts, byte totals, overall progress. Fresh object per call. */
+    readonly state: () => UploadQueueState;
+    /** Subscribes to mutations; returns an unsubscribe. */
+    readonly subscribe: (listener: UploadQueueListener) => () => void;
+    /** A monotonic counter bumped on every mutation — the stable-identity snapshot the composables subscribe to. */
+    readonly version: () => number;
+}
+/**
+ * Creates an {@link UploadQueue}. One per upload surface is the norm; create extra ones to isolate a modal's
+ * uploads from a background set, or per test.
+ */
+export declare function createUploadQueue<TResult = unknown>(options: UploadQueueOptions<TResult>): UploadQueue<TResult>;

package/dist/foundation/uploads/UploadTransport.d.ts

@@ -0,0 +1,41 @@
+/** Provides the per-attempt handles a transport receives — cancellation in, progress out. */
+export interface UploadTransportContext {
+    /** Aborts this attempt. A transport MUST honour it and reject with an `AbortError` (or let `fetch`/`xhr` do so). */
+    readonly signal: AbortSignal;
+    /**
+     * Reports bytes sent so far. `totalBytes` is the transport's own total (multipart overhead included) and is
+     * used only as the denominator — omit it when the length is not computable.
+     */
+    readonly onProgress: (bytesUploaded: number, totalBytes?: number) => void;
+}
+/** Defines how a file is sent. The single seam a consumer implements to plug any backend into the queue. */
+export interface UploadTransport<TResult = unknown> {
+    /**
+     * Sends one file, resolving with whatever the caller wants to keep (an id, a URL, the parsed body). Reject to
+     * signal failure; reject with an `AbortError` when `context.signal` fires. Called once per attempt — a retry
+     * calls it again with a fresh `signal`.
+     */
+    readonly upload: (file: File, context: UploadTransportContext) => Promise<TResult>;
+}
+/**
+ * Defines a transport failure that carries an HTTP status, so the queue's retry decision can respect HTTP
+ * semantics (`503` retries, `413` does not). Throw this from a custom transport, or throw anything with a
+ * numeric `status` — {@link readUploadErrorStatus} is structural.
+ */
+export declare class UploadHttpError extends Error {
+    /** The HTTP status of the failed response (`0` when the request never got one). */
+    readonly status: number;
+    /** The raw response body, when the transport captured one — useful for surfacing a server-side reason. */
+    readonly body?: string;
+    /** Creates an error for a non-2xx (or network-level) upload response. */
+    constructor(status: number, message?: string, body?: string);
+}
+/**
+ * Reads the HTTP status a caught transport failure carries, for `shouldRetry`. Returns `0` — the "network /
+ * unknown" status that the default policy treats as transient — when the value has no numeric `status`.
+ *
+ * Structural on purpose: `UploadHttpError`, `foundation/http`'s `ApiError`, and a hand-rolled
+ * `Object.assign(new Error(), { status })` all read the same, so no error class is privileged and this slice
+ * stays free of an HTTP-layer import. Guarded against a throwing getter — it runs inside a `catch`.
+ */
+export declare function readUploadErrorStatus(error: unknown): number;

package/dist/foundation/uploads/UseUploadQueue.d.ts

@@ -0,0 +1,47 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from 'vue';
+import { UploadItem } from './UploadItem';
+import { UploadQueue, UploadQueueOptions, UploadQueueState } from './UploadQueue';
+/**
+ * Subscribes to a queue's mutations and returns its version counter. The building block behind
+ * {@link useUploadQueueSnapshot}; use it directly to derive a custom projection
+ * (`computed(() => (version.value, queue.items().filter(failed)))`).
+ */
+export declare function useUploadQueueVersion<TResult = unknown>(queue: UploadQueue<TResult>): Readonly<ShallowRef<number>>;
+/** The item list plus the aggregate state of an explicitly-owned queue, updating the caller on every change. */
+export declare function useUploadQueueSnapshot<TResult = unknown>(queue: UploadQueue<TResult>): {
+    readonly items: ComputedRef<readonly UploadItem<TResult>[]>;
+    readonly state: ComputedRef<UploadQueueState>;
+};
+/** What {@link useUploadQueue} hands a component — live state plus every queue action. */
+export interface UseUploadQueueResult<TResult = unknown> {
+    /** The underlying queue, for anything the flattened actions don't cover (`get`, `subscribe`, passing it down). */
+    readonly queue: UploadQueue<TResult>;
+    /** Every item in admission order, refreshed on each change. */
+    readonly items: ComputedRef<readonly UploadItem<TResult>[]>;
+    /** The aggregate snapshot — counts, byte totals, overall progress. */
+    readonly state: ComputedRef<UploadQueueState>;
+    /** Admits one file or many; returns the new item ids. See `UploadQueue.add`. */
+    readonly add: UploadQueue<TResult>['add'];
+    /** Aborts one item. See `UploadQueue.cancel`. */
+    readonly cancel: UploadQueue<TResult>['cancel'];
+    /** Aborts every queued and uploading item. */
+    readonly cancelAll: UploadQueue<TResult>['cancelAll'];
+    /** Re-queues a failed or cancelled item. */
+    readonly retry: UploadQueue<TResult>['retry'];
+    /** Drops an item, aborting it first when in flight. */
+    readonly remove: UploadQueue<TResult>['remove'];
+    /** Drops every item, cancelling anything still in flight. */
+    readonly clear: UploadQueue<TResult>['clear'];
+}
+/**
+ * Creates an upload queue scoped to the component and subscribes to it — the one-call entry point for an upload
+ * panel or drop zone.
+ *
+ * The queue is created at setup and kept for the scope's lifetime, so `concurrency` / `accept` / `maxSize` /
+ * `retry` are setup-time values (`transport` stays live — see the file header). Disposal does NOT cancel
+ * in-flight uploads; call `cancelAll` from `onScopeDispose` if that is the behaviour you want, or hoist the
+ * queue out of the component with `createUploadQueue` + {@link useUploadQueueSnapshot} so uploads survive it.
+ *
+ * @param options Queue configuration. A ref or getter keeps `transport` live; the rest is read once.
+ */
+export declare function useUploadQueue<TResult = unknown>(options: MaybeRefOrGetter<UploadQueueOptions<TResult>>): UseUploadQueueResult<TResult>;

package/dist/foundation/uploads/XhrUploadTransport.d.ts

@@ -0,0 +1,23 @@
+import { UploadTransport } from './UploadTransport';
+/** Configures the built-in `XMLHttpRequest` multipart transport. */
+export interface XhrUploadTransportOptions {
+    /** The endpoint the file is sent to. */
+    readonly url: string;
+    /** The HTTP method. Defaults to `POST`. */
+    readonly method?: string;
+    /** Extra request headers. A `Content-Type` entry is ignored — the browser owns it (multipart boundary). */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** The multipart field name the file is sent under. Defaults to `file`. */
+    readonly fieldName?: string;
+    /** Whether to send cookies / TLS client certs cross-origin (`XMLHttpRequest.withCredentials`). Defaults to `false`. */
+    readonly withCredentials?: boolean;
+}
+/**
+ * Creates an {@link UploadTransport} that sends each file as a `multipart/form-data` request over
+ * `XMLHttpRequest`, forwarding real upload-progress events to the queue.
+ *
+ * Resolves with the parsed JSON response body (the raw text when it is not JSON, `undefined` when empty), cast
+ * to `TResult` — the server's contract is the caller's to declare. Rejects with {@link UploadHttpError} on a
+ * non-2xx or a network failure, and with an `AbortError` when the attempt's signal fires.
+ */
+export declare function xhrUploadTransport<TResult = unknown>(options: XhrUploadTransportOptions): UploadTransport<TResult>;

package/dist/foundation/uploads/index.d.ts

@@ -0,0 +1,5 @@
+export { UploadRejectionReason, UploadStatus, isUploadActive, isUploadTerminal, type UploadItem, } from './UploadItem';
+export { UploadHttpError, readUploadErrorStatus, type UploadTransport, type UploadTransportContext, } from './UploadTransport';
+export { xhrUploadTransport, type XhrUploadTransportOptions } from './XhrUploadTransport';
+export { DefaultUploadConcurrency, createUploadQueue, type UploadQueue, type UploadQueueListener, type UploadQueueOptions, type UploadQueueState, } from './UploadQueue';
+export { useUploadQueue, useUploadQueueSnapshot, useUploadQueueVersion, type UseUploadQueueResult, } from './UseUploadQueue';

package/dist/foundation/uploads/index.js

@@ -0,0 +1,449 @@
+import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { i as isAbortError } from "../../chunks/ErrorRecognizers-oTklha6D.js";
+import { m as matchesAccept } from "../../chunks/Accept-BWpCXDmS.js";
+import { s as safeFileName, a as fileExtension } from "../../chunks/FileName-CmNjFV7t.js";
+import { f as formatBytes } from "../../chunks/Bytes-7Jxs6Bq6.js";
+import { Guid } from "../identifiers/index.js";
+import { DefaultRetryPolicy, shouldRetry, computeRetryDelay } from "../resilience/index.js";
+import { toValue, computed, shallowRef, onMounted, onScopeDispose } from "vue";
+const UploadStatus = {
+  /** Refers to an accepted file waiting for a free concurrency slot. */
+  Queued: "queued",
+  /** Refers to an upload on the wire — including the backoff wait between retry attempts, which still holds its slot. */
+  Uploading: "uploading",
+  /** Refers to an upload the transport completed; `result` carries its value. */
+  Succeeded: "succeeded",
+  /** Refers to an upload that exhausted its retries, or a file rejected before it was ever sent (see `rejection`). */
+  Failed: "failed",
+  /** Refers to an upload aborted by `cancel` / `cancelAll` / `clear`. Never retried automatically. */
+  Cancelled: "cancelled"
+};
+const UploadRejectionReason = {
+  /** Refers to a file that failed the queue's `accept` list. */
+  Type: "type",
+  /** Refers to a file larger than the queue's `maxSize`. */
+  Size: "size"
+};
+function isUploadTerminal(status) {
+  return status === UploadStatus.Succeeded || status === UploadStatus.Failed || status === UploadStatus.Cancelled;
+}
+function isUploadActive(status) {
+  return status === UploadStatus.Uploading;
+}
+class UploadHttpError extends Error {
+  /** The HTTP status of the failed response (`0` when the request never got one). */
+  status;
+  /** The raw response body, when the transport captured one — useful for surfacing a server-side reason. */
+  body;
+  /** Creates an error for a non-2xx (or network-level) upload response. */
+  constructor(status, message, body) {
+    super(message ?? `Upload failed with status ${status}`);
+    this.name = "UploadHttpError";
+    this.status = status;
+    if (body !== void 0) this.body = body;
+  }
+}
+function readUploadErrorStatus(error) {
+  if (typeof error !== "object" || error === null) return 0;
+  try {
+    const status = error.status;
+    return typeof status === "number" && Number.isFinite(status) ? status : 0;
+  } catch {
+    return 0;
+  }
+}
+function createAbortError() {
+  const error = new Error("The upload was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+function parseResponseBody(text) {
+  if (text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function xhrUploadTransport(options) {
+  const { url, method = "POST", headers, fieldName = "file", withCredentials = false } = options;
+  return {
+    upload(file, context) {
+      return new Promise((resolve, reject) => {
+        const { signal, onProgress } = context;
+        if (signal.aborted) {
+          reject(createAbortError());
+          return;
+        }
+        const request = new XMLHttpRequest();
+        const body = new FormData();
+        body.append(fieldName, file, file.name);
+        let settled = false;
+        const settle = (action) => {
+          if (settled) return;
+          settled = true;
+          signal.removeEventListener("abort", onAbort);
+          action();
+        };
+        function onAbort() {
+          settle(() => {
+            request.abort();
+            reject(createAbortError());
+          });
+        }
+        request.open(method, url, true);
+        request.withCredentials = withCredentials;
+        for (const [name, value] of Object.entries(headers ?? {})) {
+          if (name.toLowerCase() === "content-type") continue;
+          request.setRequestHeader(name, value);
+        }
+        request.upload.addEventListener("progress", (event) => {
+          onProgress(event.loaded, event.lengthComputable ? event.total : void 0);
+        });
+        request.addEventListener("load", () => {
+          settle(() => {
+            const { status, responseText } = request;
+            if (status >= 200 && status < 300) {
+              resolve(parseResponseBody(responseText));
+              return;
+            }
+            reject(new UploadHttpError(status, `Upload of "${file.name}" failed with status ${status}.`, responseText));
+          });
+        });
+        request.addEventListener("error", () => {
+          settle(() => reject(new UploadHttpError(0, `Upload of "${file.name}" failed: network error.`)));
+        });
+        request.addEventListener("timeout", () => {
+          settle(() => reject(new UploadHttpError(0, `Upload of "${file.name}" timed out.`)));
+        });
+        request.addEventListener("abort", () => {
+          settle(() => reject(createAbortError()));
+        });
+        signal.addEventListener("abort", onAbort, { once: true });
+        request.send(body);
+      });
+    }
+  };
+}
+const DefaultUploadConcurrency = 3;
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+function createUploadQueue(options) {
+  const { transport, accept, maxSize } = options;
+  const concurrency = Math.max(1, Math.floor(options.concurrency ?? DefaultUploadConcurrency));
+  const retryPolicy = options.retry ?? DefaultRetryPolicy;
+  const entries = /* @__PURE__ */ new Map();
+  const controllers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let revision = 0;
+  let pumping = false;
+  function notify() {
+    revision += 1;
+    for (const listener of [...listeners]) listener();
+  }
+  function patch(id, changes) {
+    const current = entries.get(id);
+    if (current === void 0) return;
+    entries.set(id, { ...current, ...changes });
+    notify();
+  }
+  function describeFileType(file) {
+    if (file.type !== "") return file.type;
+    const extension = fileExtension(file.name);
+    return extension === "" ? "of an unknown type" : `a ".${extension}" file`;
+  }
+  function validate(file) {
+    if (accept !== void 0 && !matchesAccept(file, accept)) return UploadRejectionReason.Type;
+    if (maxSize !== void 0 && file.size > maxSize) return UploadRejectionReason.Size;
+    return void 0;
+  }
+  function rejectionError(file, reason) {
+    const name = safeFileName(file.name);
+    if (reason === UploadRejectionReason.Size) {
+      return new Error(`"${name}" is ${formatBytes(file.size)}, over the ${formatBytes(maxSize ?? 0)} limit.`);
+    }
+    return new Error(`"${name}" is ${describeFileType(file)}, which does not match "${accept ?? ""}".`);
+  }
+  function recordProgress(id, loaded, total) {
+    const current = entries.get(id);
+    if (current === void 0 || current.status !== UploadStatus.Uploading) return;
+    const size = current.file.size;
+    const denominator = total !== void 0 && total > 0 ? total : size;
+    const fraction = denominator > 0 ? Math.min(1, Math.max(0, loaded / denominator)) : 0;
+    const bytesUploaded = Math.round(fraction * size);
+    if (fraction === current.progress && bytesUploaded === current.bytesUploaded) return;
+    patch(id, { progress: fraction, bytesUploaded });
+  }
+  async function runItem(id) {
+    const initial = entries.get(id);
+    if (initial === void 0) return;
+    const baseAttempt = initial.attempt;
+    const controller = new AbortController();
+    controllers.set(id, controller);
+    let retries = 0;
+    let previousDelayMs = 0;
+    try {
+      for (; ; ) {
+        const current = entries.get(id);
+        if (current === void 0) return;
+        patch(id, {
+          status: UploadStatus.Uploading,
+          attempt: baseAttempt + retries + 1,
+          progress: 0,
+          bytesUploaded: 0,
+          error: void 0
+        });
+        try {
+          const result = await transport.upload(current.file, {
+            signal: controller.signal,
+            onProgress: (loaded, total) => recordProgress(id, loaded, total)
+          });
+          if (controller.signal.aborted) {
+            patch(id, { status: UploadStatus.Cancelled });
+            return;
+          }
+          patch(id, {
+            status: UploadStatus.Succeeded,
+            progress: 1,
+            bytesUploaded: current.file.size,
+            result
+          });
+          return;
+        } catch (caught) {
+          if (isAbortError(caught) || controller.signal.aborted) {
+            patch(id, { status: UploadStatus.Cancelled });
+            return;
+          }
+          const status = readUploadErrorStatus(caught);
+          if (retryPolicy !== false && shouldRetry(retryPolicy, retries, status)) {
+            const attemptNumber = retries + 1;
+            const delayMs = computeRetryDelay(retryPolicy, attemptNumber, previousDelayMs);
+            retryPolicy.onRetry?.({ attempt: attemptNumber, error: caught, status, delayMs });
+            await sleep(delayMs, controller.signal);
+            if (controller.signal.aborted) {
+              patch(id, { status: UploadStatus.Cancelled });
+              return;
+            }
+            previousDelayMs = delayMs;
+            retries = attemptNumber;
+            continue;
+          }
+          patch(id, { status: UploadStatus.Failed, error: toError(caught) });
+          return;
+        }
+      }
+    } finally {
+      controllers.delete(id);
+      pump();
+    }
+  }
+  function pump() {
+    if (pumping) return;
+    pumping = true;
+    try {
+      while (controllers.size < concurrency) {
+        let next;
+        for (const item of entries.values()) {
+          if (item.status === UploadStatus.Queued) {
+            next = item;
+            break;
+          }
+        }
+        if (next === void 0) return;
+        void runItem(next.id);
+      }
+    } finally {
+      pumping = false;
+    }
+  }
+  function createItem(file) {
+    const id = Guid.createV7();
+    const rejection = validate(file);
+    if (rejection !== void 0) {
+      return {
+        id,
+        file,
+        status: UploadStatus.Failed,
+        progress: 0,
+        bytesUploaded: 0,
+        attempt: 0,
+        rejection,
+        error: rejectionError(file, rejection)
+      };
+    }
+    return { id, file, status: UploadStatus.Queued, progress: 0, bytesUploaded: 0, attempt: 0 };
+  }
+  function cancel(id) {
+    const item = entries.get(id);
+    if (item === void 0 || isUploadTerminal(item.status)) return false;
+    const controller = controllers.get(id);
+    if (controller !== void 0) {
+      controller.abort();
+      return true;
+    }
+    patch(id, { status: UploadStatus.Cancelled });
+    pump();
+    return true;
+  }
+  function cancelAll() {
+    for (const item of [...entries.values()]) {
+      if (!isUploadTerminal(item.status)) cancel(item.id);
+    }
+  }
+  return {
+    add(input) {
+      const files = input instanceof File ? [input] : input;
+      const created = files.map(createItem);
+      for (const item of created) entries.set(item.id, item);
+      notify();
+      pump();
+      return created.map((item) => item.id);
+    },
+    cancel,
+    cancelAll,
+    retry(id) {
+      const item = entries.get(id);
+      if (item === void 0 || item.rejection !== void 0) return false;
+      if (item.status !== UploadStatus.Failed && item.status !== UploadStatus.Cancelled) return false;
+      patch(id, {
+        status: UploadStatus.Queued,
+        progress: 0,
+        bytesUploaded: 0,
+        error: void 0,
+        result: void 0
+      });
+      pump();
+      return true;
+    },
+    remove(id) {
+      if (!entries.has(id)) return false;
+      controllers.get(id)?.abort();
+      controllers.delete(id);
+      entries.delete(id);
+      notify();
+      pump();
+      return true;
+    },
+    clear() {
+      cancelAll();
+      entries.clear();
+      controllers.clear();
+      notify();
+    },
+    items() {
+      return [...entries.values()];
+    },
+    get(id) {
+      return entries.get(id);
+    },
+    state() {
+      const counts = {
+        [UploadStatus.Queued]: 0,
+        [UploadStatus.Uploading]: 0,
+        [UploadStatus.Succeeded]: 0,
+        [UploadStatus.Failed]: 0,
+        [UploadStatus.Cancelled]: 0
+      };
+      let bytesUploaded = 0;
+      let totalBytes = 0;
+      for (const item of entries.values()) {
+        counts[item.status] += 1;
+        if (item.status === UploadStatus.Cancelled || item.rejection !== void 0) continue;
+        bytesUploaded += item.bytesUploaded;
+        totalBytes += item.file.size;
+      }
+      return {
+        total: entries.size,
+        counts,
+        bytesUploaded,
+        totalBytes,
+        progress: totalBytes > 0 ? Math.min(1, bytesUploaded / totalBytes) : 0,
+        isUploading: counts[UploadStatus.Queued] > 0 || counts[UploadStatus.Uploading] > 0
+      };
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    version() {
+      return revision;
+    }
+  };
+}
+function useUploadQueueVersion(queue) {
+  const version = shallowRef(queue.version());
+  let unsubscribe;
+  onMounted(() => {
+    version.value = queue.version();
+    unsubscribe = queue.subscribe(() => {
+      version.value = queue.version();
+    });
+  });
+  onScopeDispose(() => {
+    unsubscribe?.();
+    unsubscribe = void 0;
+  });
+  return version;
+}
+function useUploadQueueSnapshot(queue) {
+  const version = useUploadQueueVersion(queue);
+  return {
+    items: computed(() => {
+      void version.value;
+      return queue.items();
+    }),
+    state: computed(() => {
+      void version.value;
+      return queue.state();
+    })
+  };
+}
+function useUploadQueue(options) {
+  const queue = createUploadQueue({
+    ...toValue(options),
+    // Delegated, not captured: the current transport handles every attempt.
+    transport: { upload: (file, context) => toValue(options).transport.upload(file, context) }
+  });
+  const { items, state } = useUploadQueueSnapshot(queue);
+  return {
+    queue,
+    items,
+    state,
+    add: queue.add,
+    cancel: queue.cancel,
+    cancelAll: queue.cancelAll,
+    retry: queue.retry,
+    remove: queue.remove,
+    clear: queue.clear
+  };
+}
+export {
+  DefaultUploadConcurrency,
+  UploadHttpError,
+  UploadRejectionReason,
+  UploadStatus,
+  createUploadQueue,
+  isUploadActive,
+  isUploadTerminal,
+  readUploadErrorStatus,
+  useUploadQueue,
+  useUploadQueueSnapshot,
+  useUploadQueueVersion,
+  xhrUploadTransport
+};
+//# sourceMappingURL=index.js.map