@useupup/core 3.3.0

package/dist/chunk-BSGQGINR.cjs

@@ -0,0 +1,219 @@
+'use strict';
+
+var chunkQK7HZIVY_cjs = require('./chunk-QK7HZIVY.cjs');
+
+// src/steps/image-utils.ts
+function hasDocument() {
+  return typeof document !== "undefined" && "createElement" in document;
+}
+function clampQuality(value, fallback) {
+  if (typeof value !== "number" || Number.isNaN(value)) return fallback;
+  return Math.min(1, Math.max(0.05, value));
+}
+function scaleDimensions(width, height, maxWidthOrHeight) {
+  if (!maxWidthOrHeight || maxWidthOrHeight <= 0) return { width, height };
+  const largest = Math.max(width, height);
+  if (largest <= maxWidthOrHeight) return { width, height };
+  const scale = maxWidthOrHeight / largest;
+  return {
+    width: Math.max(1, Math.round(width * scale)),
+    height: Math.max(1, Math.round(height * scale))
+  };
+}
+function outputTypeFor(file, requestedType) {
+  if (requestedType) return requestedType;
+  if (file.type === "image/png" || file.type === "image/webp")
+    return file.type;
+  return "image/jpeg";
+}
+function createCanvas(width, height) {
+  if (typeof OffscreenCanvas !== "undefined") {
+    return new OffscreenCanvas(width, height);
+  }
+  if (!hasDocument()) return null;
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  return canvas;
+}
+async function canvasToBlob(canvas, type, quality) {
+  if ("convertToBlob" in canvas && typeof canvas.convertToBlob === "function") {
+    return canvas.convertToBlob({ type, quality });
+  }
+  return new Promise((resolve) => {
+    canvas.toBlob(
+      (blob) => {
+        resolve(blob);
+      },
+      type,
+      quality
+    );
+  });
+}
+async function decodeImage(file) {
+  if (typeof createImageBitmap === "function") {
+    try {
+      const bitmap = await createImageBitmap(file);
+      return {
+        source: bitmap,
+        width: bitmap.width,
+        height: bitmap.height,
+        close: () => {
+          bitmap.close();
+        }
+      };
+    } catch {
+    }
+  }
+  if (!hasDocument()) return null;
+  return new Promise((resolve) => {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    const cleanup = () => {
+      URL.revokeObjectURL(url);
+    };
+    img.onload = () => {
+      cleanup();
+      resolve({
+        source: img,
+        width: img.naturalWidth || img.width,
+        height: img.naturalHeight || img.height
+      });
+    };
+    img.onerror = () => {
+      cleanup();
+      resolve(null);
+    };
+    img.src = url;
+  });
+}
+async function encodeImageFile(file, options = {}) {
+  const decoded = await decodeImage(file).catch(() => null);
+  if (!decoded) return null;
+  try {
+    const dimensions = scaleDimensions(
+      decoded.width,
+      decoded.height,
+      options.maxWidthOrHeight
+    );
+    const canvas = createCanvas(dimensions.width, dimensions.height);
+    const ctx = canvas?.getContext("2d");
+    if (!canvas || !ctx) return null;
+    ctx.drawImage(decoded.source, 0, 0, dimensions.width, dimensions.height);
+    const type = outputTypeFor(file, options.type);
+    const quality = clampQuality(options.quality, 0.82);
+    const blob = await canvasToBlob(canvas, type, quality);
+    if (!blob) return null;
+    const nextFile = new File([blob], file.name, {
+      type: blob.type || type || file.type,
+      lastModified: file.lastModified
+    });
+    return cloneUploadFile(file, nextFile, {
+      width: dimensions.width,
+      height: dimensions.height,
+      ...options.metadata
+    });
+  } finally {
+    decoded.close?.();
+  }
+}
+async function blobToDataUrl(blob) {
+  if (typeof FileReader !== "undefined") {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        const result = reader.result;
+        resolve(typeof result === "string" ? result : "");
+      };
+      reader.onerror = () => {
+        reject(reader.error ?? new Error("Failed to read blob"));
+      };
+      reader.readAsDataURL(blob);
+    });
+  }
+  const bytes = new Uint8Array(await blob.arrayBuffer());
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const encode = typeof btoa === "function" ? btoa : globalThis.Buffer ? (input) => globalThis.Buffer.from(input, "binary").toString("base64") : null;
+  if (!encode)
+    throw new chunkQK7HZIVY_cjs.UpupError(
+      "No base64 encoder available",
+      "BAD_REQUEST" /* BAD_REQUEST */
+    );
+  return `data:${blob.type || "application/octet-stream"};base64,${encode(binary)}`;
+}
+async function createThumbnail(file, options = {}) {
+  const decoded = await decodeImage(file).catch(() => null);
+  if (!decoded) return null;
+  try {
+    const maxWidth = options.width ?? 320;
+    const maxHeight = options.height ?? maxWidth;
+    const scale = Math.min(
+      1,
+      maxWidth / decoded.width,
+      maxHeight / decoded.height
+    );
+    const width = Math.max(1, Math.round(decoded.width * scale));
+    const height = Math.max(1, Math.round(decoded.height * scale));
+    const canvas = createCanvas(width, height);
+    const ctx = canvas?.getContext("2d");
+    if (!canvas || !ctx) return null;
+    ctx.drawImage(decoded.source, 0, 0, width, height);
+    const type = options.type ?? "image/jpeg";
+    const quality = clampQuality(options.quality, 0.75);
+    const blob = await canvasToBlob(canvas, type, quality);
+    if (!blob) return null;
+    const ext = type === "image/png" ? "png" : type === "image/webp" ? "webp" : "jpg";
+    const thumbnailFile = new File(
+      [blob],
+      `${file.name}.thumbnail.${ext}`,
+      {
+        type: blob.type || type,
+        lastModified: file.lastModified
+      }
+    );
+    return {
+      file: thumbnailFile,
+      dataUrl: await blobToDataUrl(blob),
+      width,
+      height
+    };
+  } finally {
+    decoded.close?.();
+  }
+}
+function cloneUploadFile(original, replacement, metadata = {}) {
+  return Object.assign(replacement, {
+    id: original.id,
+    source: original.source,
+    status: original.status,
+    metadata: {
+      ...original.metadata,
+      ...metadata
+    },
+    url: original.url,
+    relativePath: original.relativePath,
+    key: original.key,
+    etag: original.etag,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- v3 removal tracked
+    fileHash: original.fileHash,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- v3 removal tracked
+    checksumSHA256: original.checksumSHA256,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- v3 removal tracked
+    thumbnail: original.thumbnail
+  });
+}
+function uploadFileFromImageResult(original, result) {
+  const file = new File([result.bytes], result.name ?? original.name, {
+    type: result.type || original.type,
+    lastModified: original.lastModified
+  });
+  return cloneUploadFile(original, file, result.metadata ?? {});
+}
+
+exports.canvasToBlob = canvasToBlob;
+exports.cloneUploadFile = cloneUploadFile;
+exports.createCanvas = createCanvas;
+exports.createThumbnail = createThumbnail;
+exports.encodeImageFile = encodeImageFile;
+exports.uploadFileFromImageResult = uploadFileFromImageResult;

package/dist/chunk-CPKZ2CXD.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+var chunkQK7HZIVY_cjs = require('./chunk-QK7HZIVY.cjs');
+
+// src/strategies/token-endpoint.ts
+async function readErrorBody(response) {
+  try {
+    return await response.text();
+  } catch {
+    return void 0;
+  }
+}
+var TokenEndpointCredentials = class {
+  constructor(options) {
+    this.url = options.url;
+    this.headers = options.headers ?? {};
+  }
+  async getPresignedUrl(file) {
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify({
+        name: file.name,
+        size: file.size,
+        type: file.type,
+        metadata: file.metadata ?? {}
+      })
+    });
+    if (!response.ok) {
+      const body = await readErrorBody(response);
+      const error = chunkQK7HZIVY_cjs.uploadErrorFromResponse({
+        status: response.status,
+        statusText: response.statusText,
+        ...body !== void 0 ? { body } : {},
+        kind: "network"
+      });
+      if (!chunkQK7HZIVY_cjs.parseErrorBody(body).message.trim()) {
+        error.message = `Presign request failed: ${response.status} ${response.statusText}`;
+      }
+      throw error;
+    }
+    return response.json();
+  }
+};
+
+// src/strategies/direct-upload.ts
+var DirectUpload = class {
+  async upload(file, credentials, options) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.upload.addEventListener("progress", (e) => {
+        if (e.lengthComputable) {
+          options.onProgress(e.loaded, e.total);
+        }
+      });
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve({
+            key: credentials.key,
+            publicUrl: credentials.publicUrl,
+            downloadUrl: credentials.downloadUrl
+          });
+        } else {
+          reject(
+            chunkQK7HZIVY_cjs.uploadErrorFromResponse({
+              status: xhr.status,
+              statusText: xhr.statusText,
+              body: xhr.responseText,
+              kind: "storage",
+              operation: "upload"
+            })
+          );
+        }
+      });
+      xhr.addEventListener("error", () => {
+        reject(new chunkQK7HZIVY_cjs.UpupNetworkError("Network error during upload"));
+      });
+      xhr.addEventListener("abort", () => {
+        reject(new chunkQK7HZIVY_cjs.UpupNetworkError("Upload aborted"));
+      });
+      options.signal.addEventListener("abort", () => {
+        xhr.abort();
+      });
+      xhr.open("PUT", credentials.uploadUrl);
+      for (const [key, value] of Object.entries(
+        credentials.uploadHeaders ?? {}
+      )) {
+        xhr.setRequestHeader(key, value);
+      }
+      xhr.send(file);
+    });
+  }
+};
+
+// src/utils/multipart-session-store.ts
+var STORAGE_PREFIX = "upup_mp_";
+var SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+function fileFingerprint(file) {
+  return `${file.name}:${file.size}:${file.lastModified}:${file.type}`;
+}
+function storageKey(fingerprint) {
+  return `${STORAGE_PREFIX}${fingerprint}`;
+}
+function saveSession(fingerprint, session) {
+  try {
+    localStorage.setItem(storageKey(fingerprint), JSON.stringify(session));
+  } catch {
+  }
+}
+function loadSession(fingerprint) {
+  try {
+    const raw = localStorage.getItem(storageKey(fingerprint));
+    if (!raw) return null;
+    const session = JSON.parse(raw);
+    if (Date.now() - session.updatedAt > SESSION_TTL_MS) {
+      removeSession(fingerprint);
+      return null;
+    }
+    return session;
+  } catch {
+    return null;
+  }
+}
+function updateSessionProgress(fingerprint, uploadedBytes) {
+  try {
+    const raw = localStorage.getItem(storageKey(fingerprint));
+    if (!raw) return;
+    const session = JSON.parse(raw);
+    session.uploadedBytes = uploadedBytes;
+    session.updatedAt = Date.now();
+    localStorage.setItem(storageKey(fingerprint), JSON.stringify(session));
+  } catch {
+  }
+}
+function updateSessionToken(fingerprint, token) {
+  try {
+    const raw = localStorage.getItem(storageKey(fingerprint));
+    if (!raw) return;
+    const session = JSON.parse(raw);
+    session.token = token;
+    session.updatedAt = Date.now();
+    localStorage.setItem(storageKey(fingerprint), JSON.stringify(session));
+  } catch {
+  }
+}
+function removeSession(fingerprint) {
+  try {
+    localStorage.removeItem(storageKey(fingerprint));
+  } catch {
+  }
+}
+function clearAllSessions() {
+  try {
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(STORAGE_PREFIX)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((k) => {
+      localStorage.removeItem(k);
+    });
+  } catch {
+  }
+}
+
+exports.DirectUpload = DirectUpload;
+exports.TokenEndpointCredentials = TokenEndpointCredentials;
+exports.clearAllSessions = clearAllSessions;
+exports.fileFingerprint = fileFingerprint;
+exports.loadSession = loadSession;
+exports.removeSession = removeSession;
+exports.saveSession = saveSession;
+exports.updateSessionProgress = updateSessionProgress;
+exports.updateSessionToken = updateSessionToken;