@useupup/core 3.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Devino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,8 @@
+@useupup/core bundles libheif (via libheif-js) for HEIC/HEIF image decoding.
+
+libheif is licensed under the GNU Lesser General Public License v3.0 (LGPL-3.0).
+Source: https://github.com/strukturag/libheif
+libheif-js: https://github.com/catdad-experiments/libheif-js
+
+The libheif WebAssembly artifact is a separable component and may be replaced
+with a compatible build under the terms of the LGPL-3.0.

package/README.md

@@ -0,0 +1,75 @@
+# @useupup/core
+
+The headless engine behind [upup](https://github.com/DevinoSolutions/upup): file
+state and upload orchestration, the upload pipeline (image compression, HEIC
+decode, web-worker offload), cloud-drive plugins (Google Drive, OneDrive,
+Dropbox, Box), theming, and ICU i18n. It has **zero framework dependencies** and
+powers every `@useupup/*` UI package.
+
+## Install
+
+Most consumers should install a framework package instead —
+[`@useupup/react`](https://www.npmjs.com/package/@useupup/react), `@useupup/vue`,
+`@useupup/svelte`, `@useupup/angular`, `@useupup/vanilla`, or `@useupup/preact` — which bundle
+this engine and render a ready-made UI. Install `@useupup/core` directly only to
+drive uploads headlessly or to build your own UI binding.
+
+```sh
+npm i @useupup/core
+```
+
+## Headless usage
+
+```ts
+import { UpupCore } from '@useupup/core'
+
+const core = new UpupCore({
+    provider: 'aws',
+    uploadEndpoint: '/api/upload-token',
+})
+```
+
+`UpupCore` owns the file/progress state, the upload lifecycle, and the
+cloud-drive plugins. See the docs for the full event and method surface.
+
+## Errors
+
+Upload failures are typed. Catch `UpupError` and branch on its stable
+`UpupErrorCode`; the concrete subclasses (`UpupValidationError`,
+`UpupNetworkError`, `UpupStorageError`, `UpupAuthError`, `UpupQuotaError`,
+`UpupConfigError`) let you narrow further.
+
+```ts
+import { UpupError, UpupErrorCode } from '@useupup/core'
+
+function isRetryable(err: unknown): boolean {
+    return err instanceof UpupError && err.code === UpupErrorCode.NETWORK_ERROR
+}
+```
+
+`StorageProvider` enumerates the supported storage providers
+(`StorageProvider.AWS`, `StorageProvider.CloudflareR2`, `StorageProvider.MinIO`,
+and more).
+
+## Entry points
+
+The main `@useupup/core` entry is a curated allow-list of stable exports (the
+`UpupCore` engine, the drive plugins, the `UpupError` taxonomy — `UpupError`
+plus its typed subclasses and the `UpupErrorCode` enum — the locale bundles, and
+the theme presets). Advanced, deep-import-only subpaths are also published:
+
+- `@useupup/core/internal` — implementation internals (managers, orchestrator, controllers)
+- `@useupup/core/contracts`, `@useupup/core/i18n`, `@useupup/core/theme`, `@useupup/core/strategies`
+- `@useupup/core/pipeline` and `@useupup/core/steps/*` (`hash`, `heic`, `exif`, `compress`, `thumbnail`)
+
+Heavy capabilities (HEIC decode, resumable/tus uploads) load lazily via these
+subpaths, so they never weigh down the main entry.
+
+## Links
+
+- [Documentation](https://useupup.com/docs/)
+- [Source & monorepo](https://github.com/DevinoSolutions/upup)
+
+## License
+
+MIT

package/dist/browser-SXR426OQ.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkT2AQHY7V_cjs = require('./chunk-T2AQHY7V.cjs');
+
+
+
+Object.defineProperty(exports, 'BrowserRuntime', {
+  enumerable: true,
+  get: function () { return chunkT2AQHY7V_cjs.BrowserRuntime; }
+});

package/dist/browser-WD6T5ABJ.js

@@ -0,0 +1 @@
+export { BrowserRuntime } from './chunk-HFR5HZJZ.js';

package/dist/chunk-2H5ICKFT.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+// src/steps/animated-image.ts
+function ascii(bytes, start, length) {
+  let out = "";
+  for (let i = start; i < start + length; i += 1) {
+    const byte = bytes[i];
+    if (byte === void 0) return out;
+    out += String.fromCharCode(byte);
+  }
+  return out;
+}
+function byteAt(bytes, index) {
+  return bytes[index] ?? 0;
+}
+function skipSubBlocks(bytes, start) {
+  let offset = start;
+  while (offset < bytes.length) {
+    const size = byteAt(bytes, offset);
+    offset += 1;
+    if (size === 0) return offset;
+    offset += size;
+  }
+  return bytes.length;
+}
+function isAnimatedGif(bytes) {
+  if (bytes.length < 13) return false;
+  if (ascii(bytes, 0, 3) !== "GIF") return false;
+  const screenPacked = byteAt(bytes, 10);
+  let offset = 13;
+  if ((screenPacked & 128) !== 0) {
+    offset += 3 * (1 << (screenPacked & 7) + 1);
+  }
+  let frames = 0;
+  while (offset < bytes.length) {
+    const block = byteAt(bytes, offset);
+    if (block === 59) return false;
+    if (block === 33) {
+      const label = byteAt(bytes, offset + 1);
+      offset += 2;
+      if (label === 255) {
+        const identifier = ascii(
+          bytes,
+          offset + 1,
+          byteAt(bytes, offset)
+        );
+        if (identifier === "NETSCAPE2.0" || identifier === "ANIMEXTS1.0") {
+          return true;
+        }
+      }
+      offset = skipSubBlocks(bytes, offset);
+      continue;
+    }
+    if (block === 44) {
+      frames += 1;
+      if (frames > 1) return true;
+      const imagePacked = byteAt(bytes, offset + 9);
+      offset += 10;
+      if ((imagePacked & 128) !== 0) {
+        offset += 3 * (1 << (imagePacked & 7) + 1);
+      }
+      offset += 1;
+      offset = skipSubBlocks(bytes, offset);
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function isAnimatedPng(bytes) {
+  if (bytes.length < PNG_SIGNATURE.length) return false;
+  for (const [index, expected] of PNG_SIGNATURE.entries()) {
+    if (byteAt(bytes, index) !== expected) return false;
+  }
+  let offset = PNG_SIGNATURE.length;
+  while (offset + 8 <= bytes.length) {
+    const length = byteAt(bytes, offset) * 16777216 + byteAt(bytes, offset + 1) * 65536 + byteAt(bytes, offset + 2) * 256 + byteAt(bytes, offset + 3);
+    const type = ascii(bytes, offset + 4, 4);
+    if (type === "acTL") return true;
+    if (type === "IDAT") return false;
+    offset += 12 + length;
+  }
+  return false;
+}
+function isAnimatedWebp(bytes) {
+  if (bytes.length < 16) return false;
+  if (ascii(bytes, 0, 4) !== "RIFF" || ascii(bytes, 8, 4) !== "WEBP") {
+    return false;
+  }
+  let offset = 12;
+  while (offset + 8 <= bytes.length) {
+    const fourCC = ascii(bytes, offset, 4);
+    const size = byteAt(bytes, offset + 4) + byteAt(bytes, offset + 5) * 256 + byteAt(bytes, offset + 6) * 65536 + byteAt(bytes, offset + 7) * 16777216;
+    if (fourCC === "ANIM" || fourCC === "ANMF") return true;
+    if (fourCC === "VP8X" && (byteAt(bytes, offset + 8) & 2) !== 0) {
+      return true;
+    }
+    offset += 8 + size + size % 2;
+  }
+  return false;
+}
+var SNIFFERS = {
+  "image/gif": isAnimatedGif,
+  "image/png": isAnimatedPng,
+  "image/apng": isAnimatedPng,
+  "image/webp": isAnimatedWebp
+};
+function baseMimeType(type) {
+  return type.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+async function isAnimatedImage(file) {
+  const sniff = SNIFFERS[baseMimeType(file.type)];
+  if (!sniff) return false;
+  try {
+    return sniff(new Uint8Array(await file.arrayBuffer()));
+  } catch {
+    return false;
+  }
+}
+
+exports.isAnimatedImage = isAnimatedImage;

package/dist/chunk-6HF3I2JS.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+// src/pipeline/engine.ts
+var PipelineEngine = class {
+  constructor(steps) {
+    this.steps = steps;
+  }
+  get stepCount() {
+    return this.steps.length;
+  }
+  async process(file, context) {
+    context.emit("pipeline-start", {
+      fileId: file.id,
+      steps: this.steps.map((s) => s.name)
+    });
+    let current = file;
+    for (const step of this.steps) {
+      if (step.shouldProcess && !step.shouldProcess(current)) {
+        continue;
+      }
+      current = await step.process(current, context);
+      context.emit("pipeline-step", {
+        fileId: file.id,
+        step: step.name
+      });
+    }
+    context.emit("pipeline-complete", { fileId: file.id });
+    return current;
+  }
+  async processAll(files, context) {
+    const results = [];
+    for (const file of files) {
+      results.push(await this.process(file, context));
+    }
+    return results;
+  }
+};
+
+exports.PipelineEngine = PipelineEngine;

package/dist/chunk-6S5DQDQH.js

@@ -0,0 +1,212 @@
+import { UpupError } from './chunk-GE4LIVXP.js';
+
+// 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 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 ?? {});
+}
+
+export { canvasToBlob, cloneUploadFile, createCanvas, createThumbnail, encodeImageFile, uploadFileFromImageResult };

package/dist/chunk-BMQC27OE.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+var chunkQK7HZIVY_cjs = require('./chunk-QK7HZIVY.cjs');
+
+// src/strategies/tus-upload.ts
+var TusUpload = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async upload(file, _credentials, options) {
+    let tus;
+    try {
+      tus = await import('tus-js-client');
+    } catch {
+      throw new chunkQK7HZIVY_cjs.UpupError(
+        'Resumable (tus) uploads require the optional dependency "tus-js-client". Install it: npm i tus-js-client',
+        "UPLOAD_FAILED" /* UPLOAD_FAILED */
+      );
+    }
+    const fileName = file instanceof File ? file.name : "blob";
+    const fileType = file.type || "application/octet-stream";
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let upload = null;
+      const finishReject = (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      };
+      const abortUpload = () => {
+        upload?.abort().catch((error) => {
+          finishReject(
+            error instanceof Error ? error : new chunkQK7HZIVY_cjs.UpupNetworkError("Tus upload abort failed")
+          );
+        });
+        finishReject(new chunkQK7HZIVY_cjs.UpupNetworkError("Upload aborted"));
+      };
+      if (options.signal.aborted) {
+        finishReject(new chunkQK7HZIVY_cjs.UpupNetworkError("Upload aborted"));
+        return;
+      }
+      options.signal.addEventListener("abort", abortUpload, {
+        once: true
+      });
+      const uploadOptions = {
+        endpoint: this.options.endpoint,
+        metadata: {
+          filename: fileName,
+          filetype: fileType,
+          ...this.options.metadata
+        },
+        onProgress: (bytesUploaded, bytesTotal) => {
+          options.onProgress(bytesUploaded, bytesTotal);
+        },
+        onError: (error) => {
+          options.signal.removeEventListener("abort", abortUpload);
+          finishReject(
+            error instanceof Error ? error : new chunkQK7HZIVY_cjs.UpupNetworkError("Tus upload failed")
+          );
+        },
+        onSuccess: () => {
+          if (settled) return;
+          settled = true;
+          options.signal.removeEventListener("abort", abortUpload);
+          resolve({
+            key: upload?.url ?? fileName,
+            publicUrl: upload?.url ?? void 0
+          });
+        }
+      };
+      const legacyChunkSize = this.options.chunkSize;
+      const chunkSize = this.options.chunkSizeBytes ?? legacyChunkSize;
+      if (this.options.headers !== void 0)
+        uploadOptions.headers = this.options.headers;
+      if (chunkSize !== void 0) uploadOptions.chunkSize = chunkSize;
+      if (this.options.retryDelays !== void 0)
+        uploadOptions.retryDelays = this.options.retryDelays;
+      if (this.options.storeFingerprintForResuming !== void 0) {
+        uploadOptions.storeFingerprintForResuming = this.options.storeFingerprintForResuming;
+      }
+      if (this.options.removeFingerprintOnSuccess !== void 0) {
+        uploadOptions.removeFingerprintOnSuccess = this.options.removeFingerprintOnSuccess;
+      }
+      if (this.options.parallelUploads !== void 0)
+        uploadOptions.parallelUploads = this.options.parallelUploads;
+      upload = new tus.Upload(file, uploadOptions);
+      upload.start();
+    });
+  }
+};
+
+exports.TusUpload = TusUpload;