@useupup/core 3.3.0

package/dist/chunk-QK7HZIVY.cjs

@@ -0,0 +1,144 @@
+'use strict';
+
+// src/errors.ts
+var UpupErrorCode = /* @__PURE__ */ ((UpupErrorCode2) => {
+  UpupErrorCode2["AUTH_EXPIRED"] = "AUTH_EXPIRED";
+  UpupErrorCode2["AUTH_DENIED"] = "AUTH_DENIED";
+  UpupErrorCode2["AUTH_PROVIDER_ERROR"] = "AUTH_PROVIDER_ERROR";
+  UpupErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+  UpupErrorCode2["FILE_TOO_SMALL"] = "FILE_TOO_SMALL";
+  UpupErrorCode2["TYPE_MISMATCH"] = "TYPE_MISMATCH";
+  UpupErrorCode2["LIMIT_EXCEEDED"] = "LIMIT_EXCEEDED";
+  UpupErrorCode2["TOTAL_SIZE_EXCEEDED"] = "TOTAL_SIZE_EXCEEDED";
+  UpupErrorCode2["DUPLICATE"] = "DUPLICATE";
+  UpupErrorCode2["MIN_FILES_NOT_MET"] = "MIN_FILES_NOT_MET";
+  UpupErrorCode2["UPLOAD_FAILED"] = "UPLOAD_FAILED";
+  UpupErrorCode2["UPLOAD_ABORTED"] = "UPLOAD_ABORTED";
+  UpupErrorCode2["PRESIGN_FAILED"] = "PRESIGN_FAILED";
+  UpupErrorCode2["CORS_ERROR"] = "CORS_ERROR";
+  UpupErrorCode2["PIPELINE_STEP_FAILED"] = "PIPELINE_STEP_FAILED";
+  UpupErrorCode2["HEIC_CONVERSION_FAILED"] = "HEIC_CONVERSION_FAILED";
+  UpupErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  UpupErrorCode2["TIMEOUT"] = "TIMEOUT";
+  UpupErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
+  UpupErrorCode2["QUOTA_EXCEEDED"] = "QUOTA_EXCEEDED";
+  UpupErrorCode2["NO_UPLOAD_TARGET"] = "NO_UPLOAD_TARGET";
+  UpupErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  UpupErrorCode2["AUTH_REQUIRED"] = "AUTH_REQUIRED";
+  UpupErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  return UpupErrorCode2;
+})(UpupErrorCode || {});
+var UpupError = class extends Error {
+  constructor(message, code, retryable = false) {
+    super(message);
+    this.name = "UpupError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+var UpupAuthError = class extends UpupError {
+  constructor(message, provider) {
+    super(message, "AUTH_PROVIDER_ERROR" /* AUTH_PROVIDER_ERROR */, false);
+    this.name = "UpupAuthError";
+    this.provider = provider;
+  }
+};
+var UpupNetworkError = class extends UpupError {
+  constructor(message, status) {
+    super(message, "NETWORK_ERROR" /* NETWORK_ERROR */, true);
+    this.name = "UpupNetworkError";
+    if (status !== void 0) this.status = status;
+  }
+};
+var UpupValidationError = class extends UpupError {
+  constructor(message, reason, file) {
+    super(message, reason, false);
+    this.name = "UpupValidationError";
+    this.reason = reason;
+    this.file = file;
+  }
+};
+var UpupQuotaError = class extends UpupError {
+  constructor(message, limit, used) {
+    super(message, "QUOTA_EXCEEDED" /* QUOTA_EXCEEDED */, false);
+    this.name = "UpupQuotaError";
+    this.limit = limit;
+    this.used = used;
+  }
+};
+var UpupStorageError = class extends UpupError {
+  constructor(message, provider, operation) {
+    super(message, "STORAGE_ERROR" /* STORAGE_ERROR */, false);
+    this.name = "UpupStorageError";
+    this.provider = provider;
+    this.operation = operation;
+  }
+};
+var UpupConfigError = class extends UpupError {
+  constructor(message, code = "NO_UPLOAD_TARGET" /* NO_UPLOAD_TARGET */) {
+    super(message, code, false);
+    this.name = "UpupConfigError";
+  }
+};
+var MAX_ERROR_BODY_SNIPPET = 200;
+function parseErrorBody(body) {
+  if (!body) return { message: "" };
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed && typeof parsed === "object") {
+      const {
+        code,
+        error,
+        message: msg
+      } = parsed;
+      const message = typeof error === "string" ? error : msg;
+      if (typeof message === "string" || typeof code === "string") {
+        return {
+          message: message ?? "",
+          ...code !== void 0 ? { code } : {}
+        };
+      }
+    }
+  } catch {
+  }
+  const xmlCode = /<Code>([^<]*)<\/Code>/.exec(body)?.[1];
+  const xmlMessage = /<Message>([^<]*)<\/Message>/.exec(body)?.[1];
+  if (xmlCode || xmlMessage) {
+    return {
+      message: xmlMessage ?? "",
+      ...xmlCode !== void 0 ? { code: xmlCode } : {}
+    };
+  }
+  return { message: body.slice(0, MAX_ERROR_BODY_SNIPPET) };
+}
+function uploadErrorFromResponse(args) {
+  const { status, statusText, body, kind, operation, provider } = args;
+  const parsed = parseErrorBody(body);
+  const message = parsed.message || `${status} ${statusText}`.trim();
+  let err;
+  if (kind === "auth") {
+    err = new UpupAuthError(message, provider ?? "server");
+  } else if (kind === "storage") {
+    err = new UpupStorageError(
+      message,
+      provider ?? "server",
+      operation ?? "upload"
+    );
+  } else {
+    err = new UpupNetworkError(message, status);
+  }
+  if (parsed.code) err.code = parsed.code;
+  err.status = status;
+  return err;
+}
+
+exports.UpupAuthError = UpupAuthError;
+exports.UpupConfigError = UpupConfigError;
+exports.UpupError = UpupError;
+exports.UpupErrorCode = UpupErrorCode;
+exports.UpupNetworkError = UpupNetworkError;
+exports.UpupQuotaError = UpupQuotaError;
+exports.UpupStorageError = UpupStorageError;
+exports.UpupValidationError = UpupValidationError;
+exports.parseErrorBody = parseErrorBody;
+exports.uploadErrorFromResponse = uploadErrorFromResponse;

package/dist/chunk-T2AQHY7V.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/runtime/browser.ts
+var BrowserRuntime = {
+  async computeHash(data) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  },
+  createImageBitmap: typeof createImageBitmap !== "undefined" ? (blob) => createImageBitmap(blob) : void 0,
+  createWorker: typeof Worker !== "undefined" ? () => {
+    try {
+      return new Worker(
+        new URL("./pipeline-worker.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-T2AQHY7V.cjs', document.baseURI).href))),
+        {
+          type: "module"
+        }
+      );
+    } catch {
+      return null;
+    }
+  } : void 0,
+  async upload(url, body, 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", () => {
+        const headers = {};
+        xhr.getAllResponseHeaders().split("\r\n").forEach((line) => {
+          const [key, ...vals] = line.split(": ");
+          if (key) headers[key.toLowerCase()] = vals.join(": ");
+        });
+        resolve({ status: xhr.status, headers, body: xhr.responseText });
+      });
+      xhr.addEventListener("error", () => {
+        reject(new Error("Network error"));
+      });
+      options.signal.addEventListener("abort", () => {
+        xhr.abort();
+      });
+      xhr.open(options.method, url);
+      for (const [k, v] of Object.entries(options.headers)) {
+        xhr.setRequestHeader(k, v);
+      }
+      xhr.send(body);
+    });
+  },
+  async readAsArrayBuffer(file) {
+    return file.arrayBuffer();
+  },
+  createObjectURL: typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? (blob) => URL.createObjectURL(blob) : void 0,
+  revokeObjectURL: typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function" ? (url) => {
+    URL.revokeObjectURL(url);
+  } : void 0
+};
+
+exports.BrowserRuntime = BrowserRuntime;

package/dist/chunk-TRCP5FUR.js

@@ -0,0 +1,90 @@
+import { UpupError, UpupNetworkError } from './chunk-GE4LIVXP.js';
+
+// 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 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 UpupNetworkError("Tus upload abort failed")
+          );
+        });
+        finishReject(new UpupNetworkError("Upload aborted"));
+      };
+      if (options.signal.aborted) {
+        finishReject(new 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 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();
+    });
+  }
+};
+
+export { TusUpload };

package/dist/chunk-U7KL5M2H.cjs

@@ -0,0 +1,374 @@
+'use strict';
+
+// src/theme/presets.ts
+var lightPreset = {
+  color: {
+    surface: "#FFFFFF",
+    surfaceAlt: "#F7F7F8",
+    primary: "#0284c7",
+    primaryHover: "#0369a1",
+    text: "#0B0B0B",
+    textMuted: "#6D6D6D",
+    border: "#D1D5DB",
+    borderActive: "#0ea5e9",
+    danger: "#DC2626",
+    success: "#16A34A",
+    dragBg: "#e0f2fe",
+    overlay: "rgba(0, 0, 0, 0.5)"
+  },
+  radius: {
+    sm: "4px",
+    md: "8px",
+    lg: "12px",
+    full: "9999px"
+  },
+  shadow: {
+    sm: "0 1px 2px rgba(0, 0, 0, 0.05)",
+    md: "0 4px 6px rgba(0, 0, 0, 0.07)",
+    lg: "0 10px 15px rgba(0, 0, 0, 0.1)"
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "12px",
+    lg: "16px"
+  }
+};
+var darkPreset = {
+  color: {
+    surface: "#1A1A2E",
+    surfaceAlt: "#252540",
+    primary: "#38bdf8",
+    primaryHover: "#7dd3fc",
+    text: "#FFFFFF",
+    textMuted: "#D1D5DB",
+    border: "#4B5563",
+    borderActive: "#38bdf8",
+    danger: "#EF4444",
+    success: "#22C55E",
+    dragBg: "#0b2a3a",
+    overlay: "rgba(0, 0, 0, 0.7)"
+  },
+  radius: {
+    sm: "4px",
+    md: "8px",
+    lg: "12px",
+    full: "9999px"
+  },
+  shadow: {
+    sm: "0 1px 2px rgba(0, 0, 0, 0.2)",
+    md: "0 4px 6px rgba(0, 0, 0, 0.3)",
+    lg: "0 10px 15px rgba(0, 0, 0, 0.4)"
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "12px",
+    lg: "16px"
+  }
+};
+
+// src/theme/resolve-theme.ts
+function deepMerge(base, overrides) {
+  if (!overrides) return base;
+  const result = { ...base };
+  const over = overrides;
+  for (const key of Object.keys(over)) {
+    const val = over[key];
+    if (val !== void 0 && typeof val === "object" && val !== null && !Array.isArray(val) && typeof result[key] === "object" && result[key] !== null) {
+      result[key] = deepMerge(
+        result[key],
+        val
+      );
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function detectSystemMode() {
+  if (typeof window !== "undefined" && // matchMedia is absent in jsdom/SSR — keep the optional call. (The
+  // no-unnecessary-condition disable that used to sit here became
+  // unused when the rule was demoted to off in F-784's warning purge.)
+  window.matchMedia?.("(prefers-color-scheme: dark)").matches) {
+    return "dark";
+  }
+  return "light";
+}
+function resolveTheme(config, providerTokens, providerSlots) {
+  const mode = config?.mode ?? "light";
+  const effectiveMode = mode === "system" ? detectSystemMode() : mode;
+  const base = effectiveMode === "dark" ? darkPreset : lightPreset;
+  const withProvider = deepMerge(base, providerTokens);
+  const final = deepMerge(withProvider, config?.tokens);
+  const mergedSlots = deepMerge(
+    providerSlots ?? {},
+    config?.slots
+  );
+  return { mode, tokens: final, slots: mergedSlots };
+}
+
+// src/theme/vars.ts
+var UPUP_VAR_PREFIX = "--upup-";
+function toKebab(str) {
+  return str.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+}
+function tokensToVars(tokens) {
+  const vars = {};
+  for (const [group, groupTokens] of Object.entries(tokens)) {
+    for (const [key, value] of Object.entries(
+      groupTokens
+    )) {
+      const varName = `${UPUP_VAR_PREFIX}${group}-${toKebab(key)}`;
+      vars[varName] = value;
+    }
+  }
+  return vars;
+}
+function tokensToVarRefs() {
+  const groups = {
+    color: [
+      "surface",
+      "surfaceAlt",
+      "primary",
+      "primaryHover",
+      "text",
+      "textMuted",
+      "border",
+      "borderActive",
+      "danger",
+      "success",
+      "dragBg",
+      "overlay"
+    ],
+    radius: ["sm", "md", "lg", "full"],
+    shadow: ["sm", "md", "lg"],
+    spacing: ["xs", "sm", "md", "lg"]
+  };
+  const result = {};
+  for (const [group, keys] of Object.entries(groups)) {
+    result[group] = {};
+    for (const key of keys) {
+      result[group][key] = `var(${UPUP_VAR_PREFIX}${group}-${toKebab(key)})`;
+    }
+  }
+  return result;
+}
+
+// src/theme/slots.ts
+var SLOT_TO_FLAT = {
+  uploader: {
+    root: "containerFull",
+    container: "containerFull"
+  },
+  dropZone: {
+    root: "containerFull"
+  },
+  sourceSelector: {
+    root: "containerFull",
+    sourceList: "sourceButtonList",
+    sourceButton: "sourceButton",
+    sourceButtonIcon: "sourceButtonIcon",
+    sourceButtonText: "sourceButtonText",
+    browseText: "sourceButtonText",
+    dragText: "sourceButtonText"
+  },
+  sourceView: {
+    root: "sourceView",
+    header: "sourceViewHeader",
+    cancelButton: "sourceViewCancelButton"
+  },
+  fileList: {
+    root: "fileListContainer",
+    header: "containerHeader",
+    cancelButton: "containerCancelButton",
+    addMoreButton: "containerAddMoreButton",
+    fileCount: "containerHeader",
+    body: [
+      "fileListContainerInnerSingle",
+      "fileListContainerInnerMultiple"
+    ],
+    footer: "fileListFooter",
+    uploadButton: "uploadButton",
+    doneButton: "uploadDoneButton"
+  },
+  filePreview: {
+    root: ["fileItemSingle", "fileItemMultiple"],
+    thumbnail: ["fileThumbnailSingle", "fileThumbnailMultiple"],
+    icon: "fileIcon",
+    info: "fileInfo",
+    name: "fileName",
+    size: "fileSize",
+    previewButton: "filePreviewButton",
+    deleteButton: "fileDeleteButton"
+  },
+  progressBar: {
+    root: "progressBarContainer",
+    track: "progressBar",
+    fill: "progressBarInner",
+    text: "progressBarText"
+  },
+  notifier: {
+    root: "containerFull",
+    message: "containerFull"
+  },
+  urlUploader: {
+    input: "urlInput",
+    fetchButton: "urlFetchButton"
+  },
+  cameraUploader: {
+    previewContainer: "cameraPreviewContainer",
+    deleteButton: "cameraDeleteButton",
+    captureButton: "cameraCaptureButton",
+    rotateButton: "cameraRotateButton",
+    mirrorButton: "cameraRotateButton",
+    addButton: "cameraAddButton",
+    modeToggle: "cameraRotateButton",
+    videoRecordButton: "cameraCaptureButton",
+    videoStopButton: "cameraCaptureButton",
+    videoPreview: "cameraPreviewContainer",
+    videoAddButton: "cameraAddButton",
+    videoDeleteButton: "cameraDeleteButton"
+  },
+  audioUploader: {
+    root: "containerFull",
+    playbackContainer: "cameraPreviewContainer",
+    deleteButton: "cameraDeleteButton",
+    addButton: "cameraAddButton"
+  },
+  screenCaptureUploader: {
+    root: "containerFull",
+    preview: "cameraPreviewContainer",
+    addButton: "cameraAddButton",
+    deleteButton: "cameraDeleteButton"
+  },
+  driveBrowser: {
+    root: "containerFull",
+    header: "driveHeader",
+    searchContainer: "driveSearchContainer",
+    searchInput: "driveSearchInput",
+    body: "driveBody",
+    footer: "driveFooter",
+    itemDefault: "driveItemContainerDefault",
+    itemSelected: "driveItemContainerSelected",
+    itemInner: "driveItemContainerInner",
+    itemInnerText: "driveItemInnerText",
+    addFilesButton: "driveAddFilesButton",
+    cancelFilesButton: "driveCancelFilesButton",
+    logoutButton: "driveLogoutButton",
+    loading: "driveLoading"
+  },
+  driveAuthFallback: {
+    root: "containerFull"
+  },
+  filePreviewPortal: {
+    root: "filePreviewPortal"
+  },
+  imageEditor: {
+    root: "containerFull",
+    modal: "containerFull"
+  }
+};
+function flattenSlotsToClassNames(slots) {
+  if (!slots) return {};
+  const out = {};
+  for (const componentKey of Object.keys(slots)) {
+    const component = slots[componentKey];
+    if (!component) continue;
+    const mapping = SLOT_TO_FLAT[componentKey];
+    if (!mapping) continue;
+    for (const slotName of Object.keys(component)) {
+      const value = component[slotName];
+      if (typeof value !== "string" || value.length === 0) continue;
+      const target = mapping[slotName];
+      if (!target) continue;
+      const keys = Array.isArray(target) ? target : [target];
+      for (const key of keys) {
+        out[key] = out[key] ? `${out[key]} ${value}` : value;
+      }
+    }
+  }
+  return out;
+}
+
+// src/theme/theme-store.ts
+function themeConfigEqual(a, b) {
+  if (a === b) return true;
+  return a?.mode === b?.mode && JSON.stringify(a?.tokens) === JSON.stringify(b?.tokens) && JSON.stringify(a?.slots) === JSON.stringify(b?.slots);
+}
+var ThemeStore = class {
+  constructor(config) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.systemMode = "light";
+    this.mediaCleanup = null;
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    this.getSnapshot = () => this.state;
+    this.config = config;
+    this.state = this.compute();
+  }
+  /** Start the `system` matchMedia subscription (no-op for explicit modes / SSR). */
+  init() {
+    const requested = this.config?.mode ?? "light";
+    if (requested !== "system") return;
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function")
+      return;
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const update = () => {
+      this.systemMode = media.matches ? "dark" : "light";
+      this.recompute();
+    };
+    update();
+    media.addEventListener("change", update);
+    this.mediaCleanup = () => {
+      media.removeEventListener("change", update);
+    };
+  }
+  /** Re-resolve when the host's theme config prop changes. */
+  setThemeConfig(config) {
+    if (themeConfigEqual(this.config, config)) return;
+    this.config = config;
+    this.recompute();
+  }
+  compute() {
+    const requested = this.config?.mode ?? "light";
+    const effective = requested === "system" ? this.systemMode : requested;
+    const resolved = resolveTheme({
+      ...this.config ?? {},
+      mode: effective
+    });
+    return {
+      themeMode: effective,
+      isDark: effective === "dark",
+      tokens: resolved.tokens,
+      resolved,
+      slotOverrides: flattenSlotsToClassNames(resolved.slots),
+      slots: resolved.slots
+    };
+  }
+  recompute() {
+    this.state = this.compute();
+    this.notify();
+  }
+  notify() {
+    this.listeners.forEach((fn) => {
+      fn();
+    });
+  }
+  destroy() {
+    this.mediaCleanup?.();
+    this.mediaCleanup = null;
+    this.listeners.clear();
+  }
+};
+
+exports.ThemeStore = ThemeStore;
+exports.UPUP_VAR_PREFIX = UPUP_VAR_PREFIX;
+exports.darkPreset = darkPreset;
+exports.flattenSlotsToClassNames = flattenSlotsToClassNames;
+exports.lightPreset = lightPreset;
+exports.resolveTheme = resolveTheme;
+exports.tokensToVarRefs = tokensToVarRefs;
+exports.tokensToVars = tokensToVars;