@gentleduck/upload 0.2.6 → 0.3.0

package/dist/index-DsZHPmJm.d.ts

@@ -0,0 +1,225 @@
+import { O as Contracts, i as Store, n as Engine } from "./index-DCqyBVcx.js";
+import * as React$1 from "react";
+import React from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/react/uploader.types.d.ts
+/**
+ * Public typings and namespaces consumed by React hook components.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare namespace Uploader {
+  /**
+   * Return state payload returned by the `useUploader` hook.
+   *
+   * @template M - Intent map type
+   * @template C - Cursor map type
+   * @template P - Purpose string union type
+   * @template R - Backend result shape
+   */
+  type State<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base> = Pick<Store.UploadStore<M, C, P, R>, 'dispatch' | 'on' | 'off'> & {
+    /** List of all registered upload items currently tracked. */items: Array<Engine.Item<M, C, P, R>>; /** Upload items grouped by phase. */
+    byPhase: Record<Engine.Phase, Array<Engine.Item<M, C, P, R>>>; /** Subset of items currently active in the transfer phase. */
+    uploading: Array<Engine.Item<M, C, P, R>>; /** Subset of items currently paused. */
+    paused: Array<Engine.Item<M, C, P, R>>; /** Subset of items that successfully completed uploading and backend finalization. */
+    completed: Array<Engine.Item<M, C, P, R>>; /** Subset of items currently in the error state. */
+    failed: Array<Engine.Item<M, C, P, R>>; /** Subset of items validated and waiting to begin uploading. */
+    ready: Array<Engine.Item<M, C, P, R>>;
+  };
+  /**
+   * Bound action callbacks returned by context hooks.
+   *
+   * Houses both the bound dispatchers and the raw underlying store reference.
+   *
+   * @template M - Intent map type
+   * @template C - Cursor map type
+   * @template P - Purpose string union type
+   * @template R - Backend result shape
+   */
+  type IActions<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base> = Pick<Store.UploadStore<M, C, P, R>, 'dispatch' | 'on'> & {
+    /** The raw upload store instance. */store: Store.UploadStore<M, C, P, R>;
+  };
+  /**
+   * Props for the `<UploadProvider>` component.
+   */
+  interface ProviderProps<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base> {
+    /** The upload store instance to distribute. */
+    store: Store.UploadStore<M, C, P, R>;
+    /** React child elements. */
+    children: React.ReactNode;
+  }
+}
+//#endregion
+//#region src/react/upload-provider.d.ts
+/**
+ * Context provider that distributes the upload store across the React component hierarchy.
+ *
+ * Wrap this provider around the top of your layout to enable child hooks like `useUploader`
+ * to access upload status.
+ *
+ * @example
+ * ```tsx
+ * const store = createUploadStore({ ... });
+ *
+ * function App() {
+ *   return (
+ *     <UploadProvider store={store}>
+ *       <UploadForm />
+ *     </UploadProvider>
+ *   );
+ * }
+ * ```
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function UploadProvider<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>({
+  store,
+  children
+}: Uploader.ProviderProps<M, C, P, R>): react_jsx_runtime0.JSX.Element;
+/**
+ * Returns the active upload store instance from context.
+ * Throws a runtime exception if called outside an `<UploadProvider>`.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function useUploadStore<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(): Store.UploadStore<M, C, P, R>;
+/**
+ * Runtime type guard: returns `true` when `value` exposes the upload-store
+ * surface (`getSnapshot`, `subscribe`, `dispatch`, `on`, `off`, `waitFor`).
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function isUploadStore<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(value: unknown): value is Store.UploadStore<M, C, P, R>;
+//#endregion
+//#region src/react/use-dropzone.d.ts
+/**
+ * Test a file against one token from an `accept` string. A token is a MIME type
+ * (`image/png`), a MIME wildcard (`image/*`), or a filename extension (`.pdf`).
+ * @internal exported for tests.
+ */
+declare function matchesAcceptToken(file: File, token: string): boolean;
+/**
+ * True when `file` satisfies an `accept` list (comma-separated tokens). An empty
+ * or absent list accepts everything.
+ * @internal exported for tests.
+ */
+declare function fileMatchesAccept(file: File, accept?: string): boolean;
+/**
+ * Filter a dropped/selected file list by `accept` and collapse to a single file
+ * when `multiple` is false.
+ * @internal exported for tests.
+ */
+declare function selectFiles(files: File[], opts: {
+  accept?: string | undefined;
+  multiple?: boolean | undefined;
+}): File[];
+/** Options for {@link useDropzone}. */
+type UseDropzoneOptions<P extends string> = {
+  /** Purpose forwarded to the `addFiles` command. */purpose: P; /** Optional caller metadata forwarded to every backend API call. */
+  meta?: Record<string, unknown>;
+  /**
+   * Comma-separated `accept` list (`"image/*,.pdf"`). Filters dropped files and
+   * populates the input's `accept` attribute. Absent = accept everything.
+   */
+  accept?: string; /** Allow multiple files. Defaults to `true`. */
+  multiple?: boolean; /** Disable all interaction (no drop, no click-to-open). Defaults to `false`. */
+  disabled?: boolean; /** Do not open the file dialog when the root is clicked. Defaults to `false`. */
+  noClick?: boolean;
+  /**
+   * Override the default dispatch. When provided, accepted files are handed here
+   * instead of being dispatched as `addFiles` to the store.
+   */
+  onFiles?: (files: File[]) => void; /** Store instance to dispatch to. Falls back to the `<UploadProvider>` store. */
+  store?: Store.UploadStore<Contracts.Intent.Map, Contracts.Cursor.Map<Contracts.Intent.Map>, P, Contracts.Result.Base>;
+};
+/** Return value of {@link useDropzone}. */
+type UseDropzoneReturn = {
+  /** True while files are being dragged over the root. */isDragging: boolean; /** Programmatically open the native file picker. */
+  open: () => void; /** Ref to attach to the hidden `<input type="file">`. */
+  inputRef: React$1.RefObject<HTMLInputElement | null>; /** Spread onto the drop-target element. */
+  getRootProps: (extra?: React$1.HTMLAttributes<HTMLElement>) => React$1.HTMLAttributes<HTMLElement>; /** Spread onto the hidden `<input type="file">`. */
+  getInputProps: (extra?: React$1.InputHTMLAttributes<HTMLInputElement>) => React$1.InputHTMLAttributes<HTMLInputElement> & {
+    ref: React$1.Ref<HTMLInputElement>;
+  };
+};
+/**
+ * Headless drag-and-drop / file-picker hook.
+ *
+ * Wires drop and file-input events to the upload store's `addFiles` command
+ * (or a custom `onFiles` handler). Returns prop-getters for the drop target and
+ * a hidden file input plus a live `isDragging` flag — styling and markup are
+ * entirely yours.
+ *
+ * @example
+ * ```tsx
+ * function Drop() {
+ *   const { getRootProps, getInputProps, isDragging, open } = useDropzone({
+ *     purpose: 'attachment',
+ *     accept: 'image/*',
+ *   });
+ *   return (
+ *     <div {...getRootProps()} data-active={isDragging}>
+ *       <input {...getInputProps()} />
+ *       <button type="button" onClick={open}>Choose files</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function useDropzone<P extends string>(options: UseDropzoneOptions<P>): UseDropzoneReturn;
+//#endregion
+//#region src/react/use-uploader.d.ts
+/**
+ * Hook to consume the upload store state, track files, and interact with the upload engine.
+ *
+ * Exposes files, categorizes items by status phase (ready, uploading, paused, completed, failed),
+ * and registers action dispatchers.
+ *
+ * Can optionally be passed a specific store instance directly. Otherwise, it will read the store from context.
+ *
+ * @example
+ * ```tsx
+ * function UploadForm() {
+ *   const { items, uploading, dispatch } = useUploader();
+ *
+ *   const onFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+ *     if (e.target.files) {
+ *       dispatch({ type: 'addFiles', files: Array.from(e.target.files), purpose: 'avatar' });
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <input type="file" onChange={onFileChange} multiple />
+ *       <ul>
+ *         {items.map(item => (
+ *           <li key={item.localId}>{item.fingerprint.name} - {item.phase}</li>
+ *         ))}
+ *       </ul>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @template M - Intent map type
+ * @template C - Cursor map type
+ * @template P - Purpose string union type
+ * @template R - Backend result shape
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function useUploader<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(providedStore?: Store.UploadStore<M, C, P, R> | undefined): Uploader.State<M, C, P, R>;
+/**
+ * Returns the store's imperative actions (dispatch, event bindings) along with a direct
+ * reference to the store instance. Does not trigger React re-renders on upload progress or state changes.
+ *
+ * Use this when you only need to trigger commands or subscribe to events without binding UI lists.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function useUploaderActions<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(): Uploader.IActions<M, C, P, R>;
+/**
+ * Creates a bound `useUploader` hook pre-configured for a specific store instance.
+ *
+ * Useful for building static multi-uploader widgets or context-free setups.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function createUploadFactory<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(store: Store.UploadStore<M, C, P, R>): () => Uploader.State<M, C, P, R>;
+//#endregion
+export { UseDropzoneReturn as a, selectFiles as c, isUploadStore as d, useUploadStore as f, UseDropzoneOptions as i, useDropzone as l, useUploader as n, fileMatchesAccept as o, Uploader as p, useUploaderActions as r, matchesAcceptToken as s, createUploadFactory as t, UploadProvider as u };

package/dist/index-KROXtLQh.d.ts

@@ -0,0 +1,281 @@
+import { O as Contracts } from "./index-DCqyBVcx.js";
+
+//#region src/strategies/multipart/index.d.ts
+/**
+ * Namespace containing types and interfaces specific to the S3/MinIO multipart upload strategy.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare namespace MultipartStrategy {
+  /**
+   * Configuration options for the multipart upload strategy.
+   */
+  type Config = {
+    /** Maximum concurrent HTTP PUT part uploads. Defaults to 4. */maxPartConcurrency?: number;
+    /**
+     * Optional case-insensitive list of trusted hosts (with optional port, e.g. `upload.example.com`).
+     * When specified, every signed part URL must match one of the listed hosts.
+     */
+    allowedHosts?: string[];
+    /**
+     * When `true`, allows private network IP addresses (loopback, link-local, RFC1918) in signed part URLs.
+     * Defaults to `false`.
+     */
+    allowPrivateHosts?: boolean;
+  };
+  /**
+   * Intent payload detailing part sizing and active upload session IDs returned by backends.
+   */
+  type Intent = {
+    /** Discriminant matching strategy configuration registry keys. */strategy: 'multipart'; /** Unique database identifier for the file resource. */
+    fileId: string; /** Active multipart session ID returned by S3/GCS. */
+    uploadId: string; /** Chunk size in bytes for each part slice (typically 5MB minimum). */
+    partSize: number; /** Total count of parts predicted for this file size. */
+    partCount: number; /** Optional array of pre-generated URLs and headers for each part (if signed up front). */
+    parts?: Array<{
+      partNumber: number;
+      url: string;
+      headers?: Record<string, string>;
+    }>;
+  };
+  /**
+   * Persisted resume state for multipart strategy uploads.
+   */
+  type Cursor = {
+    /** List of completed parts. */done: Array<{
+      partNumber: number;
+      etag: string;
+      size: number;
+    }>;
+    /**
+     * True if the backend assembled the parts.
+     * Prevents repeating completeMultipart calls on subsequent resume attempts.
+     */
+    completed?: true;
+  };
+}
+/**
+ * S3/GCS-compatible Resumable Multipart Upload Strategy.
+ *
+ * Slices files into chunks, uploads them concurrently using S3 PUT requests,
+ * and completes the upload on the backend once all chunks are transferred.
+ *
+ * @example
+ * ```ts
+ * const registry = createStrategyRegistry([
+ *   multipartStrategy({ maxPartConcurrency: 4 })
+ * ]);
+ * ```
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function multipartStrategy<M extends Contracts.Intent.Map & {
+  multipart: MultipartStrategy.Intent;
+}, C extends Contracts.Cursor.Map<M> & {
+  multipart?: MultipartStrategy.Cursor;
+}, P extends string = string, R extends Contracts.Result.Base = Contracts.Result.Base>(opts?: MultipartStrategy.Config): Contracts.Strategy.Me<M, C, P, R, 'multipart'>;
+//#endregion
+//#region src/strategies/post/index.d.ts
+/**
+ * Types for the presigned HTTP POST upload strategy.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare namespace PostStrategy {
+  /**
+   * Presigned HTTP POST strategy configuration options.
+   */
+  type Config = {
+    /**
+     * Case-insensitive allow-list of host names (with optional port). When
+     * set, the presigned POST URL must match a listed host or it is rejected.
+     */
+    allowedHosts?: string[];
+    /**
+     * When `true`, allow private-network IP literals in the POST URL.
+     * Defaults to `false`.
+     */
+    allowPrivateHosts?: boolean;
+    /**
+     * Retries after the first attempt for transient network failures.
+     * Defaults to the shared retry default (3).
+     */
+    maxRetries?: number;
+  };
+  /**
+   * Presigned HTTP POST intent payload mapping parameters returned by backend endpoints.
+   */
+  type Intent = {
+    /** Discriminant identifier matching strategy configuration registry keys. */strategy: 'post'; /** Unique database identifier for the file resource. */
+    fileId: string; /** Presigned POST action destination URL (e.g. presigned S3/GCS bucket location). */
+    url: string; /** Key/value pair list representing form properties (e.g. AWS credential fields, policies). */
+    fields: Record<string, string>; /** Optional epoch string indicating when the pre-signed credentials lapse. */
+    expiresAt?: string;
+  };
+  /**
+   * Direct strategy cursor state representing that no resumable bytes exist.
+   */
+  type Cursor = Record<string, never>;
+}
+/** Convenience alias for {@link PostStrategy.Intent}. */
+type PostIntent = PostStrategy.Intent;
+/**
+ * Presigned HTTP POST form strategy.
+ *
+ * Sends the entire file along with backend policy fields as a single
+ * `multipart/form-data` request body. Does not support resumability.
+ *
+ * Security: the presigned URL is backend-supplied and flows straight to the
+ * transport, so a compromised backend or MITM could return a `file:`,
+ * `javascript:`, or private-network URL. Every URL is checked with
+ * {@link validateUploadUrl}; set {@link PostStrategy.Config.allowedHosts} to
+ * lock it to known hosts, or leave `allowPrivateHosts` at its default `false`
+ * to block loopback/private addresses.
+ *
+ * @example
+ * ```ts
+ * const strategies = createStrategyRegistry([
+ *   PostStrategy({ allowedHosts: ['uploads.example.com'] }),
+ *   MultipartStrategy()
+ * ]);
+ * ```
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function PostStrategy<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(opts?: PostStrategy.Config): Contracts.Strategy.Me<M, C, P, R, 'post'>;
+//#endregion
+//#region src/strategies/put/index.d.ts
+/**
+ * Types for the single-request presigned HTTP PUT upload strategy.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare namespace PutStrategy {
+  /**
+   * Presigned HTTP PUT strategy configuration options.
+   */
+  type Config = {
+    /**
+     * Case-insensitive allow-list of host names (with optional port). When
+     * set, the presigned PUT URL must match a listed host or it is rejected.
+     */
+    allowedHosts?: string[];
+    /**
+     * When `true`, allow private-network IP literals in the PUT URL.
+     * Defaults to `false`.
+     */
+    allowPrivateHosts?: boolean;
+    /**
+     * Retries after the first attempt for transient network failures.
+     * Defaults to the shared retry default (3).
+     */
+    maxRetries?: number;
+  };
+  /**
+   * Presigned HTTP PUT intent payload. The whole file body is sent in one
+   * request to a backend-signed URL (e.g. S3 `putObject`, GCS signed PUT).
+   */
+  type Intent = {
+    /** Discriminant identifier matching strategy configuration registry keys. */strategy: 'put'; /** Unique database identifier for the file resource. */
+    fileId: string; /** Presigned PUT destination URL. */
+    url: string; /** Optional request headers required by the signature (e.g. `Content-Type`). */
+    headers?: Record<string, string>; /** Optional epoch string indicating when the pre-signed credentials lapse. */
+    expiresAt?: string;
+  };
+  /**
+   * Direct strategy cursor state representing that no resumable bytes exist.
+   */
+  type Cursor = Record<string, never>;
+}
+/** Convenience alias for {@link PutStrategy.Intent}. */
+type PutIntent = PutStrategy.Intent;
+/**
+ * Presigned single-request HTTP PUT strategy.
+ *
+ * Sends the entire file as the request body to a backend-signed URL in one PUT.
+ * The most common direct-to-storage pattern (S3 `putObject`, GCS/Azure signed
+ * PUT). Not resumable — use {@link multipartStrategy} or the tus strategy for
+ * resumable transfers.
+ *
+ * Security: the presigned URL is backend-supplied and flows straight to the
+ * transport, so a compromised backend or MITM could return a `file:`,
+ * `javascript:`, or private-network URL. Every URL is checked with
+ * {@link validateUploadUrl}; set {@link PutStrategy.Config.allowedHosts} to
+ * lock it to known hosts, or leave `allowPrivateHosts` at its default `false`
+ * to block loopback/private addresses.
+ *
+ * @example
+ * ```ts
+ * const strategies = createStrategyRegistry([
+ *   PutStrategy({ allowedHosts: ['uploads.example.com'] }),
+ *   multipartStrategy(),
+ * ]);
+ * ```
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function PutStrategy<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(opts?: PutStrategy.Config): Contracts.Strategy.Me<M, C, P, R, 'put'>;
+//#endregion
+//#region src/strategies/registry/index.d.ts
+/**
+ * Create an empty strategy registry. Register upload strategies with `set`, then
+ * resolve them by id with `get` / `has`.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function createStrategyRegistry<M extends Contracts.Intent.Map, C extends Contracts.Cursor.Map<M>, P extends string, R extends Contracts.Result.Base = Contracts.Result.Base>(): Contracts.Strategy.Registry<M, C, P, R>;
+//#endregion
+//#region src/strategies/tus/index.d.ts
+/**
+ * Types for the tus resumable upload strategy.
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare namespace TusStrategy {
+  /**
+   * Configuration options for the tus strategy.
+   */
+  type Config = {
+    /** PATCH chunk size in bytes. Overridden by `intent.chunkSize`. Defaults to 8 MiB. */chunkSize?: number;
+    /**
+     * Case-insensitive allow-list of host names (with optional port). When set,
+     * the tus upload URL must match a listed host or it is rejected.
+     */
+    allowedHosts?: string[];
+    /**
+     * When `true`, allow private-network IP literals in the tus URL.
+     * Defaults to `false`.
+     */
+    allowPrivateHosts?: boolean; /** Retries after the first attempt for transient PATCH/HEAD failures. Defaults to 3. */
+    maxRetries?: number;
+  };
+  /**
+   * tus intent payload. The backend has already created the upload; `url` is the
+   * ready upload resource to PATCH against.
+   */
+  type Intent = {
+    /** Discriminant matching strategy configuration registry keys. */strategy: 'tus'; /** Unique database identifier for the file resource. */
+    fileId: string; /** Ready tus upload URL (backend-created via the creation extension). */
+    url: string; /** Optional per-upload chunk size override in bytes. */
+    chunkSize?: number; /** Optional extra headers to send on every request (e.g. auth). */
+    headers?: Record<string, string>;
+  };
+  /**
+   * Persisted resume state: the last acknowledged upload offset in bytes.
+   */
+  type Cursor = {
+    /** Byte offset already accepted by the server. */offset: number;
+  };
+}
+/** Convenience alias for {@link TusStrategy.Intent}. */
+type TusIntent = TusStrategy.Intent;
+/**
+ * tus resumable upload strategy (creation-less).
+ *
+ * @example
+ * ```ts
+ * const registry = createStrategyRegistry([
+ *   TusStrategy({ allowedHosts: ['tus.example.com'], chunkSize: 8 * 1024 * 1024 }),
+ * ]);
+ * ```
+ * @author wildduck2 <https://github.com/wildduck2>
+ */
+declare function TusStrategy<M extends Contracts.Intent.Map & {
+  tus: TusStrategy.Intent;
+}, C extends Contracts.Cursor.Map<M> & {
+  tus?: TusStrategy.Cursor;
+}, P extends string = string, R extends Contracts.Result.Base = Contracts.Result.Base>(opts?: TusStrategy.Config): Contracts.Strategy.Me<M, C, P, R, 'tus'>;
+//#endregion
+export { PutStrategy as a, MultipartStrategy as c, PutIntent as i, multipartStrategy as l, TusStrategy as n, PostIntent as o, createStrategyRegistry as r, PostStrategy as s, TusIntent as t };

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { a as AnyCursor, c as WithSignal, d as IntentBase, f as IntentMap, i as UploadTransport, l as UploadResultBase, n as StrategyRegistry, o as CursorMap, p as StrategyKey, r as UploadStrategy, s as UploadApi, t as StrategyCtx, u as AnyIntent } from "./strategy.types-gg9ZStRe.js";
-import { $ as RejectReason, A as serializeSnapshot, B as UploadItem, C as StoreOptions, D as createTypedEmitter, E as UploadEventMap, F as PersistedUploadItem, G as UploadCommand, H as UploadProgress, I as PersistenceAdapter, J as resolveUploadConfig, K as UploadConfig, L as UploadState, M as LocalStorageAdapter, N as IndexedDBAdapter, O as TypedEmitter, P as PersistedSnapshot, Q as BuiltInUploadError, R as createReducer, S as PersistenceOptions, T as UploadStore, U as UploadCompletionKind, V as UploadPhase, W as UploadOutcome, X as createXHRTransport, Y as RetryDecision, Z as FileFingerprint, _ as UploadHooks, a as DEFAULT_MAX_ATTEMPTS, b as DeserializeContext, c as DEFAULT_PROGRESS_THROTTLE_MS, d as sleep, et as UploadError, f as validateFile, g as createUploadClient, h as UploadClient, i as fingerprintMatches, j as MemoryAdapter, k as deserializeSnapshot, l as DEFAULT_RETRY_DELAY_BASE_MS, m as validateIntent, n as isRecord, nt as UploadValidationRules, o as DEFAULT_MAX_CONCURRENT_UPLOADS, p as validateFileList, q as UploadConfigInput, r as computeFingerprint, s as DEFAULT_MAX_ITEMS, t as generateId, tt as UploadErrorBase, u as DEFAULT_RETRY_DELAY_MAX_MS, v as UploadPlugin, w as StoreRuntime, x as InflightUpload, y as createUploadStore, z as InternalEvent } from "./index-C38Jmizu.js";
-import { PickItemsByPhase, UploadProvider, UploaderActions, createUploadFactory, useOptionalUploadStore, useUploadStore, useUploader, useUploaderActions } from "./react/index.js";
-import { MultipartCursor, MultipartIntent, PostCursor, PostIntent, PostStrategy, createStrategyRegistry, multipartStrategy } from "./strategies/index.js";
-export { AnyCursor, AnyIntent, BuiltInUploadError, CursorMap, DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_CONCURRENT_UPLOADS, DEFAULT_MAX_ITEMS, DEFAULT_PROGRESS_THROTTLE_MS, DEFAULT_RETRY_DELAY_BASE_MS, DEFAULT_RETRY_DELAY_MAX_MS, DeserializeContext, FileFingerprint, IndexedDBAdapter, InflightUpload, IntentBase, IntentMap, InternalEvent, LocalStorageAdapter, MemoryAdapter, MultipartCursor, MultipartIntent, PersistedSnapshot, PersistedUploadItem, PersistenceAdapter, PersistenceOptions, PickItemsByPhase, PostCursor, PostIntent, PostStrategy, RejectReason, RetryDecision, StoreOptions, StoreRuntime, StrategyCtx, StrategyKey, StrategyRegistry, TypedEmitter, UploadApi, UploadClient, UploadCommand, UploadCompletionKind, UploadConfig, UploadConfigInput, UploadError, UploadErrorBase, UploadEventMap, UploadHooks, UploadItem, UploadOutcome, UploadPhase, UploadPlugin, UploadProgress, UploadProvider, UploadResultBase, UploadState, UploadStore, UploadStrategy, UploadTransport, UploadValidationRules, UploaderActions, WithSignal, computeFingerprint, createReducer, createStrategyRegistry, createTypedEmitter, createUploadClient, createUploadFactory, createUploadStore, createXHRTransport, deserializeSnapshot, fingerprintMatches, generateId, isRecord, multipartStrategy, resolveUploadConfig, serializeSnapshot, sleep, useOptionalUploadStore, useUploadStore, useUploader, useUploaderActions, validateFile, validateFileList, validateIntent };
+import { C as UploadUnknownError, D as Transport, E as createXHRTransport, O as Contracts, S as UploadTimeoutError, T as createFetchTransport, _ as UploadHttpError, a as deserializeSnapshot, b as UploadServerError, c as createMemoryAdapter, d as UploadPersistence, f as UploadAbortError, g as UploadErrorContext, h as UploadError, i as Store, l as LocalStorageAdapter, m as UploadEngineError, n as Engine, o as serializeSnapshot, p as UploadAuthError, r as createUploadStore, s as MemoryAdapter, t as resolveUploadConfig, u as IndexedDBAdapter, v as UploadNetworkError, w as UploadValidationError, x as UploadStrategyMissingError, y as UploadRateLimitError } from "./index-DCqyBVcx.js";
+import { a as UseDropzoneReturn, c as selectFiles, d as isUploadStore, f as useUploadStore, i as UseDropzoneOptions, l as useDropzone, n as useUploader, o as fileMatchesAccept, p as Uploader, r as useUploaderActions, s as matchesAcceptToken, t as createUploadFactory, u as UploadProvider } from "./index-DsZHPmJm.js";
+import { a as PutStrategy, c as MultipartStrategy, i as PutIntent, l as multipartStrategy, n as TusStrategy, o as PostIntent, r as createStrategyRegistry, s as PostStrategy, t as TusIntent } from "./index-KROXtLQh.js";
+export { Contracts, Engine, IndexedDBAdapter, LocalStorageAdapter, MemoryAdapter, MultipartStrategy, PostIntent, PostStrategy, PutIntent, PutStrategy, Store, Transport, TusIntent, TusStrategy, UploadAbortError, UploadAuthError, UploadEngineError, UploadError, UploadErrorContext, UploadHttpError, UploadNetworkError, UploadPersistence, UploadProvider, UploadRateLimitError, UploadServerError, UploadStrategyMissingError, UploadTimeoutError, UploadUnknownError, UploadValidationError, Uploader, UseDropzoneOptions, UseDropzoneReturn, createFetchTransport, createMemoryAdapter, createStrategyRegistry, createUploadFactory, createUploadStore, createXHRTransport, deserializeSnapshot, fileMatchesAccept, isUploadStore, matchesAcceptToken, multipartStrategy, resolveUploadConfig, selectFiles, serializeSnapshot, useDropzone, useUploadStore, useUploader, useUploaderActions };

package/dist/index.js

@@ -1 +1 @@
-import{C as e,S as t,_ as n,a as r,b as i,c as a,d as o,f as s,g as c,h as l,i as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,u as y,v as b,w as x,x as S,y as C}from"./core-CMkrP9DX.js";import{t as w}from"./async-DxRWu4le.js";import{UploadProvider as T,createUploadFactory as E,useOptionalUploadStore as D,useUploadStore as O,useUploader as k,useUploaderActions as A}from"./react/index.js";import{PostStrategy as j,createStrategyRegistry as M,multipartStrategy as N}from"./strategies/index.js";export{C as DEFAULT_MAX_ATTEMPTS,i as DEFAULT_MAX_CONCURRENT_UPLOADS,S as DEFAULT_MAX_ITEMS,t as DEFAULT_PROGRESS_THROTTLE_MS,e as DEFAULT_RETRY_DELAY_BASE_MS,x as DEFAULT_RETRY_DELAY_MAX_MS,d as IndexedDBAdapter,a as LocalStorageAdapter,_ as MemoryAdapter,j as PostStrategy,T as UploadProvider,o as computeFingerprint,g as createReducer,M as createStrategyRegistry,u as createTypedEmitter,v as createUploadClient,E as createUploadFactory,p as createUploadStore,y as createXHRTransport,r as deserializeSnapshot,s as fingerprintMatches,n as generateId,c as isRecord,N as multipartStrategy,b as resolveUploadConfig,m as serializeSnapshot,w as sleep,D as useOptionalUploadStore,O as useUploadStore,k as useUploader,A as useUploaderActions,h as validateFile,f as validateFileList,l as validateIntent};
+import{C as e,S as t,_ as n,a as r,b as i,c as a,f as o,g as s,h as c,i as l,l as u,m as d,n as f,o as p,p as m,r as h,s as g,t as _,u as v,v as y,x as b,y as x}from"./core-BVgloTiP.js";import{a as S,c as C,i as w,l as T,n as E,o as D,r as O,s as k,t as A,u as j}from"./react-euPrDv24.js";import{a as M,i as N,n as P,r as F,t as I}from"./strategies-CUF0s68j.js";export{_ as Engine,a as IndexedDBAdapter,g as LocalStorageAdapter,r as MemoryAdapter,N as PostStrategy,F as PutStrategy,I as TusStrategy,o as UploadAbortError,m as UploadAuthError,d as UploadEngineError,c as UploadHttpError,s as UploadNetworkError,C as UploadProvider,n as UploadRateLimitError,y as UploadServerError,x as UploadStrategyMissingError,i as UploadTimeoutError,b as UploadUnknownError,t as UploadValidationError,u as createFetchTransport,p as createMemoryAdapter,P as createStrategyRegistry,A as createUploadFactory,f as createUploadStore,v as createXHRTransport,h as deserializeSnapshot,w as fileMatchesAccept,T as isUploadStore,S as matchesAcceptToken,M as multipartStrategy,e as resolveUploadConfig,D as selectFiles,l as serializeSnapshot,k as useDropzone,j as useUploadStore,E as useUploader,O as useUploaderActions};

package/dist/react/index.d.ts

@@ -1,51 +1,2 @@
-import { f as IntentMap, l as UploadResultBase, o as CursorMap } from "../strategy.types-gg9ZStRe.js";
-import { B as UploadItem, E as UploadEventMap, G as UploadCommand, T as UploadStore, V as UploadPhase } from "../index-C38Jmizu.js";
-import { ReactNode } from "react";
-
-//#region src/react/upload-provider.d.ts
-/** Provides an upload store to descendants. */
-declare function UploadProvider<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>({
-  store,
-  children
-}: {
-  store: UploadStore<M, C, P, R>;
-  children: ReactNode;
-}): React.JSX.Element;
-/**
- * Read the upload store from context if provided. Returns `null` outside a
- * provider so higher-level hooks can keep their context read unconditional
- * while still accepting an explicit store argument.
- */
-declare function useOptionalUploadStore<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): UploadStore<M, C, P, R> | null;
-/** Read the upload store from context. Throws when called outside `UploadProvider`. */
-declare function useUploadStore<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): UploadStore<M, C, P, R>;
-//#endregion
-//#region src/react/use-uploader.d.ts
-declare function createUploadFactory<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(store: UploadStore<M, C, P, R>): () => Uploader<M, C, P, R>;
-type PickItemsByPhase<Phase extends UploadPhase> = Extract<UploadItem<IntentMap, CursorMap<IntentMap>, string, UploadResultBase>, {
-  phase: Phase;
-}>;
-type Uploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase> = {
-  items: UploadItem<M, C, P, R>[];
-  byPhase: Record<string, UploadItem<M, C, P, R>[]>;
-  dispatch: (cmd: UploadCommand<P>) => void;
-  on: <K extends keyof UploadEventMap<M, C, P, R> & string>(type: K, cb: (payload: UploadEventMap<M, C, P, R>[K]) => void) => () => void;
-  off: <K extends keyof UploadEventMap<M, C, P, R> & string>(type: K, cb: (payload: UploadEventMap<M, C, P, R>[K]) => void) => () => void;
-  uploading: UploadItem<M, C, P, R>[];
-  paused: UploadItem<M, C, P, R>[];
-  completed: UploadItem<M, C, P, R>[];
-  failed: UploadItem<M, C, P, R>[];
-  ready: UploadItem<M, C, P, R>[];
-};
-/**
- * Imperative action surface. Declared explicitly (not inferred) so generated
- * .d.ts files do not leak internal generic names created by `store.on.bind(store)`.
- */
-type UploaderActions<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = Pick<UploadStore<M, C, P, R>, 'dispatch' | 'on'> & {
-  store: UploadStore<M, C, P, R>;
-};
-declare function useUploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): Uploader<M, C, P, R>;
-declare function useUploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(store: UploadStore<M, C, P, R>): Uploader<M, C, P, R>;
-declare function useUploaderActions<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): UploaderActions<M, C, P, R>;
-//#endregion
-export { PickItemsByPhase, UploadProvider, UploaderActions, createUploadFactory, useOptionalUploadStore, useUploadStore, useUploader, useUploaderActions };
+import { a as UseDropzoneReturn, c as selectFiles, d as isUploadStore, f as useUploadStore, i as UseDropzoneOptions, l as useDropzone, n as useUploader, o as fileMatchesAccept, p as Uploader, r as useUploaderActions, s as matchesAcceptToken, t as createUploadFactory, u as UploadProvider } from "../index-DsZHPmJm.js";
+export { UploadProvider, Uploader, UseDropzoneOptions, UseDropzoneReturn, createUploadFactory, fileMatchesAccept, isUploadStore, matchesAcceptToken, selectFiles, useDropzone, useUploadStore, useUploader, useUploaderActions };

package/dist/react/index.js

@@ -1 +1 @@
-import{g as e}from"../core-CMkrP9DX.js";import{jsxDEV as t}from"react/jsx-dev-runtime";import*as n from"react";import{createContext as r,useContext as i}from"react";const a=r(null);function o({store:e,children:n}){return t(a.Provider,{value:e,children:n},void 0,!1,{fileName:`/home/runner/work/duck-upload/duck-upload/packages/duck-upload/src/react/upload-provider.tsx`,lineNumber:18,columnNumber:10},this)}function s(){let e=i(a);if(e===null)return null;if(!l(e))throw Error(`UploadProvider received an invalid store value`);return e}function c(){let e=s();if(!e)throw Error(`useUploadStore must be used within UploadProvider`);return e}function l(t){return e(t)?typeof t.getSnapshot==`function`&&typeof t.subscribe==`function`&&typeof t.dispatch==`function`&&typeof t.on==`function`&&typeof t.off==`function`&&typeof t.waitFor==`function`:!1}function u(e){return()=>d(e)}function d(e){let t=s(),r=e??t;if(!r)throw Error(`useUploader must be used within UploadProvider when no store argument is provided`);let i=n.useSyncExternalStore(r.subscribe.bind(r),r.getSnapshot.bind(r),r.getSnapshot.bind(r)),a=n.useMemo(()=>Array.from(i.items.values()),[i.items]),o=n.useMemo(()=>{let e={};return a.forEach(t=>{e[t.phase]||(e[t.phase]=[]),e[t.phase].push(t)}),e},[a]);return{items:a,byPhase:o,dispatch:r.dispatch.bind(r),on:r.on.bind(r),off:r.off.bind(r),uploading:o.uploading||[],paused:o.paused||[],completed:o.completed||[],failed:o.error||[],ready:o.ready||[]}}function f(){let e=c();return{dispatch:n.useMemo(()=>e.dispatch.bind(e),[e]),on:n.useMemo(()=>e.on.bind(e),[e]),store:e}}export{o as UploadProvider,u as createUploadFactory,s as useOptionalUploadStore,c as useUploadStore,d as useUploader,f as useUploaderActions};
+import{a as e,c as t,i as n,l as r,n as i,o as a,r as o,s,t as c,u as l}from"../react-euPrDv24.js";export{t as UploadProvider,c as createUploadFactory,n as fileMatchesAccept,r as isUploadStore,e as matchesAcceptToken,a as selectFiles,s as useDropzone,l as useUploadStore,i as useUploader,o as useUploaderActions};

package/dist/react-euPrDv24.js

@@ -0,0 +1 @@
+import{jsxDEV as e}from"react/jsx-dev-runtime";import*as t from"react";import{createContext as n,useCallback as r,useContext as i,useEffect as a,useMemo as o,useRef as s,useState as c,useSyncExternalStore as l}from"react";const u=n(null);function d({store:t,children:n}){return a(()=>()=>{`destroy`in t&&typeof t.destroy==`function`&&t.destroy()},[t]),e(u.Provider,{value:t,children:n},void 0,!1,{fileName:`/home/runner/work/duck-upload/duck-upload/packages/duck-upload/src/react/upload-provider.tsx`,lineNumber:43,columnNumber:10},this)}function f(){let e=i(u);if(!e)throw Error(`useUploadStore must be used within an <UploadProvider>`);return e}function p(e){if(typeof e!=`object`||!e)return!1;let t=e;return typeof t.getSnapshot==`function`&&typeof t.subscribe==`function`&&typeof t.dispatch==`function`&&typeof t.on==`function`&&typeof t.off==`function`&&typeof t.waitFor==`function`}function m(e,t){let n=t.trim().toLowerCase();if(!n)return!1;if(n.startsWith(`.`))return e.name.toLowerCase().endsWith(n);let r=(e.type||``).toLowerCase();return n.endsWith(`/*`)?r.startsWith(`${n.slice(0,-1)}`):r===n}function h(e,t){if(!t)return!0;let n=t.split(`,`).map(e=>e.trim()).filter(Boolean);return n.length===0?!0:n.some(t=>m(e,t))}function g(e,t){let n=e.filter(e=>h(e,t.accept));return t.multiple===!1?n.slice(0,1):n}function _(e){let{purpose:t,meta:n,accept:i,multiple:a=!0,disabled:l=!1,noClick:u=!1,onFiles:d}=e,p=f(),m=e.store??p,h=s(null),[_,v]=c(!1),y=s(0),b=r(e=>{if(!e||e.length===0)return;let r=g(Array.from(e),{accept:i,multiple:a});r.length!==0&&(d?d(r):m.dispatch({type:`addFiles`,files:r,purpose:t,meta:n}))},[i,a,d,m,t,n]),x=r(()=>{l||h.current?.click()},[l]),S=r((e={})=>({...e,onDragEnter:t=>{e.onDragEnter?.(t),!l&&(t.preventDefault(),t.stopPropagation(),y.current+=1,v(!0))},onDragOver:t=>{e.onDragOver?.(t),!l&&(t.preventDefault(),t.stopPropagation())},onDragLeave:t=>{e.onDragLeave?.(t),!l&&(t.preventDefault(),t.stopPropagation(),y.current=Math.max(0,y.current-1),y.current===0&&v(!1))},onDrop:t=>{e.onDrop?.(t),!l&&(t.preventDefault(),t.stopPropagation(),y.current=0,v(!1),b(t.dataTransfer?.files??null))},onClick:t=>{e.onClick?.(t),!(l||u)&&x()}}),[l,u,x,b]),C=r((e={})=>({...e,ref:h,type:`file`,multiple:a,disabled:l,...i?{accept:i}:{},style:{display:`none`,...e.style},onChange:t=>{e.onChange?.(t),b(t.target.files),t.target.value=``}}),[a,l,i,b]);return o(()=>({isDragging:_,open:x,inputRef:h,getRootProps:S,getInputProps:C}),[_,x,S,C])}function v(e){let t=f(),n=e??t;if(!n)throw Error(`useUploader must be used within an <UploadProvider> or passed a store instance directly.`);let r=l(n.subscribe,n.getSnapshot,n.getSnapshot),i=o(()=>Array.from(r.items.values()),[r]),a=o(()=>{let e={validating:[],creating_intent:[],ready:[],queued:[],uploading:[],paused:[],completing:[],completed:[],error:[],canceled:[]};return i.forEach(t=>{let n=t.phase;e[n]||(e[n]=[]),e[n].push(t)}),e},[i]);return{items:i,byPhase:a,dispatch:n.dispatch.bind(n),on:n.on.bind(n),off:n.off.bind(n),uploading:a.uploading||[],paused:a.paused||[],completed:a.completed||[],failed:a.error||[],ready:a.ready||[]}}function y(){let e=f();return{dispatch:t.useMemo(()=>e.dispatch.bind(e),[e]),on:t.useMemo(()=>e.on.bind(e),[e]),store:e}}function b(e){return()=>v(e)}export{m as a,d as c,h as i,p as l,v as n,g as o,y as r,_ as s,b as t,f as u};