@useupup/core 3.3.0

package/dist/chunk-VV6QCQLL.js

@@ -0,0 +1,365 @@
+// 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();
+  }
+};
+
+export { ThemeStore, UPUP_VAR_PREFIX, darkPreset, flattenSlotsToClassNames, lightPreset, resolveTheme, tokensToVarRefs, tokensToVars };

package/dist/chunk-ZMS2HXLB.js

@@ -0,0 +1,56 @@
+// src/types/file-source.ts
+var FileSource = /* @__PURE__ */ ((FileSource2) => {
+  FileSource2["LOCAL"] = "local";
+  FileSource2["GOOGLE_DRIVE"] = "googleDrive";
+  FileSource2["ONE_DRIVE"] = "oneDrive";
+  FileSource2["DROPBOX"] = "dropbox";
+  FileSource2["BOX"] = "box";
+  FileSource2["URL"] = "url";
+  FileSource2["CAMERA"] = "camera";
+  FileSource2["MICROPHONE"] = "microphone";
+  FileSource2["SCREEN"] = "screen";
+  return FileSource2;
+})(FileSource || {});
+
+// src/types/storage-provider.ts
+var StorageProvider = /* @__PURE__ */ ((StorageProvider2) => {
+  StorageProvider2["AWS"] = "aws";
+  StorageProvider2["Azure"] = "azure";
+  StorageProvider2["BackBlaze"] = "backblaze";
+  StorageProvider2["DigitalOcean"] = "digitalocean";
+  StorageProvider2["CloudflareR2"] = "r2";
+  StorageProvider2["Wasabi"] = "wasabi";
+  StorageProvider2["MinIO"] = "minio";
+  StorageProvider2["GCS"] = "gcs";
+  StorageProvider2["Supabase"] = "supabase";
+  StorageProvider2["Hetzner"] = "hetzner";
+  StorageProvider2["Linode"] = "linode";
+  StorageProvider2["Vultr"] = "vultr";
+  StorageProvider2["UpCloud"] = "upcloud";
+  StorageProvider2["Scaleway"] = "scaleway";
+  StorageProvider2["OVHcloud"] = "ovhcloud";
+  StorageProvider2["Alibaba"] = "alibaba";
+  StorageProvider2["Oracle"] = "oracle";
+  StorageProvider2["Contabo"] = "contabo";
+  StorageProvider2["Storj"] = "storj";
+  StorageProvider2["IDrive"] = "idrive";
+  StorageProvider2["Ceph"] = "ceph";
+  return StorageProvider2;
+})(StorageProvider || {});
+var NON_S3_STORAGE_PROVIDERS = /* @__PURE__ */ new Set([
+  "azure" /* Azure */
+]);
+
+// src/types/upload-status.ts
+var UploadStatus = /* @__PURE__ */ ((UploadStatus2) => {
+  UploadStatus2["IDLE"] = "IDLE";
+  UploadStatus2["PROCESSING"] = "PROCESSING";
+  UploadStatus2["READY"] = "READY";
+  UploadStatus2["UPLOADING"] = "UPLOADING";
+  UploadStatus2["PAUSED"] = "PAUSED";
+  UploadStatus2["SUCCESSFUL"] = "SUCCESSFUL";
+  UploadStatus2["FAILED"] = "FAILED";
+  return UploadStatus2;
+})(UploadStatus || {});
+
+export { FileSource, NON_S3_STORAGE_PROVIDERS, StorageProvider, UploadStatus };

package/dist/context-shapes-123dd3b6.d.cts

@@ -0,0 +1,207 @@
+import { a as UploadFile, c as UploadStatus, F as FileSource } from './contracts-pipeline-cf177270.cjs';
+import { F as FilesProgressMap, R as ResolvedImageEditorOptions, U as UpupCore, b as CloudDrivesConfig } from './core-bea2ceca.cjs';
+import { c as Translations, T as Translator } from './ui-translations-c5d00392.cjs';
+import { e as UpupThemeMode, d as UpupThemeTokens, I as InternalFlatClassNames, l as DeepPartialSlots, g as UpupResolvedTheme } from './vars-d3421f6c.cjs';
+
+interface UploadProgressInfo {
+    loaded: number;
+    total: number;
+    percentage: number;
+}
+interface OrchestratorState {
+    files: Map<string, UploadFile>;
+    uploadStatus: UploadStatus;
+    uploadError: string;
+    /** Machine code from a typed UpupError (e.g. 'SignatureDoesNotMatch', 'bad_signature'), when the failure carried one. */
+    uploadErrorCode?: string | undefined;
+    totalProgress: number;
+    filesProgressMap: FilesProgressMap;
+    uploadSpeed: number;
+    uploadEta: number;
+    uploadedBytes: number;
+    totalBytes: number;
+    activeSource?: FileSource | undefined;
+    editingFile: UploadFile | null;
+    editorQueue: UploadFile[];
+    isAddingMore: boolean;
+    viewMode: 'grid' | 'list';
+    isOnline: boolean;
+}
+interface OrchestratorCallbacks {
+    onError?: ((message: string) => void) | undefined;
+    onWarn?: ((message: string) => void) | undefined;
+    onUploadComplete?: ((files: UploadFile[]) => void) | undefined;
+    onUploadStart?: (() => void) | undefined;
+    onFileUploadStart?: ((file: UploadFile) => void) | undefined;
+    onFileUploadProgress?: ((file: UploadFile, progress: UploadProgressInfo) => void) | undefined;
+    onFileUploadComplete?: ((file: UploadFile, key: string) => void) | undefined;
+    onFilesUploadProgress?: ((completedFiles: number, totalFiles: number) => void) | undefined;
+    onFilesUploadComplete?: ((files: UploadFile[]) => void) | undefined;
+    onFileRemoved?: ((file: UploadFile) => void) | undefined;
+    onFilesSelected?: ((files: UploadFile[]) => void) | undefined;
+    onFileDrop?: ((files: File[]) => void) | undefined;
+    onDoneClicked?: (() => void) | undefined;
+    onPrepareFiles?: ((files: UploadFile[]) => Promise<UploadFile[] | File[]> | UploadFile[] | File[]) | undefined;
+    imageEditorOptions?: ResolvedImageEditorOptions | undefined;
+    /** When true, triggers upload automatically after files are added. */
+    autoUpload?: boolean | undefined;
+}
+
+declare class UploaderOrchestrator {
+    private state;
+    private listeners;
+    private core;
+    private callbacks;
+    private unsubs;
+    private disposed;
+    constructor(core: UpupCore, callbacks: OrchestratorCallbacks);
+    /** useSyncExternalStore-compatible subscribe (bound). */
+    subscribe: (listener: () => void) => (() => void);
+    /** useSyncExternalStore-compatible getSnapshot (bound). */
+    getSnapshot: () => OrchestratorState;
+    protected setState(partial: Partial<OrchestratorState>): void;
+    private notify;
+    /** Remove a file by id: revoke its blob URL, then delegate to core. */
+    removeFile(fileId: string): void;
+    /** Set the active upload source. */
+    setActiveSource(source: FileSource | undefined): void;
+    /** Toggle between grid and list view. */
+    setViewMode(mode: 'grid' | 'list'): void;
+    /** Toggle the "adding more files" state. */
+    setIsAddingMore(value: boolean): void;
+    /** Trigger upload for all current files. Calls onPrepareFiles if provided. */
+    startUpload(): Promise<UploadFile[] | undefined>;
+    /** Retry upload for a specific file or all failed files. */
+    retryUpload(fileId?: string): Promise<UploadFile[] | undefined>;
+    /** Cancel in-progress upload, revoke blob URLs, clear all files and progress. */
+    handleCancel(): void;
+    /** Pause in-progress upload. */
+    handlePause(): void;
+    /** Resume paused upload. */
+    handleResume(): void;
+    /** Mark upload as done: invoke callback, emit event, then cancel/clear. */
+    handleDone(): void;
+    /** Full state reset: clear isAddingMore, emit state-reset, then handleDone. */
+    resetState(): void;
+    /** Open the image editor for a given file. Invokes onOpen callback and emits event. */
+    openImageEditor(file: UploadFile): void;
+    /**
+     * Close the image editor without saving. Invokes onCancel callback.
+     * If the editor queue is non-empty, the next file is automatically opened.
+     */
+    closeImageEditor(): void;
+    /**
+     * Save an edited image. Converts the data URL to a blob, creates a new
+     * UploadFile preserving the original's identity, replaces it in state
+     * and core, then invokes the onSave callback.
+     */
+    saveImageEdit(editedImageData: string, mimeType?: string): void;
+    /** Replace a single file in state by id (revokes old blob URL). Also replaces in core. */
+    replaceFile(fileId: string, newFile: UploadFile): void;
+    /** Enqueue files for auto-opening in the image editor. */
+    enqueueForEditor(files: UploadFile[]): void;
+    /** Pop the next file from the editor queue and open it. */
+    private processEditorQueue;
+    private speedSamples;
+    /**
+     * Project orchestrator state from core — the single source of truth (F-145).
+     * `uploadStatus` is derived from the `status` each status-carrying `state-change`
+     * event supplies (core sets `_status` before every such emit); the discrete
+     * upload-start/upload-all-complete/upload-error listeners no longer write it. `files`
+     * is rebuilt from `core.files`, and is a no-op when the file set is unchanged (same
+     * size + ordered ids + same UploadFile refs) so the `files` reference stays stable
+     * across the many status-only `state-change` events core emits during upload —
+     * preserving referential stability for useSyncExternalStore / computed consumers.
+     */
+    private projectFromCore;
+    private filesProjectionChanged;
+    init(): void;
+    destroy(): void;
+}
+
+/**
+ * Base context shape types shared across the framework bindings.
+ *
+ * Each framework package defines its own concrete context types that extend
+ * these bases with framework-specific fields (e.g. React refs, Vue refs,
+ * Dispatch<SetStateAction<...>> vs plain setters).
+ *
+ * This file intentionally uses plain function signatures for state setters
+ * so both React (Dispatch<SetStateAction<T>>) and Vue ((v: T) => void) are
+ * compatible supertypes.
+ */
+
+type BaseContextUpload = {
+    uploadStatus: UploadStatus;
+    uploadError?: string | undefined;
+    /** Machine code from a typed UpupError, when the failure carried one. */
+    uploadErrorCode?: string | undefined;
+    totalProgress: number;
+    filesProgressMap: FilesProgressMap;
+    startUpload: () => Promise<UploadFile[] | undefined>;
+    retryUpload: (fileId?: string) => Promise<UploadFile[] | undefined>;
+    uploadSpeed: number;
+    uploadEta: number;
+    uploadedBytes: number;
+    totalBytes: number;
+};
+type BaseContextRuntime = {
+    core: UpupCore | null;
+    orchestrator: UploaderOrchestrator | null;
+    mode: 'client' | 'server';
+    serverUrl?: string | undefined;
+    openFilePicker: () => void;
+    isOnline: boolean;
+};
+type BaseContextSource = {
+    activeSource?: FileSource | undefined;
+    setActiveSource: (source: FileSource | undefined) => void;
+    cloudDrives?: CloudDrivesConfig | undefined;
+};
+type BaseContextI18n = {
+    translations: Translations;
+    translator?: Translator | undefined;
+    lang: string;
+    dir: 'ltr' | 'rtl';
+};
+type BaseContextFiles = {
+    files: Map<string, UploadFile>;
+    setFiles: (newFiles: File[]) => void;
+    replaceFiles: (files: File[] | UploadFile[]) => void;
+    resetState: () => void;
+    uploadFiles: (files: File[] | UploadFile[]) => Promise<UploadFile[] | undefined>;
+    handleFileRemove: (fileId: string) => void;
+};
+type BaseContextUploadControls = {
+    upload: BaseContextUpload;
+    handleDone: () => void;
+    handleCancel: () => void;
+    handlePause: () => void;
+    handleResume: () => void;
+};
+type BaseContextView = {
+    isAddingMore: boolean;
+    setIsAddingMore: (value: boolean) => void;
+    viewMode: 'grid' | 'list';
+    setViewMode: (mode: 'grid' | 'list') => void;
+};
+type BaseContextEditor = {
+    editingFile: UploadFile | null;
+    openImageEditor: (file: UploadFile) => void;
+    closeImageEditor: () => void;
+    saveImageEdit: (editedImageData: string, mimeType?: string) => void;
+    replaceFile: (fileId: string, newFile: UploadFile) => void;
+};
+type BaseResolvedTheme = Omit<UpupResolvedTheme, 'mode'> & {
+    mode: Exclude<UpupThemeMode, 'system'>;
+};
+type BaseContextTheme = {
+    themeMode: Exclude<UpupThemeMode, 'system'>;
+    isDark: boolean;
+    tokens: UpupThemeTokens;
+    resolved: BaseResolvedTheme;
+    slotOverrides: InternalFlatClassNames;
+    slots: DeepPartialSlots;
+};
+
+export { type BaseContextUpload as B, type OrchestratorCallbacks as O, UploaderOrchestrator as U, type BaseContextRuntime as a, type BaseContextSource as b, type BaseContextI18n as c, type BaseContextFiles as d, type BaseContextUploadControls as e, type BaseContextView as f, type BaseContextEditor as g, type BaseContextTheme as h, type OrchestratorState as i, type UploadProgressInfo as j };