@uploadcn/react 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 UploadCN contributors
+
+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/README.md

@@ -1,3 +1,46 @@
-# Temporary Holding Version
+# @uploadcn/react
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+React hooks and headless, accessible upload primitives for
+[UploadCN](https://uploadcn.dev). The shadcn-styled components in the UploadCN registry
+are built on these.
+
+```bash
+npm install @uploadcn/react @uploadcn/core
+```
+
+```tsx
+import { s3Adapter } from "@uploadcn/core"
+import { Upload } from "@uploadcn/react"
+
+const adapter = s3Adapter({ endpoint: "/api/upload" })
+
+export function Uploader() {
+  return (
+    <Upload.Root adapter={adapter} accept="image/*" maxFiles={5}>
+      <Upload.Dropzone>Drop images or press Enter to browse</Upload.Dropzone>
+      <Upload.List>
+        {(item) => (
+          <Upload.Item item={item}>
+            <Upload.Name />
+            <Upload.Progress>
+              <Upload.ProgressIndicator />
+            </Upload.Progress>
+            <Upload.Status />
+            <Upload.Retry>Retry</Upload.Retry>
+            <Upload.Remove>Remove</Upload.Remove>
+          </Upload.Item>
+        )}
+      </Upload.List>
+    </Upload.Root>
+  )
+}
+```
+
+Hooks: `useUploader`, `useUpload`, `useUploadState`, `useUploadSelector`,
+`useUploadItem`, `useUploadProgress`, `useUploadValue`, `useDropzone`, `useWindowDrop`,
+`usePasteFiles`, `useFileValidation`, `useImageCompression`, `useImageCrop`,
+`useFilePreview`, `useNetworkStatus`, `useUploadGuard`.
+
+Requires React 19. Documentation: https://uploadcn.dev/docs/hooks
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,576 @@
+
+import { UploadAdapter, UploadError as UploadError$1, UploadItem, UploadStatus as UploadStatus$1, UploadSummary, Uploader, UploaderOptions, UploaderState, ValidateFilesResult, ValidationIssue, ValidationOptions } from "@uploadcn/core";
+import * as React$1 from "react";
+import { CompressImageOptions, CropArea, ImageTransformOptions } from "@uploadcn/core/image";
+//#region src/render.d.ts
+/**
+ * Replace a primitive's element, like Base UI's `render` prop:
+ * pass an element to clone (`render={<Button />}`) or a function that
+ * receives the merged props and the component state.
+ */
+type RenderProp<TState> = React$1.ReactElement<Record<string, unknown>> | ((props: Record<string, unknown>, state: TState) => React$1.ReactElement);
+type AnyProps = Record<string, unknown>;
+/**
+ * Merges two prop objects: event handlers run in sequence (unless the first
+ * calls `preventDefault`), classNames concatenate, styles shallow-merge,
+ * refs combine, and everything else from `overrides` wins.
+ */
+export declare function mergeProps(base: AnyProps, overrides: AnyProps): AnyProps;
+//#endregion
+//#region src/messages.d.ts
+/** Every user-facing string, so primitives can be translated. */
+interface UploadMessages {
+  status: Record<UploadStatus$1, string>;
+  retrying: string;
+  waitingForNetwork: string;
+  /** Live-region announcements. */
+  added: (count: number) => string;
+  uploaded: (name: string) => string;
+  failed: (name: string, reason: string) => string;
+  rejected: (name: string, reason: string) => string;
+  cancelled: (name: string) => string;
+  completed: (count: number) => string;
+  /** Accessible labels for item actions. */
+  remove: (name: string) => string;
+  cancel: (name: string) => string;
+  retry: (name: string) => string;
+  pause: (name: string) => string;
+  resume: (name: string) => string;
+  progress: (name: string) => string;
+  totalProgress: string;
+}
+export declare const defaultMessages: UploadMessages;
+/** A status label that also explains automatic retries and offline pauses. */
+export declare function getStatusLabel(item: Pick<UploadItem, "status" | "retryAt" | "pauseReason">, messages?: UploadMessages): string;
+//#endregion
+//#region src/use-uploader.d.ts
+interface UploaderCallbacks<TResult> {
+  onAdd?: (items: UploadItem<TResult>[]) => void;
+  onReject?: (item: UploadItem<TResult>) => void;
+  onSuccess?: (item: UploadItem<TResult>) => void;
+  onError?: (item: UploadItem<TResult>, error: UploadError$1) => void;
+  /** Called when the queue drains after uploads finished. */
+  onComplete?: (items: UploadItem<TResult>[]) => void;
+}
+interface UseUploaderOptions<TResult> extends Omit<UploaderOptions<TResult>, "adapter">, UploaderCallbacks<TResult> {
+  /**
+   * Where files go. Defaults to the adapter from the nearest
+   * `UploadConfigProvider`.
+   */
+  adapter?: UploadAdapter<TResult>;
+  /** Restore persisted uploads on mount (requires `persistence`). */
+  restore?: boolean;
+}
+/**
+ * Creates an upload engine bound to the component's lifetime. The instance
+ * is stable; option changes (including a new adapter) apply on the next
+ * render without recreating it.
+ */
+export declare function useUploader<TResult = unknown>(options?: UseUploaderOptions<TResult>): Uploader<TResult>;
+//#endregion
+//#region src/primitives.d.ts
+type ElementProps<TTag extends keyof React$1.JSX.IntrinsicElements, TState> = Omit<React$1.ComponentPropsWithRef<TTag>, "children"> & {
+  render?: RenderProp<TState>;
+  children?: React$1.ReactNode;
+};
+declare const OPTION_KEYS: readonly ["adapter", "autoUpload", "concurrency", "retry", "duplicates", "transform", "process", "persistence", "network", "progressInterval", "accept", "maxSize", "minSize", "maxFiles", "minFiles", "image", "media", "validate", "restore", "onAdd", "onReject", "onSuccess", "onError", "onComplete"];
+interface UploadRootState {
+  disabled: boolean;
+  isUploading: boolean;
+}
+interface UploadRootOwnProps<TResult> {
+  /** Allow selecting several files. Default `true` (unless `maxFiles` is 1). */
+  multiple?: boolean;
+  disabled?: boolean;
+  /**
+   * Renders hidden inputs with the values of successful uploads, so the
+   * component works in plain `<form>`s and server actions.
+   */
+  name?: string;
+  /** Value submitted per successful upload. Defaults to `result.key`, `result.url`, or the file name. */
+  getFormValue?: (item: UploadItem<TResult>) => string;
+  /**
+   * What the form submits under `name`: `"value"` (default) submits a value
+   * per successful upload; `"file"` submits the selected files themselves,
+   * so the component works as a plain file input (no upload needed).
+   */
+  submit?: "value" | "file";
+  /** Opens the camera on mobile (`<input capture>`). */
+  capture?: "user" | "environment";
+  /** Let users pick whole folders. */
+  directory?: boolean;
+  /** Translate or customize every string. */
+  messages?: Partial<UploadMessages>;
+  render?: RenderProp<UploadRootState>;
+  children?: React$1.ReactNode;
+}
+type DivProps = Omit<React$1.ComponentPropsWithRef<"div">, "onError" | "children">;
+type UploadRootProps<TResult = unknown> = DivProps & UploadRootOwnProps<TResult> & (({
+  uploader: Uploader<TResult>;
+} & { [K in (typeof OPTION_KEYS)[number]]?: never; }) | ({
+  uploader?: undefined;
+} & UseUploaderOptions<TResult>));
+/**
+ * The root of an upload UI. Pass uploader options directly
+ * (`<Upload adapter={…} maxFiles={5}>`) or an `uploader` from `useUploader`
+ * to control it from outside.
+ */
+export declare function UploadRoot<TResult = unknown>(props: UploadRootProps<TResult>): React$1.JSX.Element;
+interface UploadDropzoneState {
+  isDragging: boolean;
+  isDragReject: boolean;
+  disabled: boolean;
+}
+type UploadDropzoneProps = ElementProps<"div", UploadDropzoneState> & {
+  /**
+   * Clicking or pressing Enter/Space opens the file picker. Set `false` when
+   * the dropzone contains its own `UploadTrigger`. Default `true`.
+   */
+  clickable?: boolean;
+};
+export declare function UploadDropzone({ render, clickable, ...props }: UploadDropzoneProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type UploadTriggerProps = ElementProps<"button", {
+  disabled: boolean;
+}>;
+/** A button that opens the file picker. */
+export declare function UploadTrigger({ render, ...props }: UploadTriggerProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type UploadListProps = Omit<ElementProps<"ul", {
+  count: number;
+}>, "children"> & {
+  /**
+   * A template rendered once per item (`<UploadItem>…</UploadItem>`), or a
+   * function of the item for full control.
+   */
+  children?: React$1.ReactNode | ((item: UploadItem) => React$1.ReactNode);
+  /** Show only matching items (e.g. hide rejected ones). */
+  filter?: (item: UploadItem) => boolean;
+};
+/**
+ * A list of uploads. Children are rendered once per item, with the item in
+ * context; each item re-renders on its own progress without re-rendering
+ * its siblings.
+ */
+export declare function UploadList({ render, children, filter, ...props }: UploadListProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type UploadItemProps = ElementProps<"li", UploadItem> & {
+  /** The item to render. Optional inside `UploadList`, which provides it. */
+  item?: UploadItem;
+};
+/** Provides an item to the item-level primitives inside it. */
+export declare function UploadItemRoot({ item: itemProp, render, ...props }: UploadItemProps): React$1.JSX.Element;
+type UploadPreviewProps = Omit<ElementProps<"img", UploadItem>, "src"> & {
+  /** Shown for files that can't be previewed as images. */
+  fallback?: React$1.ReactNode;
+  /** Max thumbnail dimension in px. Default 256. */
+  thumbnailSize?: number;
+};
+/** An image thumbnail of the item, or `fallback` for other file types. */
+export declare function UploadPreview({ render, fallback, thumbnailSize, alt, ...props }: UploadPreviewProps): React$1.JSX.Element | null;
+export declare function UploadName({ render, ...props }: ElementProps<"span", UploadItem>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type UploadSizeProps = ElementProps<"span", UploadItem> & {
+  /** `"total"` shows the size; `"progress"` shows "3 MB / 10 MB" while uploading. */
+  format?: "total" | "progress";
+};
+export declare function UploadSize({ render, format, ...props }: UploadSizeProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+/** Upload speed and time remaining, while uploading. */
+export declare function UploadSpeed({ render, ...props }: ElementProps<"span", UploadItem>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+export declare function UploadStatus({ render, ...props }: ElementProps<"span", UploadItem>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+/** The item's error or validation message, when it has one. */
+export declare function UploadError({ render, ...props }: ElementProps<"p", UploadItem>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+/** Renders its children only once the item uploaded successfully. */
+export declare function UploadSuccess({ children }: {
+  children?: React$1.ReactNode;
+}): React$1.JSX.Element | null;
+interface UploadProgressState {
+  percent: number;
+  indeterminate: boolean;
+  complete: boolean;
+}
+type UploadProgressProps = ElementProps<"div", UploadProgressState>;
+/**
+ * An accessible progress bar. Inside `<UploadItem>` it tracks that item;
+ * anywhere else it tracks the whole queue.
+ */
+export declare function UploadProgress(props: UploadProgressProps): React$1.JSX.Element;
+/** The filled part of `UploadProgress`. */
+export declare function UploadProgressIndicator({ render, ...props }: ElementProps<"div", UploadProgressState>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type ActionProps = ElementProps<"button", UploadItem> & {
+  /** Render (disabled) even when the action doesn't apply. */
+  forceMount?: boolean;
+};
+export declare const UploadRemove: {
+  ({ render, forceMount, ...props }: ActionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+  displayName: string;
+};
+export declare const UploadCancel: {
+  ({ render, forceMount, ...props }: ActionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+  displayName: string;
+};
+export declare const UploadRetry: {
+  ({ render, forceMount, ...props }: ActionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+  displayName: string;
+};
+export declare const UploadPause: {
+  ({ render, forceMount, ...props }: ActionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+  displayName: string;
+};
+export declare const UploadResume: {
+  ({ render, forceMount, ...props }: ActionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+  displayName: string;
+};
+/** Renders its children only while the queue is empty. */
+export declare function UploadEmpty({ children }: {
+  children?: React$1.ReactNode;
+}): React$1.JSX.Element | null;
+type QueueActionProps = ElementProps<"button", {
+  count: number;
+}> & {
+  forceMount?: boolean;
+};
+/** Starts idle uploads (when `autoUpload` is off). Hidden when there are none. */
+export declare function UploadStart({ render, forceMount, ...props }: QueueActionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+/** Removes finished items (or every item with `all`). Hidden when there's nothing to clear. */
+export declare function UploadClear({ render, forceMount, all, ...props }: QueueActionProps & {
+  all?: boolean;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+//#endregion
+//#region src/context.d.ts
+interface UploadContextValue {
+  uploader: Uploader<unknown>;
+  /** Opens the native file picker. */
+  openFileDialog: () => void;
+  /** Adds files through the same path as the picker and drops. */
+  addFiles: (files: File[]) => void;
+  accept: ValidationOptions["accept"];
+  multiple: boolean;
+  disabled: boolean;
+  messages: UploadMessages;
+  inputId: string;
+}
+export declare const UploadContext: React$1.Context<UploadContextValue | null>;
+export declare function useUploadContext(): UploadContextValue;
+export declare const UploadItemContext: React$1.Context<UploadItem<unknown> | null>;
+/**
+ * The current item. Inside `<UploadItem>` it reads from context; pass an id
+ * to subscribe to any item from within `<Upload>`.
+ */
+export declare function useUploadItem<TResult = unknown>(id?: string): UploadItem<TResult>;
+//#endregion
+//#region src/use-upload.d.ts
+interface UseUploadReturn<TResult> {
+  uploader: Uploader<TResult>;
+  items: readonly UploadItem<TResult>[];
+  summary: UploadSummary;
+  online: boolean;
+  add: Uploader<TResult>["add"];
+  start: Uploader<TResult>["start"];
+  pause: Uploader<TResult>["pause"];
+  resume: Uploader<TResult>["resume"];
+  cancel: Uploader<TResult>["cancel"];
+  retry: Uploader<TResult>["retry"];
+  remove: Uploader<TResult>["remove"];
+  clearCompleted: Uploader<TResult>["clearCompleted"];
+  update: Uploader<TResult>["update"];
+}
+/**
+ * The all-in-one hook: creates an uploader and returns its items, an
+ * aggregate summary and bound actions.
+ *
+ * @example
+ * const { items, add, summary } = useUpload({ adapter: s3Adapter({ endpoint: "/api/upload" }) })
+ */
+export declare function useUpload<TResult = unknown>(options: UseUploaderOptions<TResult>): UseUploadReturn<TResult>;
+/** Like `useUpload`, for an uploader created elsewhere (e.g. from context). */
+export declare function useUploadState<TResult>(uploader: Uploader<TResult>): UseUploadReturn<TResult>;
+/** Aggregate progress, speed, ETA and counts for the whole queue. */
+export declare function useUploadProgress<TResult>(uploader: Uploader<TResult>): UploadSummary;
+/**
+ * Derives form values from successful uploads — e.g. object keys for a
+ * server action or react-hook-form field. Pass a stable `getValue` (defined
+ * outside the component or memoized) to keep the returned array stable.
+ */
+export declare function useUploadValue<TResult, TValue>(uploader: Uploader<TResult>, getValue: (item: UploadItem<TResult>) => TValue): TValue[];
+//#endregion
+//#region src/use-upload-selector.d.ts
+/**
+ * Subscribes to a slice of uploader state. The component re-renders only
+ * when the selected value changes (by `isEqual`, default `Object.is`).
+ */
+export declare function useUploadSelector<TResult, TSelected>(uploader: Uploader<TResult>, selector: (state: UploaderState<TResult>) => TSelected, isEqual?: (a: TSelected, b: TSelected) => boolean): TSelected;
+/** Shallow array equality, for selectors that return lists. */
+export declare function shallowArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean;
+//#endregion
+//#region src/use-dropzone.d.ts
+interface UseDropzoneOptions {
+  /** Receives every dropped file, with folders expanded. */
+  onDrop: (files: File[]) => void;
+  /** Used to flag drags of unsupported types before they are dropped. */
+  accept?: ValidationOptions["accept"];
+  /** Reject drags carrying more than one file. */
+  multiple?: boolean;
+  disabled?: boolean;
+}
+interface DropzoneState {
+  /** Files are being dragged over the zone. */
+  isDragging: boolean;
+  /** The dragged files don't match `accept` (or `multiple`). */
+  isDragReject: boolean;
+}
+interface DropzoneHandlers {
+  onDragEnter: React$1.DragEventHandler;
+  onDragOver: React$1.DragEventHandler;
+  onDragLeave: React$1.DragEventHandler;
+  onDrop: React$1.DragEventHandler;
+}
+/**
+ * Drag-and-drop state and handlers for any element. Uses an enter/leave
+ * counter so moving over child elements doesn't flicker the drag state.
+ */
+export declare function useDropzone(options: UseDropzoneOptions): {
+  handlers: DropzoneHandlers;
+  /** Files are being dragged over the zone. */
+  isDragging: boolean;
+  /** The dragged files don't match `accept` (or `multiple`). */
+  isDragReject: boolean;
+};
+//#endregion
+//#region src/use-window-drop.d.ts
+interface UseWindowDropOptions {
+  /** Called with files dropped anywhere on the page. */
+  onDrop: (files: File[]) => void;
+  /** Turn detection off without unmounting. Default `true`. */
+  enabled?: boolean;
+}
+/**
+ * Detects files dragged over the browser window — for "drop anywhere"
+ * overlays. Drops already handled by an inner dropzone (which calls
+ * `preventDefault`) are ignored, so the two can coexist.
+ */
+export declare function useWindowDrop({ onDrop, enabled }: UseWindowDropOptions): {
+  isDragging: boolean;
+};
+//#endregion
+//#region src/use-paste-files.d.ts
+interface UsePasteFilesOptions {
+  onPaste: (files: File[]) => void;
+  /**
+   * Element to listen on. Defaults to the whole document, which is what chat
+   * inputs usually want (paste a screenshot anywhere).
+   */
+  target?: React$1.RefObject<HTMLElement | null>;
+  enabled?: boolean;
+}
+/**
+ * Uploads files and screenshots pasted from the clipboard. Text pastes are
+ * left alone so inputs keep working normally.
+ */
+export declare function usePasteFiles({ onPaste, target, enabled }: UsePasteFilesOptions): void;
+//#endregion
+//#region src/use-file-validation.d.ts
+/**
+ * Standalone validation for flows that don't upload immediately — e.g.
+ * collecting files in a form and submitting them later. Uses the same rules
+ * as the uploader, including async and custom validators.
+ */
+export declare function useFileValidation(options: ValidationOptions): {
+  validate: (files: readonly File[], context?: {
+    existingCount?: number;
+  }) => Promise<ValidateFilesResult>;
+  validateCount: (count: number) => ValidationIssue | null;
+  isValidating: boolean;
+};
+//#endregion
+//#region src/use-image.d.ts
+interface CompressionStats {
+  before: number;
+  after: number;
+  /** Fraction saved, 0–1. */
+  saved: number;
+}
+/** Compresses images on demand and reports how much was saved. */
+export declare function useImageCompression(options?: CompressImageOptions): {
+  compress: (file: File) => Promise<File>;
+  isCompressing: boolean;
+  stats: CompressionStats | null;
+  error: Error | null;
+};
+interface ImageCropState {
+  /** Pan offset, in the units of your crop UI. */
+  position: {
+    x: number;
+    y: number;
+  };
+  zoom: number;
+  /** Degrees, clockwise. */
+  rotation: number;
+  flipHorizontal: boolean;
+  flipVertical: boolean;
+  /** Crop rectangle in source-image pixels, reported by the crop UI. */
+  area: CropArea | null;
+}
+interface UseImageCropOptions {
+  minZoom?: number;
+  maxZoom?: number;
+}
+/**
+ * UI-agnostic crop/rotate/zoom state with an `apply` that renders the
+ * result. Pair it with any crop UI (react-easy-crop, a canvas, sliders).
+ */
+export declare function useImageCrop({ minZoom, maxZoom }?: UseImageCropOptions): {
+  minZoom: number;
+  maxZoom: number;
+  apply: (file: File, options?: Omit<ImageTransformOptions, "crop" | "rotate">) => Promise<File>;
+  setPosition: (position: {
+    x: number;
+    y: number;
+  }) => void;
+  setZoom: (zoom: number) => void;
+  setRotation: (rotation: number) => void;
+  rotateBy: (degrees: number) => void;
+  flip: (axis: "horizontal" | "vertical") => void;
+  setArea: (area: CropArea | null) => void;
+  reset: () => void;
+  /** Pan offset, in the units of your crop UI. */
+  position: {
+    x: number;
+    y: number;
+  };
+  zoom: number;
+  /** Degrees, clockwise. */
+  rotation: number;
+  flipHorizontal: boolean;
+  flipVertical: boolean;
+  /** Crop rectangle in source-image pixels, reported by the crop UI. */
+  area: CropArea | null;
+};
+//#endregion
+//#region src/use-file-preview.d.ts
+type PreviewKind = "image" | "video" | "audio" | "pdf" | "file";
+export declare function getPreviewKind(file: {
+  type: string;
+  name: string;
+}): PreviewKind;
+interface UseFilePreviewOptions {
+  /**
+   * For images, render a downscaled thumbnail no larger than this many
+   * pixels instead of decoding the full image — keeps large galleries fast.
+   */
+  thumbnailSize?: number;
+}
+/**
+ * An object URL for previewing a file, revoked automatically when the file
+ * changes or the component unmounts.
+ */
+export declare function useFilePreview(file: File | Blob | null | undefined, { thumbnailSize }?: UseFilePreviewOptions): string | null;
+//#endregion
+//#region src/use-network.d.ts
+/**
+ * `navigator.onLine`, kept in sync with `online`/`offline` events. `true`
+ * on the server. Note that "online" only means a network interface is up.
+ */
+export declare function useNetworkStatus(): boolean;
+interface UseUploadGuardOptions {
+  /** Default `true`. */
+  enabled?: boolean;
+}
+/**
+ * Warns before closing or reloading the tab while uploads are in progress.
+ * Browsers show their own generic message; custom text is not supported.
+ */
+export declare function useUploadGuard<TResult>(uploader: Uploader<TResult>, { enabled }?: UseUploadGuardOptions): boolean;
+//#endregion
+//#region src/config.d.ts
+/**
+ * App-wide defaults for every uploader below the provider: where files go
+ * (`adapter`), limits, retries and messages. Props on a component win.
+ */
+interface UploadConfig extends Partial<Omit<UploaderOptions<unknown>, "adapter">> {
+  adapter?: UploadAdapter<any>;
+  messages?: Partial<UploadMessages>;
+}
+/**
+ * Configure uploads once — usually in your root layout — and every Upload
+ * component and block uses it. Nest providers to override per section.
+ *
+ * @example
+ * <UploadConfigProvider adapter={cloudinaryAdapter({ cloudName, uploadPreset })}>
+ *   {children}
+ * </UploadConfigProvider>
+ */
+export declare function UploadConfigProvider({ children, ...config }: UploadConfig & {
+  children?: React$1.ReactNode;
+}): React$1.JSX.Element;
+/** The merged config from the nearest `UploadConfigProvider`s. */
+export declare function useUploadConfig(): UploadConfig;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Headless, accessible upload primitives. Style them directly or use the
+ * shadcn-styled versions from the UploadCN registry.
+ */
+export declare const Upload: {
+  Root: typeof UploadRoot;
+  Dropzone: typeof UploadDropzone;
+  Trigger: typeof UploadTrigger;
+  List: typeof UploadList;
+  Item: typeof UploadItemRoot;
+  Preview: typeof UploadPreview;
+  Name: typeof UploadName;
+  Size: typeof UploadSize;
+  Speed: typeof UploadSpeed;
+  Status: typeof UploadStatus;
+  Error: typeof UploadError;
+  Success: typeof UploadSuccess;
+  Progress: typeof UploadProgress;
+  ProgressIndicator: typeof UploadProgressIndicator;
+  Remove: {
+    ({ render, forceMount, ...props }: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children"> & {
+      render?: RenderProp<import("@uploadcn/core").UploadItem<unknown>> | undefined;
+      children?: React.ReactNode;
+    } & {
+      forceMount?: boolean;
+    }): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    displayName: string;
+  };
+  Cancel: {
+    ({ render, forceMount, ...props }: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children"> & {
+      render?: RenderProp<import("@uploadcn/core").UploadItem<unknown>> | undefined;
+      children?: React.ReactNode;
+    } & {
+      forceMount?: boolean;
+    }): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    displayName: string;
+  };
+  Retry: {
+    ({ render, forceMount, ...props }: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children"> & {
+      render?: RenderProp<import("@uploadcn/core").UploadItem<unknown>> | undefined;
+      children?: React.ReactNode;
+    } & {
+      forceMount?: boolean;
+    }): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    displayName: string;
+  };
+  Pause: {
+    ({ render, forceMount, ...props }: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children"> & {
+      render?: RenderProp<import("@uploadcn/core").UploadItem<unknown>> | undefined;
+      children?: React.ReactNode;
+    } & {
+      forceMount?: boolean;
+    }): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    displayName: string;
+  };
+  Resume: {
+    ({ render, forceMount, ...props }: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children"> & {
+      render?: RenderProp<import("@uploadcn/core").UploadItem<unknown>> | undefined;
+      children?: React.ReactNode;
+    } & {
+      forceMount?: boolean;
+    }): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    displayName: string;
+  };
+  Empty: typeof UploadEmpty;
+  Start: typeof UploadStart;
+  Clear: typeof UploadClear;
+};
+//#endregion
+export type { CompressionStats, DropzoneHandlers, DropzoneState, ImageCropState, PreviewKind, RenderProp, UploadConfig, UploadContextValue, UploadDropzoneProps, UploadDropzoneState, UploadItemProps, UploadListProps, UploadMessages, UploadPreviewProps, UploadProgressProps, UploadProgressState, UploadRootProps, UploadRootState, UploadSizeProps, UploadTriggerProps, UploaderCallbacks, UseDropzoneOptions, UseFilePreviewOptions, UseImageCropOptions, UsePasteFilesOptions, UseUploadGuardOptions, UseUploadReturn, UseUploaderOptions, UseWindowDropOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["React","UploadStatus","UploadError","React","React","React","React","React","_$__render0.RenderProp"],"sources":["../src/render.ts","../src/messages.ts","../src/use-uploader.ts","../src/primitives.tsx","../src/context.ts","../src/use-upload.ts","../src/use-upload-selector.ts","../src/use-dropzone.ts","../src/use-window-drop.ts","../src/use-paste-files.ts","../src/use-file-validation.ts","../src/use-image.ts","../src/use-file-preview.ts","../src/use-network.ts","../src/config.tsx","../src/index.ts"],"mappings":"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"}