@calmlens/sdk 0.16.3 → 0.18.0

package/esm/ui-wIiMfqMB.d.ts

@@ -0,0 +1,526 @@
+import { Dt as ViewerClaims, k as CdnTransform, m as AssetModerationStatus, w as CalmLensAppClientOptions } from "./CalmLensTypes-9Vt16pc7.js";
+import { t as CalmLensAppClient } from "./CalmLensAppClient-CV_K26Ce.js";
+/**
+ * The parts of an asset, as the API or a webhook returns it, that the media component reads.
+ * Assets from `CalmLensServerClient` fit as they are.
+ */
+interface MediaAsset {
+  id: string;
+  projectId: string;
+  type?: string | null;
+  classification?: {
+    moderation?: {
+      status?: AssetModerationStatus | null;
+      regions?: {
+        region: string;
+        action: string;
+      }[];
+    } | null;
+  } | null;
+  content?: {
+    status?: string | null;
+    image?: {
+      thumbhash?: string | null;
+      averageColor?: string | null;
+      width?: number | null;
+      height?: number | null;
+    } | null;
+  } | null;
+}
+/** Which asset to show: an asset from the API, or its project and ID. */
+type MediaSource = {
+  /**
+   * An asset from the API. It supplies the project, ID, moderation status, media type and
+   * stored preview (placeholder, average colour and size); props you pass win over it.
+   */
+  asset: MediaAsset;
+  projectId?: string;
+  assetId?: string;
+} | {
+  asset?: undefined;
+  projectId: string /** The asset ID, or its `externalId`. */;
+  assetId: string;
+};
+type MediaOptions = MediaSource & MediaSettings;
+interface MediaSettings {
+  /** Optional customer assertions. Defaults to connection country and age confirmation false. */
+  viewerClaims?: ViewerClaims;
+  /** The asset's stored moderation status. Defaults to `allowed`. */
+  status?: AssetModerationStatus;
+  /**
+   * Whether CalmLens has removed the asset's content, from its `content.status`. Removed content
+   * shows the unavailable notice and requests nothing. Set from `asset` when you pass one.
+   */
+  contentRemoved?: boolean;
+  /** `image` (default), `video` or `audio`. */
+  type?: "image" | "video" | "audio";
+  /**
+   * `rendered` (default), which the CDN serves in the best format the browser accepts and where
+   * lenses and transforms apply, or `original`, the exact uploaded file. Video and audio always
+   * play the original.
+   */
+  resource?: "original" | "rendered";
+  /** A named lens, such as `avatar`. */
+  lens?: string;
+  /** A transform applied after the lens, as a selector string or structured steps. */
+  transform?: CdnTransform;
+  /** Widths to offer in `srcset`, so browsers fetch the smallest that fits `sizes`. */
+  widths?: number[];
+  /**
+   * A signed URL from your server, used as-is instead of a CDN URL built here, for private
+   * assets. Include any viewer claims when creating the signed URL.
+   */
+  url?: string;
+  /** Show the blurred placeholder while the media loads. Defaults to `true`. */
+  placeholder?: boolean;
+  /**
+   * The asset's `content.image.thumbhash`, if your app stores it. The placeholder is then
+   * drawn in the browser instead of requested from the CDN.
+   */
+  placeholderHash?: string;
+  /** Your own placeholder image URL, used when there is no `placeholderHash`. */
+  placeholderUrl?: string;
+  /** The CDN base URL, for local development. */
+  cdnBaseUrl?: string;
+}
+type MediaState = {
+  kind: "unavailable";
+  reason?: "regional";
+} | {
+  kind: "gated";
+  placeholderUrl?: string;
+} | {
+  kind: "image";
+  src: string;
+  srcSet?: string;
+  /** One URL per width in `widths`, smallest first, for apps that pick their own. */
+  sources?: MediaImageSource[];
+  placeholderUrl?: string;
+} | {
+  kind: "video";
+  src: string;
+  placeholderUrl?: string;
+} | {
+  kind: "audio";
+  src: string;
+};
+/** An image at one of the widths in `widths`. */
+interface MediaImageSource {
+  src: string;
+  width: number;
+}
+/**
+ * The image URL to load for a box `displayWidth` pixels wide: the smallest width that covers it,
+ * or the largest when none does. Without `widths`, or before the box is measured, the image's own
+ * `src`. React Native, which has no `srcset`, calls this with its measured size.
+ */
+declare const pickMediaSource: (state: Extract<MediaState, {
+  kind: "image";
+}>, displayWidth: number | undefined) => string;
+/**
+ * What the media component should render for an asset: the image with its responsive widths,
+ * the video or audio, a gated placeholder for an age-restricted asset the viewer can't see, or
+ * nothing for blocked and purged assets. Every framework's component renders this.
+ */
+/** The display props an asset can supply, which media components read alongside the options. */
+type AssetDisplay = {
+  width?: number;
+  height?: number;
+  averageColor?: string;
+};
+/**
+ * Fills the props left unset from `asset`, if there is one: the project and ID, its moderation
+ * status, `video` or `audio` for those asset types, and its stored preview's ThumbHash, average
+ * colour and size. Every framework's media component calls this before rendering.
+ */
+declare const resolveMediaProps: <T extends MediaOptions & AssetDisplay>(props: T) => T & {
+  projectId: string;
+  assetId: string;
+};
+declare const getMediaState: (options: MediaOptions) => MediaState;
+/**
+ * Where a file is in the upload: picked and waiting for `start()` (with `autoUpload: false`),
+ * waiting its turn, sending bytes, being moderated, or finished.
+ */
+type UploadStage = "selected" | "queued" | "uploading" | "checking" | "complete" | "failed";
+/**
+ * A file to upload: a browser `File`, or a file on a phone, such as a `File` from
+ * `expo-file-system`. Anything with a name, MIME type, size and bytes works.
+ */
+interface UploadFile {
+  readonly name: string;
+  readonly type: string;
+  readonly size: number;
+  /** The file's local URI on a phone, such as `file:///…`, used for the image preview. */
+  readonly uri?: string;
+  /** Reads the file's bytes when its upload starts. */
+  arrayBuffer(): Promise<ArrayBuffer>;
+}
+/** One file the uploader has picked, as the components render it. */
+interface UploadItem<F extends UploadFile = UploadFile> {
+  /** A local ID for the file in this uploader, not the asset ID. */
+  readonly key: string;
+  readonly file: F;
+  readonly stage: UploadStage;
+  /** Sent bytes as a fraction from 0 to 1 while uploading, `null` when unknown. */
+  readonly progress: number | null;
+  /**
+   * A local preview of an image file while it's checked: an object URL in browsers, or the file's
+   * own URI on a phone.
+   */
+  readonly previewUrl?: string;
+  readonly assetId?: string;
+  /** The moderation status, when the upload preset shows decisions to the uploader. */
+  readonly status?: AssetModerationStatus;
+  /**
+   * Why the file failed: a `CalmLensError` code, or `file/not-accepted` and `file/too-large` when
+   * the uploader refused the file before sending it.
+   */
+  readonly errorCode?: string;
+}
+/** A finished upload that wasn't blocked, which your app saves with its record. */
+interface CalmLensUpload<F extends UploadFile = UploadFile> {
+  assetId: string;
+  /** `undefined` when the upload preset doesn't show decisions to the uploader. */
+  status?: AssetModerationStatus;
+  file: F;
+}
+interface UploadSnapshot<F extends UploadFile = UploadFile> {
+  readonly items: readonly UploadItem<F>[];
+  /** Whether any file is still waiting, uploading or being checked. */
+  readonly busy: boolean;
+}
+/** The part of `CalmLensAppClient` the uploader uses, which `MockCalmLensAppClient` also has. */
+interface UploadClient {
+  assets: Pick<CalmLensAppClient["assets"], "create" | "retrieve">;
+}
+/** What a custom `upload` function returns for each file. */
+interface CustomUploadResult {
+  assetId: string;
+  /** The moderation status, if your API returns it. */
+  status?: AssetModerationStatus;
+}
+interface CustomUploadContext {
+  /** Aborted when the uploader cancels or removes the file. */
+  signal: AbortSignal;
+  /** Reports sent bytes, for the progress bar. `createProgressFetch` reports them for you. */
+  onProgress: (sentBytes: number, totalBytes: number) => void;
+}
+interface UploadControllerOptions<F extends UploadFile = UploadFile> {
+  /** The upload preset the files upload through. Not needed with `upload`. */
+  uploadPresetId?: string;
+  /**
+   * Uploads each file your own way instead of through an upload preset, for example through your
+   * app's API, which creates the asset with its API key. The uploader still shows progress, the
+   * decision and errors: throw a `CalmLensError` to show its code's message.
+   */
+  upload?: (file: F, context: CustomUploadContext) => Promise<CustomUploadResult>;
+  /**
+   * Checks a pending upload made with `upload`, returning its current moderation status. Without
+   * it, a pending upload finishes as pending.
+   */
+  checkStatus?: (assetId: string, context: {
+    signal: AbortSignal;
+  }) => Promise<AssetModerationStatus | undefined>;
+  /**
+   * The upload token, or a function that returns a fresh one for each file. Leave it out for
+   * presets that anyone can upload to.
+   */
+  token?: string | ((file: F) => string | Promise<string>);
+  /**
+   * An endpoint on your server that returns `{ token }` for each file. It receives a `POST` with
+   * the file's `{ name, type, size }` as JSON. Use `token` instead for anything more custom.
+   */
+  tokenUrl?: string;
+  /** File types to accept, as in an `<input accept>`: `image/*`, `.png`, `video/mp4`. */
+  accept?: string;
+  /** The largest file to accept, in bytes. Your preset's own limit still applies. */
+  maxFileSize?: number;
+  /**
+   * Upload files as soon as they're picked. Defaults to `true`. With `false`, picked files wait in
+   * the `selected` stage until you call `start()`, for example when a form is submitted.
+   */
+  autoUpload?: boolean;
+  /** Accept more than one file. Defaults to `false`; a new file then replaces the last one. */
+  multiple?: boolean;
+  /** The most files kept at once when `multiple` is on. Defaults to 10. */
+  maxFiles?: number;
+  /** How many files upload at the same time. Defaults to 3. */
+  concurrency?: number;
+  /**
+   * How long to keep checking for a moderation decision, in milliseconds. Defaults to 15
+   * seconds; anything still pending after that is settled by your server's webhook.
+   */
+  decisionTimeoutMs?: number;
+  /** The CalmLens API base URL, for local development. */
+  baseUrl?: string;
+  /**
+   * Creates the client for each upload. Defaults to `CalmLensAppClient`; tests can return a
+   * `MockCalmLensAppClient` from `calmlens/testing` instead.
+   */
+  createClient?: (options: CalmLensAppClientOptions) => UploadClient;
+  /**
+   * Called for each finished upload that wasn't blocked or purged, and again with the new status
+   * when `retry` checks one that was still pending.
+   */
+  onUploaded?: (upload: CalmLensUpload<F>) => void;
+  /** Called when moderation blocks or purges a file. */
+  onRejected?: (item: UploadItem<F>) => void;
+  /** Called when a file couldn't be uploaded. */
+  onFailed?: (item: UploadItem<F>) => void;
+  /** Called when the uploader removes a file, including a finished upload. */
+  onRemoved?: (item: UploadItem<F>) => void;
+}
+/** Whether a file matches an `accept` list such as `image/*,.pdf`. */
+declare const isFileAccepted: (file: Pick<UploadFile, "name" | "type">, accept?: string) => boolean;
+/**
+ * Uploads files through an upload preset and tracks each one until it has a moderation
+ * decision. It holds no UI: the React, Vue, Svelte and web components render its snapshot, and
+ * you can render your own with `subscribe`, which also makes it a Svelte store.
+ */
+declare class UploadController<F extends UploadFile = UploadFile> {
+  #private;
+  constructor(options: UploadControllerOptions<F>);
+  /** The current options. */
+  get options(): Readonly<UploadControllerOptions<F>>;
+  /** Replaces the options, for example when a component's props change. */
+  setOptions(options: UploadControllerOptions<F>): void;
+  getSnapshot: () => UploadSnapshot<F>;
+  /**
+   * Calls `listener` with the current snapshot now and after every change, and returns a
+   * function that stops. This is the Svelte store contract, and works with React's
+   * `useSyncExternalStore`.
+   */
+  subscribe: (listener: (snapshot: UploadSnapshot<F>) => void) => (() => void);
+  /**
+   * Adds files from a file input, a drop, a paste or a phone's picker, and starts uploading them,
+   * or keeps them `selected` with `autoUpload: false`.
+   */
+  addFiles(files: Iterable<F> | ArrayLike<F>): void;
+  /** Uploads every `selected` file, for an uploader with `autoUpload: false`. */
+  start(): void;
+  /**
+   * Tries a failed file again: an upload that finished but couldn't be checked is checked again,
+   * anything else is uploaded again. A finished upload still `pending` is checked again too.
+   */
+  retry(key: string): void;
+  /**
+   * Stops a queued or running file and keeps it in the list as failed with `sdk/cancelled`, so
+   * `retry` can upload it again. Finished files are left as they are.
+   */
+  cancel(key: string): void;
+  /** Cancels a file's upload if it's running and removes it from the list. */
+  remove(key: string): void;
+  /** Cancels every upload and empties the list, without calling `onRemoved`. */
+  clear(): void;
+}
+declare const createUploadController: <F extends UploadFile = UploadFile>(options: UploadControllerOptions<F>) => UploadController<F>;
+/**
+ * The text the components show. Pass `messages` to any component to replace some or all of it,
+ * for example to translate it. Keys other than the named ones are error codes, so you can give
+ * any `CalmLensError` code its own message.
+ */
+interface CalmLensMessages {
+  dropzoneTitle: string;
+  dropzoneTitleDragging: string;
+  /** The picker button when the uploader takes one file. */
+  chooseFile: string;
+  /** The picker button with `multiple`. */
+  chooseFiles: string;
+  /** Replaces the picked file when the uploader takes one file. */
+  chooseAnother: string;
+  /** `{size}` is replaced with the largest accepted size, such as `20 MB`. */
+  maxFileSizeHint: string;
+  /** Under a file waiting for `start()`. Empty by default, so the row shows only its size. */
+  selected: string;
+  queued: string;
+  uploading: string;
+  checking: string;
+  /** Finished, when the upload preset doesn't show decisions to the uploader. */
+  submitted: string;
+  pending: string;
+  allowed: string;
+  limited: string;
+  "age-restricted": string;
+  blocked: string;
+  purged: string;
+  failed: string;
+  "file/not-accepted": string;
+  "file/too-large": string;
+  retry: string;
+  /** `{name}` is replaced with the file name. */
+  remove: string;
+  /** `{name}` is replaced with the file name. */
+  cancel: string;
+  sensitiveTitle: string;
+  sensitiveBody: string;
+  reveal: string;
+  unavailable: string;
+  /** A viewer-specific regional block reported by the asset API. */
+  regionalUnavailable: string;
+  [errorCode: string]: string;
+}
+declare const DEFAULT_MESSAGES: CalmLensMessages;
+declare const resolveMessages: (overrides?: Partial<CalmLensMessages>) => CalmLensMessages;
+/** The unavailable notice every media binding shows for the same resolved state. */
+declare const getMediaUnavailableMessage: (state: MediaState, messages: CalmLensMessages) => string;
+/** Fills `{name}`-style placeholders. */
+declare const formatMessage: (message: string, values: Record<string, string>) => string;
+/** The message for a file's current state. */
+declare const getUploadItemMessage: (item: UploadItem, messages: CalmLensMessages) => string;
+/** How a finished file turned out, for styling: `accepted`, `restricted` or `rejected`. */
+declare const getUploadItemOutcome: (item: UploadItem) => "accepted" | "restricted" | "rejected" | undefined;
+/** A byte count for people, such as `1.2 MB`. */
+declare const formatBytes: (bytes: number) => string;
+/** Everything a file's row shows, worked out once for every framework's uploader. */
+interface UploadItemView {
+  message: string;
+  outcome?: "accepted" | "restricted" | "rejected";
+  busy: boolean;
+  /** Sent bytes from 0 to 100, or `undefined` for an indeterminate bar while checking. */
+  progressPercent?: number;
+  canRetry: boolean;
+  /** The remove button's accessible name: cancel while the file is busy. */
+  removeLabel: string;
+  /** The file-type icon shown when there is no image preview, as SVG markup. */
+  fileIcon: string;
+  size: string;
+}
+declare const describeUploadItem: (item: UploadItem, messages: CalmLensMessages) => UploadItemView;
+/** The hint under the drop zone's title, or `undefined` without a size limit. */
+declare const getDropzoneHint: (messages: CalmLensMessages, maxFileSize?: number) => string | undefined;
+/** What an uploader shows around its file list, worked out once for every framework. */
+interface UploaderView {
+  /**
+   * Whether to show the drop zone. An uploader that takes one file swaps it for the file's row,
+   * with a button to choose another, once a file is picked.
+   */
+  showDropzone: boolean;
+  chooseLabel: string;
+  hint?: string;
+}
+declare const describeUploader: (snapshot: UploadSnapshot, options: Pick<UploadControllerOptions, "multiple" | "maxFileSize">, messages: CalmLensMessages) => UploaderView;
+/** Props every framework's uploader takes, on top of the upload options. */
+interface UploaderDisplayOptions<F extends UploadFile = UploadFile> {
+  disabled?: boolean;
+  /** Opens the camera on phones: `user` for the front camera, `environment` for the back. */
+  capture?: "user" | "environment";
+  /** Replaces some or all of the text the uploader shows. */
+  messages?: Partial<CalmLensMessages>;
+  /**
+   * Shows this upload queue instead of creating one, such as `useCalmLensUpload`'s `controller`,
+   * so your app can read the picked files and call `start()`. The upload options then come from
+   * the controller, and the uploader leaves its uploads running when it unmounts.
+   */
+  controller?: UploadController<F>;
+}
+type UploaderProps<F extends UploadFile = UploadFile> = UploadControllerOptions<F> & UploaderDisplayOptions<F>;
+/** Props every framework's media component takes, on top of the media options. */
+interface MediaDisplayOptions {
+  /** Describes the image. Leave it empty only for decorative images. */
+  alt?: string;
+  /** Width divided by height, which you store with the upload, so the box keeps its size. */
+  aspectRatio?: number;
+  /** The intrinsic width, used with `height` for the aspect ratio and the image attributes. */
+  width?: number;
+  height?: number;
+  /** The `sizes` attribute for `widths`, such as `(min-width: 768px) 50vw, 100vw`. */
+  sizes?: string;
+  /** The asset's `content.image.averageColor`, shown behind the media while it loads. */
+  averageColor?: string;
+  /** How the media fills its box: `cover` (default) or `contain`. */
+  fit?: "cover" | "contain";
+  /** The CSS `object-position`, such as `top` or `30% 50%`. */
+  position?: string;
+  /** Load the image only when it nears the viewport. Defaults to `true`. */
+  lazy?: boolean;
+  fetchPriority?: "high" | "low" | "auto";
+  /** Video and audio controls. Defaults to `true`. */
+  controls?: boolean;
+  messages?: Partial<CalmLensMessages>;
+  /**
+   * Called when the viewer presses the reveal button on age-restricted media. Run your app's own
+   * check, then render again with `ageConfirmed`. Without it, the notice has no button.
+   */
+  onReveal?: () => void;
+}
+type MediaProps = MediaOptions & MediaDisplayOptions;
+/** The aspect ratio a media component's box keeps, if it knows one. */
+declare const getMediaAspectRatio: ({ aspectRatio, width, height }: MediaDisplayOptions) => number | undefined;
+/** A key that changes whenever a media component must load something new. */
+declare const getMediaLoadKey: (state: MediaState) => string;
+/** Path data for the components' 24×24 stroke icons, so every framework draws the same ones. */
+declare const ICONS: {
+  readonly upload: "M12 16V4m0 0L7 9m5-5 5 5M4 16v2a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2";
+  readonly remove: "M18 6 6 18M6 6l12 12";
+  readonly retry: "M20 11a8 8 0 1 0-2.3 5.7M20 4v7h-7";
+  readonly unavailable: "M3 3l18 18M10.6 10.6a2 2 0 0 0 2.8 2.8M9.9 5.1A9.8 9.8 0 0 1 12 5c5 0 9 5 10 7a17 17 0 0 1-3.3 4.2M6.6 6.6C4.4 8 2.8 10.4 2 12c1 2 5 7 10 7a9.6 9.6 0 0 0 5.4-1.6";
+};
+type IconName = keyof typeof ICONS;
+/** Attributes shared by every icon's `<svg>`. */
+declare const ICON_ATTRIBUTES: {
+  readonly width: "18";
+  readonly height: "18";
+  readonly viewBox: "0 0 24 24";
+  readonly fill: "none";
+  readonly stroke: "currentColor";
+  readonly "stroke-width": "2";
+  readonly "stroke-linecap": "round";
+  readonly "stroke-linejoin": "round";
+  readonly "aria-hidden": "true";
+};
+/**
+ * A `fetch` that reports how many bytes of the request body have been sent, which `fetch` itself
+ * can't do. It sends through `XMLHttpRequest`, so the upload components pass it to
+ * `CalmLensAppClient` as `uploadFetch`. Without `XMLHttpRequest` it falls back to `fetch` and
+ * reports nothing.
+ */
+declare const createProgressFetch: (onProgress: (sentBytes: number, totalBytes: number) => void) => ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>);
+/**
+ * The components' stylesheet, also shipped as `calmlens/styles.css`. The React components
+ * render it themselves (React hoists it into the head, on the server too); with Vue, Svelte or
+ * the web components, import or link `calmlens/styles.css` once. Nothing is added to the page
+ * at runtime. Theme it with the `--calmlens-*` custom properties, or leave it out and style the
+ * `calmlens-*` classes yourself.
+ */
+declare const CALMLENS_STYLES: string;
+/**
+ * The components' colours and corner radius. The stylesheet uses them as its `--calmlens-*`
+ * defaults, and the React Native components take them as `theme`.
+ */
+interface CalmLensTheme {
+  accent: string;
+  /** Text on the accent colour. */
+  accentText: string;
+  /** Corner radius of the drop zone, file rows and media, in pixels. */
+  radius: number;
+  /** Body text. The stylesheet inherits it from the page instead. */
+  text: string;
+  /** Secondary text, such as a file's size. Defaults to `text` at 72%. */
+  muted: string;
+  /** Borders and the progress track. Defaults to `text` at 18%. */
+  border: string;
+  /** The drop zone's fill. Defaults to `text` at 4%. */
+  surface: string;
+  /** The file rows' fill. Defaults to none, so rows show what's behind them. */
+  background: string;
+  success: string;
+  warning: string;
+  danger: string;
+}
+declare const CALMLENS_THEME: {
+  readonly accent: "#635bff";
+  readonly accentText: "#fff";
+  readonly radius: 12;
+  readonly text: "#1f2328";
+  readonly background: "transparent";
+  readonly success: "#12a26f";
+  readonly warning: "#e8a317";
+  readonly danger: "#e5484d";
+};
+/**
+ * The full theme from your overrides, mixing the muted, border and surface colours from `text`
+ * as the stylesheet mixes them from the page's text colour.
+ */
+declare const resolveTheme: (overrides?: Partial<CalmLensTheme>) => CalmLensTheme;
+export { CustomUploadResult as A, MediaAsset as B, getDropzoneHint as C, resolveMessages as D, getUploadItemOutcome as E, UploadItem as F, MediaState as G, MediaOptions as H, UploadSnapshot as I, resolveMediaProps as J, getMediaState as K, UploadStage as L, UploadController as M, UploadControllerOptions as N, CalmLensUpload as O, UploadFile as P, createUploadController as R, formatMessage as S, getUploadItemMessage as T, MediaSettings as U, MediaImageSource as V, MediaSource as W, UploadItemView as _, createProgressFetch as a, describeUploader as b, IconName as c, UploaderDisplayOptions as d, UploaderProps as f, DEFAULT_MESSAGES as g, CalmLensMessages as h, CALMLENS_STYLES as i, UploadClient as j, CustomUploadContext as k, MediaDisplayOptions as l, getMediaLoadKey as m, CalmLensTheme as n, ICONS as o, getMediaAspectRatio as p, pickMediaSource as q, resolveTheme as r, ICON_ATTRIBUTES as s, CALMLENS_THEME as t, MediaProps as u, UploaderView as v, getMediaUnavailableMessage as w, formatBytes as x, describeUploadItem as y, isFileAccepted as z };

package/esm/ui.d.ts

@@ -0,0 +1,2 @@
+import { A as CustomUploadResult, B as MediaAsset, C as getDropzoneHint, D as resolveMessages, E as getUploadItemOutcome, F as UploadItem, G as MediaState, H as MediaOptions, I as UploadSnapshot, J as resolveMediaProps, K as getMediaState, L as UploadStage, M as UploadController, N as UploadControllerOptions, O as CalmLensUpload, P as UploadFile, R as createUploadController, S as formatMessage, T as getUploadItemMessage, U as MediaSettings, V as MediaImageSource, W as MediaSource, _ as UploadItemView, a as createProgressFetch, b as describeUploader, c as IconName, d as UploaderDisplayOptions, f as UploaderProps, g as DEFAULT_MESSAGES, h as CalmLensMessages, i as CALMLENS_STYLES, j as UploadClient, k as CustomUploadContext, l as MediaDisplayOptions, m as getMediaLoadKey, n as CalmLensTheme, o as ICONS, p as getMediaAspectRatio, q as pickMediaSource, r as resolveTheme, s as ICON_ATTRIBUTES, t as CALMLENS_THEME, u as MediaProps, v as UploaderView, w as getMediaUnavailableMessage, x as formatBytes, y as describeUploadItem, z as isFileAccepted } from "./ui-wIiMfqMB.js";
+export { CALMLENS_STYLES, CALMLENS_THEME, type CalmLensMessages, type CalmLensTheme, type CalmLensUpload, type CustomUploadContext, type CustomUploadResult, DEFAULT_MESSAGES, ICONS, ICON_ATTRIBUTES, type IconName, type MediaAsset, type MediaDisplayOptions, type MediaImageSource, type MediaOptions, type MediaProps, type MediaSettings, type MediaSource, type MediaState, type UploadClient, UploadController, type UploadControllerOptions, type UploadFile, type UploadItem, type UploadItemView, type UploadSnapshot, type UploadStage, type UploaderDisplayOptions, type UploaderProps, type UploaderView, createProgressFetch, createUploadController, describeUploadItem, describeUploader, formatBytes, formatMessage, getDropzoneHint, getMediaAspectRatio, getMediaLoadKey, getMediaState, getMediaUnavailableMessage, getUploadItemMessage, getUploadItemOutcome, isFileAccepted, pickMediaSource, resolveMediaProps, resolveMessages, resolveTheme };

package/esm/ui.js

@@ -0,0 +1,3 @@
+import { _ as getMediaState, a as getMediaAspectRatio, b as ICONS, c as describeUploadItem, d as formatMessage, f as getDropzoneHint, g as resolveMessages, h as getUploadItemOutcome, i as resolveTheme, l as describeUploader, m as getUploadItemMessage, o as getMediaLoadKey, p as getMediaUnavailableMessage, r as CALMLENS_THEME, s as DEFAULT_MESSAGES, t as CALMLENS_STYLES, u as formatBytes, v as pickMediaSource, x as ICON_ATTRIBUTES, y as resolveMediaProps } from "./ui-CCY3yXFn.js";
+import { i as createProgressFetch, n as createUploadController, r as isFileAccepted, t as UploadController } from "./UploadController-qjoYGCwx.js";
+export { CALMLENS_STYLES, CALMLENS_THEME, DEFAULT_MESSAGES, ICONS, ICON_ATTRIBUTES, UploadController, createProgressFetch, createUploadController, describeUploadItem, describeUploader, formatBytes, formatMessage, getDropzoneHint, getMediaAspectRatio, getMediaLoadKey, getMediaState, getMediaUnavailableMessage, getUploadItemMessage, getUploadItemOutcome, isFileAccepted, pickMediaSource, resolveMediaProps, resolveMessages, resolveTheme };