@useupup/core 3.3.0

package/dist/steps/hash.js

@@ -0,0 +1,42 @@
+// src/steps/hash.ts
+async function computeSHA256(buffer) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hashStep() {
+  return {
+    name: "hash",
+    async process(file, context) {
+      if (context.worker) {
+        try {
+          const result = await context.worker.execute({
+            type: "hash",
+            data: await file.arrayBuffer()
+          });
+          if (result.kind === "hash") {
+            file.metadata = {
+              ...file.metadata,
+              checksum: result.checksum,
+              originalContentHash: result.checksum
+            };
+            return Object.assign(file, {
+              checksumSHA256: result.checksum
+            });
+          }
+        } catch {
+        }
+      }
+      const buffer = await file.arrayBuffer();
+      const hash = await computeSHA256(buffer);
+      file.metadata = {
+        ...file.metadata,
+        checksum: hash,
+        originalContentHash: hash
+      };
+      return Object.assign(file, { checksumSHA256: hash });
+    }
+  };
+}
+
+export { hashStep };

package/dist/steps/heic.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var chunkE3ZCNOXG_cjs = require('../chunk-E3ZCNOXG.cjs');
+var chunkBSGQGINR_cjs = require('../chunk-BSGQGINR.cjs');
+require('../chunk-QK7HZIVY.cjs');
+
+// src/steps/heic.ts
+function jpegName(name) {
+  if (/\.(heic|heif)$/i.test(name))
+    return name.replace(/\.(heic|heif)$/i, ".jpg");
+  return `${name}.jpg`;
+}
+function heicStep() {
+  return {
+    name: "heic",
+    shouldProcess: (file) => file.type === "image/heic" || file.type === "image/heif" || /\.(heic|heif)$/i.test(file.name),
+    async process(file, context) {
+      if (context.worker) {
+        try {
+          const result = await context.worker.execute({
+            type: "heic",
+            data: await file.arrayBuffer(),
+            params: { mime: file.type, name: file.name }
+          });
+          if (result.kind === "image")
+            return chunkBSGQGINR_cjs.uploadFileFromImageResult(file, result);
+        } catch {
+        }
+      }
+      try {
+        const blob = await chunkE3ZCNOXG_cjs.heicToJpegBlob(file, { quality: 0.92 });
+        if (!blob) return file;
+        const converted = new File([blob], jpegName(file.name), {
+          type: "image/jpeg",
+          lastModified: file.lastModified
+        });
+        return chunkBSGQGINR_cjs.cloneUploadFile(file, converted, {
+          originalSize: file.size,
+          processedSize: converted.size,
+          heicConverted: true
+        });
+      } catch (err) {
+        context.emit("pipeline-error", {
+          scope: "heic",
+          name: file.name,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        console.error(
+          "[upup] HEIC conversion failed for",
+          file.name,
+          err
+        );
+        return file;
+      }
+    }
+  };
+}
+
+exports.heicStep = heicStep;

package/dist/steps/heic.d.cts

@@ -0,0 +1,5 @@
+import { P as PipelineStep } from '../contracts-pipeline-cf177270.cjs';
+
+declare function heicStep(): PipelineStep;
+
+export { heicStep };

package/dist/steps/heic.d.ts

@@ -0,0 +1,5 @@
+import { P as PipelineStep } from '../contracts-pipeline-cf177270.js';
+
+declare function heicStep(): PipelineStep;
+
+export { heicStep };

package/dist/steps/heic.js

@@ -0,0 +1,57 @@
+import { heicToJpegBlob } from '../chunk-I7ULPCA2.js';
+import { uploadFileFromImageResult, cloneUploadFile } from '../chunk-6S5DQDQH.js';
+import '../chunk-GE4LIVXP.js';
+
+// src/steps/heic.ts
+function jpegName(name) {
+  if (/\.(heic|heif)$/i.test(name))
+    return name.replace(/\.(heic|heif)$/i, ".jpg");
+  return `${name}.jpg`;
+}
+function heicStep() {
+  return {
+    name: "heic",
+    shouldProcess: (file) => file.type === "image/heic" || file.type === "image/heif" || /\.(heic|heif)$/i.test(file.name),
+    async process(file, context) {
+      if (context.worker) {
+        try {
+          const result = await context.worker.execute({
+            type: "heic",
+            data: await file.arrayBuffer(),
+            params: { mime: file.type, name: file.name }
+          });
+          if (result.kind === "image")
+            return uploadFileFromImageResult(file, result);
+        } catch {
+        }
+      }
+      try {
+        const blob = await heicToJpegBlob(file, { quality: 0.92 });
+        if (!blob) return file;
+        const converted = new File([blob], jpegName(file.name), {
+          type: "image/jpeg",
+          lastModified: file.lastModified
+        });
+        return cloneUploadFile(file, converted, {
+          originalSize: file.size,
+          processedSize: converted.size,
+          heicConverted: true
+        });
+      } catch (err) {
+        context.emit("pipeline-error", {
+          scope: "heic",
+          name: file.name,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        console.error(
+          "[upup] HEIC conversion failed for",
+          file.name,
+          err
+        );
+        return file;
+      }
+    }
+  };
+}
+
+export { heicStep };

package/dist/steps/thumbnail.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var chunkBSGQGINR_cjs = require('../chunk-BSGQGINR.cjs');
+require('../chunk-QK7HZIVY.cjs');
+
+// src/steps/thumbnail.ts
+function thumbnailStep(_options) {
+  return {
+    name: "thumbnail",
+    shouldProcess: (file) => file.type.startsWith("image/"),
+    async process(file, context) {
+      if (!file.type.startsWith("image/")) return file;
+      if (context.worker) {
+        try {
+          const result = await context.worker.execute({
+            type: "thumbnail",
+            data: await file.arrayBuffer(),
+            params: {
+              mime: file.type,
+              name: file.name,
+              maxWidthOrHeight: _options?.width,
+              quality: _options?.quality
+            }
+          });
+          if (result.kind === "thumbnail") {
+            file.metadata = {
+              ...file.metadata,
+              thumbnailUrl: result.thumbnailUrl
+            };
+            file.thumbnail = {
+              file: new File([result.bytes], result.name, {
+                type: result.type,
+                lastModified: file.lastModified
+              })
+            };
+            return file;
+          }
+        } catch {
+        }
+      }
+      const thumbnail = await chunkBSGQGINR_cjs.createThumbnail(file, _options);
+      if (!thumbnail) return file;
+      file.metadata = {
+        ...file.metadata,
+        thumbnailUrl: thumbnail.dataUrl
+      };
+      const fileRecord = file;
+      fileRecord.thumbnail = { file: thumbnail.file };
+      return file;
+    }
+  };
+}
+
+exports.thumbnailStep = thumbnailStep;

package/dist/steps/thumbnail.d.cts

@@ -0,0 +1,10 @@
+import { P as PipelineStep } from '../contracts-pipeline-cf177270.cjs';
+
+interface ThumbnailGeneratorOptions {
+    width?: number;
+    height?: number;
+    quality?: number;
+}
+declare function thumbnailStep(_options?: ThumbnailGeneratorOptions): PipelineStep;
+
+export { type ThumbnailGeneratorOptions, thumbnailStep };

package/dist/steps/thumbnail.d.ts

@@ -0,0 +1,10 @@
+import { P as PipelineStep } from '../contracts-pipeline-cf177270.js';
+
+interface ThumbnailGeneratorOptions {
+    width?: number;
+    height?: number;
+    quality?: number;
+}
+declare function thumbnailStep(_options?: ThumbnailGeneratorOptions): PipelineStep;
+
+export { type ThumbnailGeneratorOptions, thumbnailStep };

package/dist/steps/thumbnail.js

@@ -0,0 +1,52 @@
+import { createThumbnail } from '../chunk-6S5DQDQH.js';
+import '../chunk-GE4LIVXP.js';
+
+// src/steps/thumbnail.ts
+function thumbnailStep(_options) {
+  return {
+    name: "thumbnail",
+    shouldProcess: (file) => file.type.startsWith("image/"),
+    async process(file, context) {
+      if (!file.type.startsWith("image/")) return file;
+      if (context.worker) {
+        try {
+          const result = await context.worker.execute({
+            type: "thumbnail",
+            data: await file.arrayBuffer(),
+            params: {
+              mime: file.type,
+              name: file.name,
+              maxWidthOrHeight: _options?.width,
+              quality: _options?.quality
+            }
+          });
+          if (result.kind === "thumbnail") {
+            file.metadata = {
+              ...file.metadata,
+              thumbnailUrl: result.thumbnailUrl
+            };
+            file.thumbnail = {
+              file: new File([result.bytes], result.name, {
+                type: result.type,
+                lastModified: file.lastModified
+              })
+            };
+            return file;
+          }
+        } catch {
+        }
+      }
+      const thumbnail = await createThumbnail(file, _options);
+      if (!thumbnail) return file;
+      file.metadata = {
+        ...file.metadata,
+        thumbnailUrl: thumbnail.dataUrl
+      };
+      const fileRecord = file;
+      fileRecord.thumbnail = { file: thumbnail.file };
+      return file;
+    }
+  };
+}
+
+export { thumbnailStep };

package/dist/strategies/index.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+var chunkDTKDIMKT_cjs = require('../chunk-DTKDIMKT.cjs');
+var chunkCPKZ2CXD_cjs = require('../chunk-CPKZ2CXD.cjs');
+var chunkBMQC27OE_cjs = require('../chunk-BMQC27OE.cjs');
+require('../chunk-N2SLHVAW.cjs');
+var chunkQK7HZIVY_cjs = require('../chunk-QK7HZIVY.cjs');
+require('../chunk-DYE5XJ6Z.cjs');
+require('../chunk-U7KL5M2H.cjs');
+
+// 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 = chunkQK7HZIVY_cjs.uploadErrorFromResponse({
+        status: response.status,
+        statusText: response.statusText,
+        body,
+        kind: "network"
+      });
+      throw err;
+    }
+    return response.json();
+  }
+};
+
+Object.defineProperty(exports, 'MultipartUpload', {
+  enumerable: true,
+  get: function () { return chunkDTKDIMKT_cjs.MultipartUpload; }
+});
+Object.defineProperty(exports, 'ServerCredentials', {
+  enumerable: true,
+  get: function () { return chunkDTKDIMKT_cjs.ServerCredentials; }
+});
+Object.defineProperty(exports, 'DirectUpload', {
+  enumerable: true,
+  get: function () { return chunkCPKZ2CXD_cjs.DirectUpload; }
+});
+Object.defineProperty(exports, 'TokenEndpointCredentials', {
+  enumerable: true,
+  get: function () { return chunkCPKZ2CXD_cjs.TokenEndpointCredentials; }
+});
+Object.defineProperty(exports, 'TusUpload', {
+  enumerable: true,
+  get: function () { return chunkBMQC27OE_cjs.TusUpload; }
+});
+exports.ServerTransfer = ServerTransfer;

package/dist/strategies/index.d.cts

@@ -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.cjs';
+export { i as ProgressInfo, m as RuntimeAdapter } from '../contracts-strategies-378a16b7.cjs';
+export { D as DirectUpload, T as TokenEndpointCredentials } from '../token-endpoint-a7d15ab6.cjs';
+export { TusUpload } from './tus-upload.cjs';
+
+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 };