@useupup/angular 3.3.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@useupup/angular" />
+export * from './public-api';

package/dist/lib/to-signal-store.d.ts

@@ -0,0 +1,20 @@
+import { type Signal } from '@angular/core';
+/** The subscribe/getSnapshot contract every @useupup/core headless store satisfies. */
+export interface HeadlessStore<S> {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): S;
+}
+/** The Angular-signal view returned by toSignalStore. Call destroy() in ngOnDestroy / DestroyRef. */
+export interface SignalStore<S> {
+    state: Signal<S>;
+    destroy: () => void;
+}
+/**
+ * Bridge a headless @useupup/core store to an Angular signal. State mirroring only —
+ * init()/destroy() stay the caller's responsibility (Angular ngOnInit/DestroyRef),
+ * mirroring @useupup/svelte's toReadable and keeping SSR side-effect-free.
+ * The orchestrator returns a fresh snapshot object on every change, so Object.is
+ * (the signal default) always sees a new reference, ensuring no real update is
+ * silently dropped. destroy() is idempotent — safe to call more than once.
+ */
+export declare function toSignalStore<S>(store: HeadlessStore<S>): SignalStore<S>;

package/dist/lib/use-sse-processing.d.ts

@@ -0,0 +1,19 @@
+import type { UploadFile } from '@useupup/core';
+export type SSEProcessingOptions = {
+    processingEndpoint?: string | undefined;
+    onFileProcessed?: ((file: UploadFile, data: Record<string, unknown>) => void) | undefined;
+    onError?: ((error: Error) => void) | undefined;
+    processingTimeout?: number | undefined;
+};
+/**
+ * Framework-free SSE processing helper (ported from @useupup/svelte useSSEProcessing).
+ * Returns { connectSSE(file), destroy() }.
+ * - connectSSE opens an EventSource at processingEndpoint?key=file.key.
+ * - destroy tears down all open EventSources and timers.
+ *
+ * No Svelte lifecycle hooks — callers push destroy() into their own cleanup array.
+ */
+export declare function createSSEProcessing({ processingEndpoint, onFileProcessed, onError, processingTimeout, }: SSEProcessingOptions): {
+    connectSSE(file: UploadFile): void;
+    destroy(): void;
+};

package/dist/lib/use-tiles-per-row.d.ts

@@ -0,0 +1,18 @@
+import { type Signal } from '@angular/core';
+/**
+ * Measure an element's content-box width with a ResizeObserver and derive how
+ * many 160px grid tiles fit one row (see view-mode.ts). Returns 0 until measured
+ * (SSR / jsdom / pre-paint), which isListViewForced reads as "unknown — don't
+ * force list yet". Isolated so tests can mock the measurement seam without a
+ * real layout engine. Mirrors React's lib/use-tiles-per-row.
+ */
+export declare class TilesPerRowObserver {
+    private ro;
+    private readonly _tilesPerRow;
+    /** Reactive tile-per-row count (0 until measured — see view-mode.ts). */
+    get tilesPerRow(): Signal<number>;
+    /** (Re)observe an element with the ResizeObserver. Call it whenever the
+     *  scroll container the file list binds changes; passing null disconnects. */
+    observe(el: HTMLElement | null): void;
+    destroy(): void;
+}

package/dist/lib/use-upup-upload.d.ts

@@ -0,0 +1,40 @@
+import { type WritableSignal } from '@angular/core';
+import { UpupCore, UploadStatus } from '@useupup/core';
+import type { CoreOptions, UploadFile, ExtensionMethods } from '@useupup/core';
+export interface UseUpupUploadOptions extends CoreOptions {
+    onFileAdded?: (files: UploadFile[]) => void;
+    onFileRemoved?: (file: UploadFile) => void;
+    onUploadProgress?: (progress: {
+        fileId: string;
+        loaded: number;
+        total: number;
+    }) => void;
+    onUploadComplete?: (files: UploadFile[]) => void;
+}
+export interface UpupUploadHandle {
+    files: WritableSignal<UploadFile[]>;
+    status: WritableSignal<UploadStatus>;
+    progress: WritableSignal<{
+        totalFiles: number;
+        completedFiles: number;
+        percentage: number;
+    }>;
+    error: WritableSignal<Error | null>;
+    addFiles(files: File[]): Promise<void>;
+    removeFile(id: string): void;
+    removeAll(): void;
+    setFiles(files: File[]): Promise<void>;
+    reorderFiles(ids: string[]): void;
+    upload(): Promise<UploadFile[]>;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    retry(fileId?: string): Promise<UploadFile[]>;
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    ext: Record<string, ExtensionMethods>;
+    core: UpupCore;
+    start(): void;
+    destroy(): void;
+}
+/** Single-use: after destroy() the underlying UpupCore is destroyed; do not call start() again on the same instance. */
+export declare function createUpupUpload(options: UseUpupUploadOptions): UpupUploadHandle;

package/dist/lib/view-mode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Grid-tile geometry. The grid lays tiles with
+ * `repeat(auto-fit, minmax(FILE_TILE_MIN, 1fr))` and a FILE_TILE_GAP gap, so a
+ * row fits floor((width + gap) / (min + gap)) tiles before it would wrap, and
+ * the tiles STRETCH to fill the row (no dead columns). The force-list rule below
+ * uses the SAME numbers so the grid never wraps: the moment one more tile would
+ * spill to a second row, list mode is forced instead.
+ */
+export declare const FILE_TILE_MIN = 160;
+export declare const FILE_TILE_GAP = 16;
+/**
+ * How many auto-fit tiles fit across `containerWidth` in a single row. A
+ * non-positive / non-finite (unmeasured) width yields 0, which
+ * isListViewForced reads as "not measured yet — don't force a switch".
+ */
+export declare function computeTilesPerRow(containerWidth: number): number;
+/**
+ * The square-tile grid is only honored when every tile fits in ONE row of the
+ * fixed-height panel; past that the row list is FORCED and UploaderHeader hides
+ * the grid/list toggle. `tilesPerRow <= 0` means the container has not been
+ * measured yet — treated as "fits" so the first paint never flashes to list.
+ */
+export declare function isListViewForced(fileCount: number, tilesPerRow: number): boolean;

package/dist/public-api.d.ts

@@ -0,0 +1,9 @@
+export { UpupUploaderComponent } from './upup-uploader.component';
+export { UpupStore } from './upup-store.service';
+export { createUpupUpload } from './lib/use-upup-upload';
+export type { UseUpupUploadOptions, UpupUploadHandle, } from './lib/use-upup-upload';
+export { toSignalStore } from './lib/to-signal-store';
+export type { SignalStore, HeadlessStore } from './lib/to-signal-store';
+export type { UploaderProps, UploaderIcons } from './shared/types';
+export { FileSource, StorageProvider, UploadStatus } from '@useupup/core';
+export type { UploadFile, CoreOptions, ImageEditorOptions, ResolvedImageEditorOptions, UploadSource, UploadProvider, } from '@useupup/core';

package/dist/services/box.service.d.ts

@@ -0,0 +1,40 @@
+import { type Signal } from '@angular/core';
+import { type DriveFile, type DriveFolder } from '@useupup/core';
+import * as i0 from "@angular/core";
+/**
+ * Angular port of useBox.ts (svelte composable).
+ *
+ * Pure delegation to DriveBrowserController with BOX_DESCRIPTOR (popup auth).
+ * No business logic lives here — everything flows through the controller.
+ */
+export declare class BoxService {
+    private store;
+    private controller;
+    private signalStore;
+    private state;
+    readonly user: Signal<import("@useupup/core").DriveUser>;
+    readonly boxFiles: Signal<DriveFolder>;
+    readonly token: Signal<string>;
+    readonly isAuthenticated: Signal<boolean>;
+    readonly isLoading: Signal<boolean>;
+    readonly path: Signal<DriveFolder[]>;
+    readonly selectedFiles: Signal<DriveFile[]>;
+    readonly showLoader: Signal<boolean>;
+    readonly isClickLoading: Signal<boolean>;
+    readonly error: Signal<import("@useupup/core").DriveBrowserError>;
+    readonly hasMore: Signal<boolean>;
+    readonly isLoadingMore: Signal<boolean>;
+    init(): void;
+    destroy(): void;
+    authenticate(): void;
+    logout(): void;
+    setPath(newPath: DriveFolder[]): void;
+    handleClick(file: DriveFile): void;
+    handleSignOut(): void;
+    handleSubmit(): Promise<void>;
+    handleCancelDownload(): void;
+    onSelectCurrentFolder(): void;
+    loadMore(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BoxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BoxService>;
+}

package/dist/services/camera-uploader.service.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from "@angular/core";
+export declare enum FacingMode {
+    Environment = "environment",
+    User = "user"
+}
+/**
+ * Angular port of useCameraUploader (svelte composable).
+ *
+ * Manages getUserMedia stream lifecycle, canvas capture → File, facing-mode switch.
+ * The video element is wired in by the component via setVideoEl() (mirrors svelte's
+ * bind:this={videoEl} + $effect(() => setVideoEl(videoEl))).
+ *
+ * Cleanup: call stopCamera() from ngOnDestroy.
+ */
+export declare class CameraUploaderService {
+    private store;
+    private videoEl;
+    private stream;
+    readonly capturedUrl: import("@angular/core").WritableSignal<string>;
+    readonly facingMode: import("@angular/core").WritableSignal<FacingMode>;
+    /** 'front' when environment-facing (switch button shows "Switch to front"), 'back' otherwise. */
+    readonly newCameraSide: import("@angular/core").Signal<"front" | "back">;
+    setVideoEl(el: HTMLVideoElement | null): void;
+    startCamera(): Promise<void>;
+    stopCamera(): void;
+    capture(): void;
+    clearUrl(): void;
+    handleFetchImage(): Promise<void>;
+    handleCameraSwitch(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CameraUploaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CameraUploaderService>;
+}

package/dist/services/dropbox.service.d.ts

@@ -0,0 +1,40 @@
+import { type Signal } from '@angular/core';
+import { type DriveFile, type DriveFolder } from '@useupup/core';
+import * as i0 from "@angular/core";
+/**
+ * Angular port of useDropbox.ts (svelte composable).
+ *
+ * Pure delegation to DriveBrowserController with DROPBOX_DESCRIPTOR (popup auth).
+ * No business logic lives here — everything flows through the controller.
+ */
+export declare class DropboxService {
+    private store;
+    private controller;
+    private signalStore;
+    private state;
+    readonly user: Signal<import("@useupup/core").DriveUser>;
+    readonly dropboxFiles: Signal<DriveFolder>;
+    readonly token: Signal<string>;
+    readonly isAuthenticated: Signal<boolean>;
+    readonly isLoading: Signal<boolean>;
+    readonly path: Signal<DriveFolder[]>;
+    readonly selectedFiles: Signal<DriveFile[]>;
+    readonly showLoader: Signal<boolean>;
+    readonly isClickLoading: Signal<boolean>;
+    readonly error: Signal<import("@useupup/core").DriveBrowserError>;
+    readonly hasMore: Signal<boolean>;
+    readonly isLoadingMore: Signal<boolean>;
+    init(): void;
+    destroy(): void;
+    authenticate(): void;
+    logout(): void;
+    setPath(newPath: DriveFolder[]): void;
+    handleClick(file: DriveFile): void;
+    handleSignOut(): void;
+    handleSubmit(): Promise<void>;
+    handleCancelDownload(): void;
+    onSelectCurrentFolder(): void;
+    loadMore(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropboxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropboxService>;
+}

package/dist/services/fetch-file-by-url.service.d.ts

@@ -0,0 +1,17 @@
+import { deriveFetchedFileName } from '@useupup/core/internal';
+import * as i0 from "@angular/core";
+export { deriveFetchedFileName };
+/**
+ * Angular port of useFetchFileByUrl (svelte/vue composable).
+ *
+ * Fetches a URL → Blob → File using deriveFetchedFileName for the filename.
+ * Error path calls store.uiProps.onError (svelte parity: composable uses onError
+ * from useUploaderOptions which resolves to the same callback).
+ */
+export declare class FetchFileByUrlService {
+    private store;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    fetchImage(url: string): Promise<File | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FetchFileByUrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FetchFileByUrlService>;
+}

package/dist/services/google-drive.service.d.ts

@@ -0,0 +1,47 @@
+import { type Signal } from '@angular/core';
+import { type DriveFile, type DriveFolder } from '@useupup/core';
+import * as i0 from "@angular/core";
+/**
+ * Angular port of useGoogleDrive.ts (svelte composable).
+ *
+ * Creates and manages one DriveBrowserController for Google Drive (GIS auth).
+ * ALL business logic lives in the controller — this service only:
+ *   1. Constructs the controller with the store's core + callbacks
+ *   2. Bridges the controller's subscribe/getSnapshot to Angular signals via toSignalStore
+ *   3. Exposes typed selectors + forwarding methods (pure delegation, no logic)
+ *
+ * Call init() from ngOnInit and destroy() from ngOnDestroy (or via DestroyRef).
+ */
+export declare class GoogleDriveService {
+    private store;
+    private controller;
+    private signalStore;
+    private state;
+    readonly user: Signal<import("@useupup/core").DriveUser>;
+    readonly googleFiles: Signal<DriveFolder>;
+    readonly token: Signal<{
+        access_token: string;
+        expires_in: number;
+    }>;
+    readonly authCancelled: Signal<boolean>;
+    readonly isAuthReady: Signal<boolean>;
+    readonly path: Signal<DriveFolder[]>;
+    readonly selectedFiles: Signal<DriveFile[]>;
+    readonly showLoader: Signal<boolean>;
+    readonly isClickLoading: Signal<boolean>;
+    readonly error: Signal<import("@useupup/core").DriveBrowserError>;
+    readonly hasMore: Signal<boolean>;
+    readonly isLoadingMore: Signal<boolean>;
+    init(): void;
+    destroy(): void;
+    retryAuth(): void;
+    handleSignOut(): void;
+    setPath(newPath: DriveFolder[]): void;
+    handleClick(file: DriveFile): void;
+    handleSubmit(): Promise<void>;
+    handleCancelDownload(): void;
+    onSelectCurrentFolder(): void;
+    loadMore(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleDriveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GoogleDriveService>;
+}

package/dist/services/one-drive.service.d.ts

@@ -0,0 +1,39 @@
+import { type Signal } from '@angular/core';
+import { type DriveFile, type DriveFolder } from '@useupup/core';
+import * as i0 from "@angular/core";
+/**
+ * Angular port of useOneDrive.ts (svelte composable).
+ *
+ * Pure delegation to DriveBrowserController with ONE_DRIVE_DESCRIPTOR (popup auth).
+ * No business logic lives here — everything flows through the controller.
+ */
+export declare class OneDriveService {
+    private store;
+    private controller;
+    private signalStore;
+    private state;
+    readonly user: Signal<import("@useupup/core").DriveUser>;
+    readonly oneDriveFiles: Signal<DriveFolder>;
+    readonly token: Signal<string>;
+    readonly isAuthenticated: Signal<boolean>;
+    readonly isLoading: Signal<boolean>;
+    readonly path: Signal<DriveFolder[]>;
+    readonly selectedFiles: Signal<DriveFile[]>;
+    readonly showLoader: Signal<boolean>;
+    readonly isClickLoading: Signal<boolean>;
+    readonly error: Signal<import("@useupup/core").DriveBrowserError>;
+    readonly hasMore: Signal<boolean>;
+    readonly isLoadingMore: Signal<boolean>;
+    init(): void;
+    destroy(): void;
+    signIn(): void;
+    signOut(): void;
+    setPath(newPath: DriveFolder[]): void;
+    handleClick(file: DriveFile): void;
+    handleSubmit(): Promise<void>;
+    handleCancelDownload(): void;
+    onSelectCurrentFolder(): void;
+    loadMore(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OneDriveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OneDriveService>;
+}

package/dist/services/server-mode-drive.service.d.ts

@@ -0,0 +1,30 @@
+import { type ServerModeProvider, type ServerDriveFile, type ServerDriveListState } from '@useupup/core';
+import * as i0 from "@angular/core";
+export type { ServerModeProvider, ServerDriveFile };
+export type ListState = ServerDriveListState;
+export declare const PROVIDER_LABEL: Record<ServerModeProvider, string>;
+export declare class ServerModeDriveService {
+    private store;
+    private controller;
+    private bridge;
+    private provider;
+    readonly listState: import("@angular/core").Signal<ServerDriveListState>;
+    readonly folderId: import("@angular/core").Signal<string>;
+    readonly search: import("@angular/core").Signal<string>;
+    readonly selected: import("@angular/core").WritableSignal<Set<string>>;
+    readonly isTransferring: import("@angular/core").WritableSignal<boolean>;
+    init(provider: ServerModeProvider): void;
+    list(opts?: {
+        folderId?: string;
+        search?: string;
+    }): Promise<void>;
+    startAuth(): void;
+    setFolderId(id: string | undefined): void;
+    setSearch(s: string): void;
+    toggleSelected(id: string): void;
+    transfer(): Promise<void>;
+    destroy(): void;
+    get providerLabel(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServerModeDriveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServerModeDriveService>;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,14 @@
+import type { Type } from '@angular/core';
+import type { UploaderBaseProps } from '@useupup/core';
+export type UploaderIcons = {
+    ContainerAddMoreIcon?: Type<unknown> | undefined;
+    FileDeleteIcon?: Type<unknown> | undefined;
+    CameraDeleteIcon?: Type<unknown> | undefined;
+    CameraCaptureIcon?: Type<unknown> | undefined;
+    CameraRotateIcon?: Type<unknown> | undefined;
+    LoaderIcon?: Type<unknown> | undefined;
+};
+export type UploaderProps = UploaderBaseProps & {
+    icons?: UploaderIcons | undefined;
+    style?: Record<string, string> | undefined;
+};

package/dist/styles.d.ts

@@ -0,0 +1,4 @@
+// Generated by scripts/emit-styles-dts.mjs — do not edit.
+// Declares the './styles' subpath (runtime target: ./tailwind-prefixed.css) so
+// TypeScript 6+ can resolve `import '@useupup/<framework>/styles'`.
+export {}