@useupup/core 3.3.0

package/dist/strategies/index.d.ts

@@ -0,0 +1,187 @@
+import { k as CredentialStrategy, F as FileMetadata, P as PresignedUrlResponse, a as MultipartInitResponse, b as MultipartSignPartResponse, f as MultipartCompleteResponse, e as MultipartResumeResponse, l as UploadStrategy, U as UploadCredentials, h as UploadResult, j as CloudProvider } from '../contracts-strategies-378a16b7.js';
+export { i as ProgressInfo, m as RuntimeAdapter } from '../contracts-strategies-378a16b7.js';
+export { D as DirectUpload, T as TokenEndpointCredentials } from '../token-endpoint-5fdb4a35.js';
+export { TusUpload } from './tus-upload.js';
+
+interface ServerCredentialsOptions {
+    serverUrl: string;
+    headers?: Record<string, string>;
+}
+declare class ServerCredentials implements CredentialStrategy {
+    private serverUrl;
+    private headers;
+    constructor(options: ServerCredentialsOptions);
+    private post;
+    getPresignedUrl(file: FileMetadata): Promise<PresignedUrlResponse>;
+    initMultipartUpload(file: FileMetadata): Promise<MultipartInitResponse>;
+    signPart(params: {
+        token: string;
+        partNumber: number;
+    }): Promise<MultipartSignPartResponse>;
+    completeMultipartUpload(params: {
+        token: string;
+        parts: {
+            partNumber: number;
+            eTag: string;
+        }[];
+    }): Promise<MultipartCompleteResponse>;
+    abortMultipartUpload(params: {
+        token: string;
+    }): Promise<void>;
+    /** Re-attach to an upload the client left in flight (page reload, pause,
+     *  retry) or whose token aged past its 1h TTL. The presented token is the
+     *  ONLY input — key/uploadId are never sent by the client — and the
+     *  response carries a freshly-signed replacement plus the parts storage
+     *  already holds, each with its byte size. */
+    resumeMultipartUpload(params: {
+        token: string;
+    }): Promise<MultipartResumeResponse>;
+}
+
+interface MultipartUploadOptions {
+    credentials: CredentialStrategy;
+    chunkSizeBytes?: number | undefined;
+    /**
+     * Parts of this one file in flight at once. Throughput on a fast link
+     * against memory and socket pressure — every in-flight part holds its own
+     * chunk. Clamped to a whole number ≥ 1 — the cap is a count of live
+     * requests, and a run with none in flight can never finish.
+     */
+    maxConcurrentParts?: number | undefined;
+    /**
+     * Persist a resumable session (localStorage) for `File` inputs, so a page
+     * reload, a pause, or a retry re-attaches to the server-side upload rather
+     * than restarting it from part 1.
+     *
+     * Defaults to FALSE here on purpose: `resolveUploadConfig` is the single
+     * place that opts the product default in (`resumable.persist ?? true`), so
+     * a hand-constructed strategy keeps the historical abort-on-failure
+     * semantics until it explicitly asks for persistence.
+     */
+    persist?: boolean | undefined;
+    /**
+     * The serverUrl sessions belong to. A session saved against server A must
+     * never be resumed against server B — its token means nothing there.
+     */
+    sessionScope?: string | undefined;
+    /**
+     * Delays (ms) before each successive retry of a part whose attempt failed
+     * transiently — a network-level fetch rejection, a 429, a 5xx, or a stall
+     * caught by `partTimeoutMs`. Same vocabulary as the tus strategy's
+     * `retryDelays`: the array length is the retry budget, `[]` disables part
+     * retries. Definitive 4xx rejections are never retried.
+     */
+    retryDelays?: number[] | undefined;
+    /**
+     * Watchdog budget applied to each PHASE of a part attempt separately: the
+     * sign call, the source read (parts small enough to be materialized —
+     * see MATERIALIZE_PART_MAX_BYTES), and the PUT, where it is an INACTIVITY
+     * window reset by upload progress. A phase that neither succeeds nor
+     * fails within its window is aborted and counted as a transient failure,
+     * so a hung connection or a hung blob read costs one `retryDelays` slot
+     * instead of hanging the whole upload forever (worst case per attempt is
+     * therefore up to 3 × this value, not 1 ×). A slow-but-progressing PUT is
+     * never aborted — only one with no forward motion at all.
+     */
+    partTimeoutMs?: number | undefined;
+}
+declare class MultipartUpload implements UploadStrategy {
+    private credentials;
+    private initMultipartUpload;
+    private signPart;
+    private completeMultipartUpload;
+    private resumeMultipartUpload;
+    private chunkSizeBytes;
+    private maxConcurrentParts;
+    private persist;
+    private sessionScope;
+    private retryDelays;
+    private partTimeoutMs;
+    constructor(options: MultipartUploadOptions);
+    /**
+     * Each stored part must be byte-for-byte where this file's own chunking
+     * would put it: exactly `partSize`, except the file's TRUE final part
+     * (`partNumber === totalParts`), which must be exactly the remaining tail.
+     *
+     * The "highest part number we happen to hold" is NOT the exemption — the
+     * server may hold a sparse prefix (say parts 1, 2, 5 of 10), and letting
+     * part 5 be short would splice a short block into the MIDDLE of the object.
+     * S3 only enforces the ≥5 MiB floor on non-final parts, so it would accept
+     * the complete call and hand back a silently corrupt object. A part with no
+     * reported `size` is unverifiable and therefore equally unusable.
+     */
+    private partsMatchSession;
+    /**
+     * Try to re-attach to the upload a previous session left in flight.
+     * Returns `null` for every "just start fresh" outcome — a resume failure
+     * must never fail an upload that a fresh init could still serve.
+     */
+    private tryResume;
+    /**
+     * Failure teardown. THE behavior change of cross-reload resume: with
+     * `persist` on, an error or abort deliberately leaves the server-side
+     * upload alive so the next attempt can resume into it — pause(), a dropped
+     * connection, and UploadManager's own retries all re-enter `upload()` and
+     * pick the session back up. Without persist this is exactly the historical
+     * best-effort abort. Either way, a 4xx from init/complete kills the
+     * session: the server has already torn the upload down.
+     */
+    private handleUploadFailure;
+    /**
+     * PUT one signed part over XMLHttpRequest, under an INACTIVITY watchdog.
+     *
+     * The watchdog resets on every `upload` progress event and fires only after
+     * `partTimeoutMs` with no forward motion at all. That distinction is the
+     * point: `fetch()` for a PUT resolves only once the whole body is sent, so a
+     * flat ceiling on total time aborts a large part on a slow-but-healthy link
+     * (a 5 MiB part under ~233 kbit/s crosses the 180s default) even though it
+     * is uploading fine. An inactivity timer kills the connection the watchdog
+     * was built for — one that has genuinely stopped moving bytes — without
+     * penalizing the slow one. Mirrors the XHR PUT in direct-upload.ts.
+     *
+     * Resolves with the part's ETag. Rejects with: the retryable stall on
+     * inactivity (`partStallError`) — covering both the slice READ and the PUT;
+     * a retryable `UPLOAD_FAILED` when the slice read itself rejects;
+     * `UpupNetworkError('Upload aborted')` when
+     * the caller's signal aborts; a retryable `TypeError` on a network-level
+     * failure (the shape `fetch` produced, which `isRetryablePartFailure`
+     * already classifies); or an `uploadErrorFromResponse` on a non-2xx — its
+     * body read synchronously from `xhr.responseText`, so the whole request
+     * including the error body stays inside the one abort/inactivity window (the
+     * old `await response.text()` ran AFTER the watchdog was cleared and could
+     * hang a half-dead connection forever on the body read).
+     */
+    private putPart;
+    upload(file: File | Blob, _credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+
+interface ServerTransferOptions {
+    serverUrl: string;
+    headers?: Record<string, string>;
+}
+interface TransferResult {
+    provider: string;
+    fileId: string;
+    status: string;
+    key?: string;
+    url?: string;
+}
+/**
+ * Strategy that POSTs to the server's /files/:provider/transfer endpoint
+ * to transfer a file from a cloud drive directly to S3 on the server side.
+ */
+declare class ServerTransfer {
+    private serverUrl;
+    private headers;
+    constructor(options: ServerTransferOptions);
+    private providerSlug;
+    transfer(provider: CloudProvider, fileId: string, options?: {
+        token?: string;
+        fileName?: string;
+    }): Promise<TransferResult>;
+}
+
+export { CloudProvider, CredentialStrategy, FileMetadata, MultipartUpload, ServerCredentials, ServerTransfer, UploadCredentials, UploadResult, UploadStrategy };

package/dist/strategies/index.js

@@ -0,0 +1,60 @@
+export { MultipartUpload, ServerCredentials } from '../chunk-MHYXDLZR.js';
+export { DirectUpload, TokenEndpointCredentials } from '../chunk-OOPDEOTM.js';
+export { TusUpload } from '../chunk-TRCP5FUR.js';
+import '../chunk-ZMS2HXLB.js';
+import { uploadErrorFromResponse } from '../chunk-GE4LIVXP.js';
+import '../chunk-UXNPM54W.js';
+import '../chunk-VV6QCQLL.js';
+
+// src/strategies/server-transfer.ts
+var ServerTransfer = class {
+  constructor(options) {
+    this.serverUrl = options.serverUrl.replace(/\/$/, "");
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+  }
+  providerSlug(provider) {
+    switch (provider) {
+      case "googleDrive":
+        return "google-drive";
+      case "oneDrive":
+        return "one-drive";
+      case "dropbox":
+        return "dropbox";
+      case "box":
+        return "box";
+      default:
+        return provider;
+    }
+  }
+  async transfer(provider, fileId, options) {
+    const slug = this.providerSlug(provider);
+    const response = await fetch(
+      `${this.serverUrl}/files/${slug}/transfer`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({
+          fileId,
+          fileName: options?.fileName,
+          token: options?.token
+        })
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      const err = uploadErrorFromResponse({
+        status: response.status,
+        statusText: response.statusText,
+        body,
+        kind: "network"
+      });
+      throw err;
+    }
+    return response.json();
+  }
+};
+
+export { ServerTransfer };

package/dist/strategies/tus-upload.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var chunkBMQC27OE_cjs = require('../chunk-BMQC27OE.cjs');
+require('../chunk-N2SLHVAW.cjs');
+require('../chunk-QK7HZIVY.cjs');
+require('../chunk-DYE5XJ6Z.cjs');
+require('../chunk-U7KL5M2H.cjs');
+
+
+
+Object.defineProperty(exports, 'TusUpload', {
+  enumerable: true,
+  get: function () { return chunkBMQC27OE_cjs.TusUpload; }
+});

package/dist/strategies/tus-upload.d.cts

@@ -0,0 +1,15 @@
+import { l as UploadStrategy, U as UploadCredentials, h as UploadResult, R as ResumableUploadOptions } from '../contracts-strategies-378a16b7.cjs';
+
+type TusOptions = Extract<ResumableUploadOptions, {
+    protocol: 'tus';
+}>;
+declare class TusUpload implements UploadStrategy {
+    private options;
+    constructor(options: TusOptions);
+    upload(file: File | Blob, _credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+
+export { TusUpload };

package/dist/strategies/tus-upload.d.ts

@@ -0,0 +1,15 @@
+import { l as UploadStrategy, U as UploadCredentials, h as UploadResult, R as ResumableUploadOptions } from '../contracts-strategies-378a16b7.js';
+
+type TusOptions = Extract<ResumableUploadOptions, {
+    protocol: 'tus';
+}>;
+declare class TusUpload implements UploadStrategy {
+    private options;
+    constructor(options: TusOptions);
+    upload(file: File | Blob, _credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+
+export { TusUpload };

package/dist/strategies/tus-upload.js

@@ -0,0 +1,5 @@
+export { TusUpload } from '../chunk-TRCP5FUR.js';
+import '../chunk-ZMS2HXLB.js';
+import '../chunk-GE4LIVXP.js';
+import '../chunk-UXNPM54W.js';
+import '../chunk-VV6QCQLL.js';

package/dist/theme/index.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var chunkU7KL5M2H_cjs = require('../chunk-U7KL5M2H.cjs');
+
+
+
+Object.defineProperty(exports, 'ThemeStore', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.ThemeStore; }
+});
+Object.defineProperty(exports, 'UPUP_VAR_PREFIX', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.UPUP_VAR_PREFIX; }
+});
+Object.defineProperty(exports, 'darkPreset', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.darkPreset; }
+});
+Object.defineProperty(exports, 'flattenSlotsToClassNames', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.flattenSlotsToClassNames; }
+});
+Object.defineProperty(exports, 'lightPreset', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.lightPreset; }
+});
+Object.defineProperty(exports, 'resolveTheme', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.resolveTheme; }
+});
+Object.defineProperty(exports, 'tokensToVarRefs', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.tokensToVarRefs; }
+});
+Object.defineProperty(exports, 'tokensToVars', {
+  enumerable: true,
+  get: function () { return chunkU7KL5M2H_cjs.tokensToVars; }
+});

package/dist/theme/index.d.cts

@@ -0,0 +1,3 @@
+export { D as DeepPartial, l as DeepPartialSlots, I as InternalFlatClassNames, h as UPUP_VAR_PREFIX, U as UpupColorTokens, a as UpupRadiusTokens, g as UpupResolvedTheme, b as UpupShadowTokens, k as UpupSlotPath, c as UpupSpacingTokens, f as UpupThemeConfig, e as UpupThemeMode, j as UpupThemeSlots, d as UpupThemeTokens, m as flattenSlotsToClassNames, i as tokensToVarRefs, t as tokensToVars } from '../vars-d3421f6c.cjs';
+export { d as darkPreset, l as lightPreset, r as resolveTheme } from '../resolve-theme-66cf8d98.cjs';
+export { a as ThemeStore, T as ThemeStoreState } from '../theme-store-2e56a674.cjs';

package/dist/theme/index.d.ts

@@ -0,0 +1,3 @@
+export { D as DeepPartial, l as DeepPartialSlots, I as InternalFlatClassNames, h as UPUP_VAR_PREFIX, U as UpupColorTokens, a as UpupRadiusTokens, g as UpupResolvedTheme, b as UpupShadowTokens, k as UpupSlotPath, c as UpupSpacingTokens, f as UpupThemeConfig, e as UpupThemeMode, j as UpupThemeSlots, d as UpupThemeTokens, m as flattenSlotsToClassNames, i as tokensToVarRefs, t as tokensToVars } from '../vars-d3421f6c.js';
+export { d as darkPreset, l as lightPreset, r as resolveTheme } from '../resolve-theme-01758105.js';
+export { a as ThemeStore, T as ThemeStoreState } from '../theme-store-f13e0315.js';

package/dist/theme/index.js

@@ -0,0 +1 @@
+export { ThemeStore, UPUP_VAR_PREFIX, darkPreset, flattenSlotsToClassNames, lightPreset, resolveTheme, tokensToVarRefs, tokensToVars } from '../chunk-VV6QCQLL.js';

package/dist/theme-store-2e56a674.d.cts

@@ -0,0 +1,39 @@
+import { d as UpupThemeTokens, I as InternalFlatClassNames, l as DeepPartialSlots, f as UpupThemeConfig, g as UpupResolvedTheme } from './vars-d3421f6c.cjs';
+
+type ResolvedLightDark = Omit<UpupResolvedTheme, 'mode'> & {
+    mode: 'light' | 'dark';
+};
+interface ThemeStoreState {
+    themeMode: 'light' | 'dark';
+    isDark: boolean;
+    tokens: UpupThemeTokens;
+    resolved: ResolvedLightDark;
+    slotOverrides: InternalFlatClassNames;
+    slots: DeepPartialSlots;
+}
+/**
+ * Framework-agnostic theme store. Owns the `system` matchMedia subscription and
+ * the resolution of a tri-state theme mode ('light' | 'dark' | 'system') into a
+ * concrete 'light' | 'dark' + tokens/slots. Mirrors UploaderOrchestrator's
+ * subscribe/getSnapshot pattern. SSR-safe: init() no-ops without window.
+ */
+declare class ThemeStore {
+    private state;
+    private listeners;
+    private config?;
+    private systemMode;
+    private mediaCleanup;
+    constructor(config?: UpupThemeConfig);
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => ThemeStoreState;
+    /** Start the `system` matchMedia subscription (no-op for explicit modes / SSR). */
+    init(): void;
+    /** Re-resolve when the host's theme config prop changes. */
+    setThemeConfig(config?: UpupThemeConfig): void;
+    private compute;
+    private recompute;
+    private notify;
+    destroy(): void;
+}
+
+export { type ThemeStoreState as T, ThemeStore as a };

package/dist/theme-store-f13e0315.d.ts

@@ -0,0 +1,39 @@
+import { d as UpupThemeTokens, I as InternalFlatClassNames, l as DeepPartialSlots, f as UpupThemeConfig, g as UpupResolvedTheme } from './vars-d3421f6c.js';
+
+type ResolvedLightDark = Omit<UpupResolvedTheme, 'mode'> & {
+    mode: 'light' | 'dark';
+};
+interface ThemeStoreState {
+    themeMode: 'light' | 'dark';
+    isDark: boolean;
+    tokens: UpupThemeTokens;
+    resolved: ResolvedLightDark;
+    slotOverrides: InternalFlatClassNames;
+    slots: DeepPartialSlots;
+}
+/**
+ * Framework-agnostic theme store. Owns the `system` matchMedia subscription and
+ * the resolution of a tri-state theme mode ('light' | 'dark' | 'system') into a
+ * concrete 'light' | 'dark' + tokens/slots. Mirrors UploaderOrchestrator's
+ * subscribe/getSnapshot pattern. SSR-safe: init() no-ops without window.
+ */
+declare class ThemeStore {
+    private state;
+    private listeners;
+    private config?;
+    private systemMode;
+    private mediaCleanup;
+    constructor(config?: UpupThemeConfig);
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => ThemeStoreState;
+    /** Start the `system` matchMedia subscription (no-op for explicit modes / SSR). */
+    init(): void;
+    /** Re-resolve when the host's theme config prop changes. */
+    setThemeConfig(config?: UpupThemeConfig): void;
+    private compute;
+    private recompute;
+    private notify;
+    destroy(): void;
+}
+
+export { type ThemeStoreState as T, ThemeStore as a };

package/dist/token-endpoint-5fdb4a35.d.ts

@@ -0,0 +1,20 @@
+import { l as UploadStrategy, U as UploadCredentials, h as UploadResult, k as CredentialStrategy, F as FileMetadata, P as PresignedUrlResponse } from './contracts-strategies-378a16b7.js';
+
+declare class DirectUpload implements UploadStrategy {
+    upload(file: File | Blob, credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+
+declare class TokenEndpointCredentials implements CredentialStrategy {
+    private url;
+    private headers;
+    constructor(options: {
+        url: string;
+        headers?: Record<string, string>;
+    });
+    getPresignedUrl(file: FileMetadata): Promise<PresignedUrlResponse>;
+}
+
+export { DirectUpload as D, TokenEndpointCredentials as T };

package/dist/token-endpoint-a7d15ab6.d.cts

@@ -0,0 +1,20 @@
+import { l as UploadStrategy, U as UploadCredentials, h as UploadResult, k as CredentialStrategy, F as FileMetadata, P as PresignedUrlResponse } from './contracts-strategies-378a16b7.cjs';
+
+declare class DirectUpload implements UploadStrategy {
+    upload(file: File | Blob, credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+
+declare class TokenEndpointCredentials implements CredentialStrategy {
+    private url;
+    private headers;
+    constructor(options: {
+        url: string;
+        headers?: Record<string, string>;
+    });
+    getPresignedUrl(file: FileMetadata): Promise<PresignedUrlResponse>;
+}
+
+export { DirectUpload as D, TokenEndpointCredentials as T };