@devultur/convex 1.3.1 → 1.4.0

package/dist/index.js

@@ -1,6 +1,17 @@
+import {
+  mediaFromRecord
+} from "./chunk-KAIVI7RB.js";
 import {
   dv
-} from "./chunk-GKLFRSGI.js";
+} from "./chunk-YIPZZDGD.js";
+import {
+  DEVULTUR_ERROR_CODES,
+  describeDevulturError,
+  devulturErrorLabels,
+  devulturErrorOf,
+  isDevulturError,
+  isDevulturErrorCode
+} from "./chunk-EX3W77VY.js";
 
 // src/index.ts
 import {
@@ -15,11 +26,148 @@ import {
   TranslationProvider
 } from "@devultur/core";
 
-// src/client.ts
+// src/exposed-functions.ts
 import { extractId } from "@devultur/core";
-import { actionGeneric, mutationGeneric, paginationOptsValidator, queryGeneric } from "convex/server";
-import { v } from "convex/values";
+import {
+  actionGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+  mutationGeneric,
+  paginationOptsValidator,
+  queryGeneric
+} from "convex/server";
+import { ConvexError, v } from "convex/values";
+function exposed(kind, args, handler) {
+  return { kind, args, handler };
+}
+var visibilityArg = v.optional(v.union(v.literal("public"), v.literal("private")));
+var mediaTypeArg = v.optional(v.union(v.literal("video"), v.literal("image"), v.literal("file")));
+var progressArgs = { userId: v.string(), videoId: v.string() };
+function progressArgsFor(args, caller) {
+  if (!caller.userId || caller.canActForOthers || args.userId === caller.userId) return args;
+  throw new ConvexError({
+    code: "user_mismatch",
+    message: "This progress belongs to another user",
+    status: 403
+  });
+}
+function mediaIdOf(key) {
+  return key.includes("/") ? extractId(key) : key;
+}
+function exposedFunctions(component, config) {
+  const preset = config?.video?.transcodePreset;
+  const locales = config?.video?.captionLocales ?? [];
+  const uploadLock = config?.upload?.lock;
+  return {
+    issueViewerToken: exposed(
+      "action",
+      { sessionSecret: v.optional(v.string()) },
+      async (ctx, args, caller) => ctx.runAction(component.public.issueViewerToken, {
+        ...args,
+        ...caller.userId ? { userId: caller.userId } : {}
+      })
+    ),
+    // Optional per-resource visibility; omitted → the component resolves the config's default (secure-by-default).
+    createUploadUrl: exposed(
+      "action",
+      { filename: v.string(), contentType: v.string(), visibility: visibilityArg },
+      async (ctx, args) => ctx.runAction(component.public.createUploadUrl, { ...args, ...uploadLock ? { lock: uploadLock } : {} })
+    ),
+    // Records an upload once its bytes are stored (the Worker HEADs the key): a browser can't list anything
+    // that isn't in your bucket. `useDevultur().upload()` and `useMediaUpload` call it after the PUT.
+    confirmUpload: exposed(
+      "action",
+      {
+        key: v.string(),
+        filename: v.optional(v.string()),
+        width: v.optional(v.number()),
+        height: v.optional(v.number()),
+        pageCount: v.optional(v.number())
+      },
+      async (ctx, args) => ctx.runAction(component.uploads.confirmUpload, args)
+    ),
+    // Edits a record's title, alt text and tags. Your guard decides who may edit which media.
+    updateMediaMeta: exposed(
+      "mutation",
+      {
+        key: v.string(),
+        title: v.optional(v.string()),
+        alt: v.optional(v.string()),
+        tags: v.optional(v.array(v.string()))
+      },
+      async (ctx, args) => ctx.runMutation(component.metadata.updateMediaMeta, { ...args, key: mediaIdOf(args.key) })
+    ),
+    deleteMedia: exposed(
+      "action",
+      { key: v.string() },
+      async (ctx, args) => ctx.runAction(component.public.deleteMediaAction, args)
+    ),
+    deleteVideo: exposed(
+      "action",
+      { videoId: v.string(), visibility: visibilityArg },
+      async (ctx, args) => ctx.runAction(component.public.deleteVideo, args)
+    ),
+    processVideo: exposed(
+      "action",
+      { key: v.string() },
+      async (ctx, args) => ctx.runAction(component.public.processVideo, { key: args.key, preset, locales })
+    ),
+    getMedia: exposed(
+      "query",
+      { key: v.string() },
+      async (ctx, args) => ctx.runQuery(component.public.getMediaByKey, { key: mediaIdOf(args.key) })
+    ),
+    // The media library, a page at a time (for `usePaginatedQuery`). It lists every record, of every user.
+    listMediaPage: exposed(
+      "query",
+      { type: mediaTypeArg, paginationOpts: paginationOptsValidator },
+      async (ctx, args) => ctx.runQuery(component.public.listMediaPage, args)
+    ),
+    // The media library matching a search (title and filename), a page at a time. Every user's media, like
+    // `listMediaPage`; a blank search lists it newest first.
+    searchMedia: exposed(
+      "query",
+      { search: v.string(), type: mediaTypeArg, paginationOpts: paginationOptsValidator },
+      async (ctx, args) => ctx.runQuery(component.library.searchMedia, args)
+    ),
+    saveProgress: exposed(
+      "mutation",
+      { ...progressArgs, position: v.number() },
+      async (ctx, args, caller) => ctx.runMutation(component.public.saveProgress, progressArgsFor(args, caller))
+    ),
+    loadProgress: exposed(
+      "query",
+      progressArgs,
+      async (ctx, args, caller) => ctx.runQuery(component.public.loadProgress, progressArgsFor(args, caller))
+    ),
+    markComplete: exposed(
+      "mutation",
+      progressArgs,
+      async (ctx, args, caller) => ctx.runMutation(component.public.markComplete, progressArgsFor(args, caller))
+    ),
+    resetProgress: exposed(
+      "mutation",
+      progressArgs,
+      async (ctx, args, caller) => ctx.runMutation(component.public.resetProgress, progressArgsFor(args, caller))
+    )
+  };
+}
+var BUILDERS = {
+  public: { query: queryGeneric, mutation: mutationGeneric, action: actionGeneric },
+  internal: { query: internalQueryGeneric, mutation: internalMutationGeneric, action: internalActionGeneric }
+};
+function registerFunctions(functions, visibility, wrap) {
+  const entries = Object.entries(functions).map(([name, fn]) => {
+    const builder = BUILDERS[visibility][fn.kind];
+    return [name, builder({ args: fn.args, handler: wrap(name, fn) })];
+  });
+  return Object.fromEntries(entries);
+}
+
+// src/client.ts
 var Devultur = class {
+  /** The mounted component (`components.devultur`) this client calls. */
   component;
   constructor(component) {
     this.component = component;
@@ -40,10 +188,20 @@ var Devultur = class {
   /**
    * Records an upload in the component once its bytes are stored (after the PUT): it then shows in `listMedia`.
    * Returns the record, or `null` when nothing is stored at `key`. Uploads nobody confirms are recorded a day later.
+   * `width`, `height` and `pageCount` are the client's hints (positive integers up to 100,000); an image size the
+   * Worker read from the bytes wins over them.
    */
   async confirmUpload(ctx, args) {
     return ctx.runAction(this.component.uploads.confirmUpload, args);
   }
+  /**
+   * Sets a record's `title`, `alt` and/or `tags` (only the ones passed; an empty string clears a title or alt, `[]`
+   * the tags). `key` is the media id. Trimmed and deduplicated; past title 200, alt 1000 or 20 tags of 50 characters
+   * it throws `invalid_media_metadata`. Returns the updated record, or `null` when there is none.
+   */
+  async updateMediaMeta(ctx, args) {
+    return ctx.runMutation(this.component.metadata.updateMediaMeta, args);
+  }
   /**
    * The recorded media (every confirmed upload, and every video sent to `processVideo`), optionally of one type.
    * `mediaFromRecord(record)` turns a row into the reference `<Image>` and `dv.media()` take. Unbounded: it reads every
@@ -56,6 +214,21 @@ var Devultur = class {
   async listMediaPage(ctx, args) {
     return ctx.runQuery(this.component.public.listMediaPage, args);
   }
+  /**
+   * One page of the records whose title or filename matches `search` (its last word as a prefix), best match first,
+   * optionally of one type. A blank `search` lists newest first, like `listMediaPage`. Records from before 1.4.0
+   * match once `backfillSearchText` (or any write) gives them a `searchText`.
+   */
+  async searchMedia(ctx, args) {
+    return ctx.runQuery(this.component.library.searchMedia, args);
+  }
+  /**
+   * One-off for records written before 1.4.0: gives every record without a `searchText` one, `batchSize` records
+   * per mutation (default 100, at most 1000). Runs the first batch and schedules the rest. Safe to run again.
+   */
+  async backfillSearchText(ctx, options) {
+    return ctx.runMutation(this.component.library.backfillSearchText, options ?? {});
+  }
   /** The lock in force on `key`. */
   async getLock(ctx, key) {
     return ctx.runAction(this.component.lock.getLock, { key });
@@ -72,137 +245,32 @@ var Devultur = class {
   async releaseHold(ctx, keys) {
     return ctx.runAction(this.component.lock.releaseHold, { keys });
   }
+  /**
+   * The component's functions for your app to export. They have no auth of their own: anyone who can call your
+   * Convex deployment can call them. `defineDevulturFunctions` returns the same functions behind your guard.
+   */
   static exposeApi(component, config) {
-    const preset = config?.video?.transcodePreset;
-    const locales = config?.video?.captionLocales ?? [];
-    const visibilityArg = v.optional(v.union(v.literal("public"), v.literal("private")));
-    const uploadLock = config?.upload?.lock;
-    return {
-      issueViewerToken: actionGeneric({
-        args: { sessionSecret: v.optional(v.string()) },
-        handler: async (ctx, args) => {
-          return ctx.runAction(component.public.issueViewerToken, args);
-        }
-      }),
-      createUploadUrl: actionGeneric({
-        args: { filename: v.string(), contentType: v.string(), visibility: visibilityArg },
-        handler: async (ctx, args) => {
-          return ctx.runAction(component.public.createUploadUrl, {
-            ...args,
-            ...uploadLock ? { lock: uploadLock } : {}
-          });
-        }
-      }),
-      // Records an upload once its bytes are stored (the Worker HEADs the key): a browser can't list anything
-      // that isn't in your bucket. `useDevultur().upload()` and `useMediaUpload` call it after the PUT.
-      confirmUpload: actionGeneric({
-        args: {
-          key: v.string(),
-          filename: v.optional(v.string()),
-          width: v.optional(v.number()),
-          height: v.optional(v.number())
-        },
-        handler: async (ctx, args) => {
-          return ctx.runAction(component.uploads.confirmUpload, args);
-        }
-      }),
-      deleteMedia: actionGeneric({
-        args: { key: v.string() },
-        handler: async (ctx, args) => {
-          return ctx.runAction(component.public.deleteMediaAction, args);
-        }
-      }),
-      deleteVideo: actionGeneric({
-        args: { videoId: v.string(), visibility: visibilityArg },
-        handler: async (ctx, args) => {
-          return ctx.runAction(component.public.deleteVideo, args);
-        }
-      }),
-      processVideo: actionGeneric({
-        args: { key: v.string() },
-        handler: async (ctx, args) => {
-          return ctx.runAction(component.public.processVideo, {
-            key: args.key,
-            preset,
-            locales
-          });
-        }
-      }),
-      getMedia: queryGeneric({
-        args: { key: v.string() },
-        handler: async (ctx, args) => {
-          const mediaKey = args.key.includes("/") ? extractId(args.key) : args.key;
-          return ctx.runQuery(component.public.getMediaByKey, { key: mediaKey });
-        }
-      }),
-      // The media library, a page at a time (for `usePaginatedQuery`). It lists every record, of every user: export
-      // it only when every caller may see the whole library, otherwise wrap `devultur.listMediaPage` with your checks.
-      listMediaPage: queryGeneric({
-        args: {
-          type: v.optional(v.union(v.literal("video"), v.literal("image"), v.literal("file"))),
-          paginationOpts: paginationOptsValidator
-        },
-        handler: async (ctx, args) => {
-          return ctx.runQuery(component.public.listMediaPage, args);
-        }
-      }),
-      saveProgress: mutationGeneric({
-        args: { userId: v.string(), videoId: v.string(), position: v.number() },
-        handler: async (ctx, args) => {
-          return ctx.runMutation(component.public.saveProgress, args);
-        }
-      }),
-      loadProgress: queryGeneric({
-        args: { userId: v.string(), videoId: v.string() },
-        handler: async (ctx, args) => {
-          return ctx.runQuery(component.public.loadProgress, args);
-        }
-      }),
-      markComplete: mutationGeneric({
-        args: { userId: v.string(), videoId: v.string() },
-        handler: async (ctx, args) => {
-          return ctx.runMutation(component.public.markComplete, args);
-        }
-      }),
-      resetProgress: mutationGeneric({
-        args: { userId: v.string(), videoId: v.string() },
-        handler: async (ctx, args) => {
-          return ctx.runMutation(component.public.resetProgress, args);
-        }
-      })
-    };
+    return registerFunctions(exposedFunctions(component, config), "public", (_name, fn) => {
+      return (ctx, args) => fn.handler(ctx, args, {});
+    });
   }
 };
 
-// src/errors.ts
-import { ConvexError } from "convex/values";
-function isErrorData(data) {
-  if (typeof data !== "object" || data === null) return false;
-  const fields = data;
-  return typeof fields.code === "string" && typeof fields.status === "number" && typeof fields.message === "string";
-}
-function isDevulturError(error) {
-  return error instanceof ConvexError && isErrorData(error.data);
-}
-function devulturErrorOf(error) {
-  return isDevulturError(error) ? error.data : null;
-}
-
-// src/media-record.ts
-function mediaFromRecord(record) {
-  if (!record.visibility) return null;
-  return {
-    id: record.key,
-    kind: record.type,
-    visibility: record.visibility,
-    filename: record.filename,
-    ...record.objectKey ? { key: record.objectKey } : {},
-    ...record.width !== void 0 ? { width: record.width } : {},
-    ...record.height !== void 0 ? { height: record.height } : {}
-  };
+// src/guarded-functions.ts
+function defineDevulturFunctions(devultur, options) {
+  const { guard, config } = options;
+  const visibility = options.visibility ?? "public";
+  return registerFunctions(exposedFunctions(devultur.component, config), visibility, (name, fn) => {
+    return async (ctx, args) => {
+      const operation = { name, kind: fn.kind, args };
+      const caller = await guard(ctx, operation) ?? {};
+      return fn.handler(ctx, args, caller);
+    };
+  });
 }
 export {
   CaptionLocale,
+  DEVULTUR_ERROR_CODES,
   Devultur,
   ImageFit,
   ImageFormat,
@@ -212,8 +280,12 @@ export {
   TranscodePreset,
   TranscodeProvider,
   TranslationProvider,
+  defineDevulturFunctions,
+  describeDevulturError,
+  devulturErrorLabels,
   devulturErrorOf,
   dv,
   isDevulturError,
+  isDevulturErrorCode,
   mediaFromRecord
 };

package/dist/locales/es.d.ts

@@ -0,0 +1,11 @@
+import { A as AttachmentLabels, M as MediaLibraryLabels, a as MediaPickerLabels } from '../media-picker-labels-CiVcNUZo.js';
+import { D as DevulturErrorLabels } from '../error-labels-BfqcFh2R.js';
+import '../types-LrusGVDf.js';
+import '@devultur/core';
+
+declare const devulturErrorLabels: DevulturErrorLabels;
+declare const attachmentLabels: AttachmentLabels;
+declare const mediaLibraryLabels: MediaLibraryLabels;
+declare const mediaPickerLabels: MediaPickerLabels;
+
+export { attachmentLabels, devulturErrorLabels, mediaLibraryLabels, mediaPickerLabels };

package/dist/locales/es.js

@@ -0,0 +1,162 @@
+import {
+  formatDuration,
+  formatFileSize
+} from "../chunk-QBHIZBOQ.js";
+import {
+  describeDevulturError,
+  formatBytes,
+  formatDate
+} from "../chunk-EX3W77VY.js";
+
+// src/locales/es.ts
+var LOCALE = "es";
+var devulturErrorLabels = {
+  file_too_large: (details) => {
+    const limit = typeof details.limit === "number" ? formatBytes(details.limit, LOCALE) : null;
+    return limit ? `El archivo supera el tama\xF1o m\xE1ximo (${limit}).` : "El archivo supera el tama\xF1o m\xE1ximo.";
+  },
+  content_type_not_allowed: "Este tipo de archivo no est\xE1 permitido.",
+  content_type_mismatch: "El contenido del archivo no coincide con su tipo.",
+  content_unverified: "No se pudo verificar la subida. Vuelve a intentarlo.",
+  unsupported_content_type: "Este tipo de archivo no es compatible.",
+  media_type_mismatch: "El tipo de archivo no coincide con el tipo de contenido esperado.",
+  already_exists: "Ya existe un archivo con este nombre.",
+  write_conflict: "El archivo cambi\xF3 mientras se guardaba. Vuelve a intentarlo.",
+  upload_not_found: "No se encontr\xF3 la subida o ya venci\xF3. Vuelve a empezarla.",
+  invalid_upload_key: "Esta subida no es v\xE1lida.",
+  invalid_path: "La ruta del archivo no es v\xE1lida.",
+  path_required: "Esta subida necesita una ruta de archivo.",
+  invalid_expires_in: "El tiempo de vencimiento no es v\xE1lido.",
+  invalid_file_expires_in: "El tiempo de vencimiento del archivo no es v\xE1lido.",
+  invalid_cache_control: "La configuraci\xF3n de cach\xE9 no es v\xE1lida.",
+  invalid_limits: "Los l\xEDmites de la subida no son v\xE1lidos.",
+  invalid_prefix: "La carpeta no es v\xE1lida.",
+  invalid_visibility: "La visibilidad debe ser p\xFAblica o privada.",
+  invalid_cursor: "La p\xE1gina de resultados no es v\xE1lida. Vuelve a cargar la lista.",
+  invalid_sha256: "La suma de verificaci\xF3n del archivo no es v\xE1lida.",
+  sha256_mismatch: "El archivo se da\xF1\xF3 durante la subida. Vuelve a intentarlo.",
+  max_files_reached: "Alcanzaste el n\xFAmero m\xE1ximo de archivos para esta subida.",
+  invalid_multipart: "La solicitud de subida no es v\xE1lida.",
+  invalid_size: "El tama\xF1o del archivo no es v\xE1lido.",
+  invalid_part: "Una parte de la subida no es v\xE1lida. Vuelve a intentarlo.",
+  invalid_parts: "La subida est\xE1 incompleta. Vuelve a intentarlo.",
+  part_size_mismatch: "Una parte de la subida tiene un tama\xF1o incorrecto. Vuelve a intentarlo.",
+  part_sha256_required: "A una parte de la subida le falta la suma de verificaci\xF3n.",
+  invalid_media_metadata: (details) => {
+    if (details.field === "title") return "El t\xEDtulo no puede tener m\xE1s de 200 caracteres.";
+    if (details.field === "alt") return "El texto alternativo no puede tener m\xE1s de 1000 caracteres.";
+    if (details.field === "tags") return "Usa como m\xE1ximo 20 etiquetas, de hasta 50 caracteres cada una.";
+    return "Los datos del archivo no son v\xE1lidos.";
+  },
+  expired: "Este archivo ya venci\xF3.",
+  invalid_key: "La referencia del archivo no es v\xE1lida.",
+  invalid_max_uses: "El n\xFAmero de usos no es v\xE1lido.",
+  link_exists: "Este enlace de descarga ya existe.",
+  link_not_found: "Este enlace de descarga no existe.",
+  link_expired: "Este enlace de descarga ya venci\xF3.",
+  link_used: "Este enlace de descarga ya se us\xF3.",
+  not_configured: "Esta funci\xF3n no est\xE1 configurada.",
+  retention_active: (details) => {
+    if (details.hold === true) return "Este archivo tiene una retenci\xF3n legal y no se puede modificar ni eliminar.";
+    const until = formatDate(details.until, LOCALE);
+    return until ? `Este archivo est\xE1 protegido hasta el ${until} y no se puede modificar ni eliminar antes de esa fecha.` : "Este archivo est\xE1 protegido y no se puede modificar ni eliminar.";
+  },
+  lock_conflict: "La protecci\xF3n del archivo cambi\xF3 mientras tanto. Vuelve a intentarlo.",
+  compliance_extend_only: "La protecci\xF3n de este archivo solo se puede extender.",
+  lock_privilege_required: "No tienes permiso para acortar ni quitar la protecci\xF3n de este archivo.",
+  lock_record_unreadable: "No se pudo leer la protecci\xF3n del archivo.",
+  lock_below_minimum: "Esta subida requiere una protecci\xF3n m\xE1s estricta.",
+  invalid_lock: "La configuraci\xF3n de protecci\xF3n no es v\xE1lida.",
+  invalid_hold: "La configuraci\xF3n de retenci\xF3n legal no es v\xE1lida.",
+  reserved_key: "Este nombre de archivo est\xE1 reservado.",
+  keys_bucket_missing: "En este momento no se pueden guardar archivos de forma segura.",
+  encryption_key_missing: "Este archivo ya no se puede leer. Vuelve a subirlo.",
+  unauthorized: "No tienes autorizaci\xF3n para hacer esto.",
+  session_mismatch: "Tu sesi\xF3n cambi\xF3. Vuelve a cargar la p\xE1gina.",
+  token_rejected: "Se deneg\xF3 el acceso.",
+  reserved_user_id: "Este identificador de usuario est\xE1 reservado.",
+  invalid_scopes: "Los permisos solicitados no son v\xE1lidos.",
+  user_mismatch: "Solo puedes ver y cambiar tu propio progreso.",
+  transcode_not_configured: "El procesamiento de video no est\xE1 configurado.",
+  transcode_runner_unavailable: "El procesamiento de video est\xE1 ocupado en este momento. Vuelve a intentarlo m\xE1s tarde.",
+  transcode_launch_failed: "No se pudo procesar el video.",
+  original_not_retained: "El video original ya no est\xE1 disponible, as\xED que no se puede volver a procesar. Vuelve a subirlo.",
+  locale_not_allowed: "Los subt\xEDtulos no est\xE1n disponibles en este idioma.",
+  captions_provider_rate_limited: "El servicio de subt\xEDtulos est\xE1 ocupado en este momento. Vuelve a intentarlo m\xE1s tarde.",
+  captions_provider_error: "No se pudieron generar los subt\xEDtulos.",
+  captions_failed: "No se pudieron generar los subt\xEDtulos.",
+  webhook_secret_missing: "El procesamiento de video no est\xE1 configurado.",
+  worker_auth_secret_missing: "El servicio de medios no est\xE1 configurado.",
+  worker_error: "El servicio de medios no pudo completar la solicitud.",
+  http_error: "No se pudo cargar el archivo.",
+  too_large: "El archivo es demasiado grande para la vista previa.",
+  unsupported_type: "Este tipo de archivo no tiene vista previa.",
+  type_mismatch: "El contenido del archivo no coincide con su tipo.",
+  token_unavailable: "No se pudo autorizar el acceso a este archivo. Vuelve a intentarlo.",
+  capability_unavailable: "Esta aplicaci\xF3n no puede hacer eso aqu\xED."
+};
+var KIND_TEXT = {
+  image: "Imagen",
+  video: "Video",
+  pdf: "PDF",
+  audio: "Audio",
+  text: "Texto",
+  file: "Archivo"
+};
+var attachmentLabels = {
+  locale: LOCALE,
+  size: formatFileSize,
+  pages: (pageCount) => pageCount === 1 ? "1 p\xE1gina" : `${pageCount.toLocaleString(LOCALE)} p\xE1ginas`,
+  duration: formatDuration,
+  kind: (kind) => KIND_TEXT[kind],
+  download: "Descargar",
+  open: "Abrir vista previa",
+  untitled: "Archivo sin t\xEDtulo"
+};
+var mediaLibraryLabels = {
+  search: "Buscar archivos",
+  searchPlaceholder: "Busca por t\xEDtulo o nombre de archivo",
+  typeFilter: "Tipo",
+  allTypes: "Todos los tipos",
+  types: { image: "Im\xE1genes", video: "Videos", file: "Archivos" },
+  results: "Archivos",
+  loading: "Cargando archivos\u2026",
+  empty: "Todav\xEDa no hay archivos.",
+  noResults: (search) => `Nada coincide con \xAB${search}\xBB.`,
+  loadMore: "Cargar m\xE1s",
+  loadingMore: "Cargando\u2026",
+  error: (error) => describeDevulturError(error, devulturErrorLabels) ?? "No se pudieron cargar los archivos.",
+  retry: "Reintentar",
+  size: (bytes) => formatFileSize(bytes, LOCALE)
+};
+var mediaPickerLabels = {
+  upload: (multiple) => multiple ? "Subir archivos" : "Subir un archivo",
+  dropHint: (multiple) => multiple ? "o suelta los archivos aqu\xED" : "o suelta un archivo aqu\xED",
+  uploads: "Subidas",
+  progress: (filename) => `Subiendo ${filename}`,
+  percent: (percent) => `${percent} %`,
+  uploading: (filename) => `Subiendo ${filename}.`,
+  uploaded: (filename) => `${filename} se subi\xF3 y qued\xF3 seleccionado.`,
+  cancel: "Cancelar",
+  cancelUpload: (filename) => `Cancelar la subida de ${filename}`,
+  cancelled: (filename) => `Se cancel\xF3 la subida de ${filename}.`,
+  notAccepted: (filename) => `${filename} no es un tipo de archivo que se pueda elegir aqu\xED.`,
+  uploadError: (error) => describeDevulturError(error, devulturErrorLabels) ?? "La subida fall\xF3. Vuelve a intentarlo.",
+  retry: "Reintentar",
+  dismiss: "Descartar",
+  selection: "Archivos seleccionados",
+  empty: "No hay nada seleccionado.",
+  remove: "Quitar",
+  removeItem: (name) => `Quitar ${name}`,
+  clear: "Limpiar",
+  replace: "Reemplazar",
+  selected: (name) => `${name} seleccionado.`,
+  removed: (name) => `${name} se quit\xF3.`,
+  cleared: "Se limpi\xF3 la selecci\xF3n."
+};
+export {
+  attachmentLabels,
+  devulturErrorLabels,
+  mediaLibraryLabels,
+  mediaPickerLabels
+};

package/dist/media-picker-labels-CiVcNUZo.d.ts

@@ -0,0 +1,114 @@
+import { M as MediaRecord } from './types-LrusGVDf.js';
+
+/** What an attachment is, for its icon and type label. */
+type AttachmentKind = "image" | "video" | "pdf" | "audio" | "text" | "file";
+/**
+ * Every string `<AttachmentCard>` and `<DocumentLink>` show or announce. Pass any subset as `labels`; the rest keep
+ * the English defaults (`defaultAttachmentLabels`). Spanish: `attachmentLabels` from `@devultur/convex/locales/es`.
+ */
+interface AttachmentLabels {
+    /** BCP 47 locale passed to `size`. A component's `locale` prop wins over it. */
+    locale: string;
+    /** A file size, e.g. `1.5 MB`. */
+    size: (bytes: number, locale: string) => string;
+    /** A PDF's page count, e.g. `12 pages`. */
+    pages: (pageCount: number) => string;
+    /** An audio or video duration, e.g. `1:05`. */
+    duration: (seconds: number) => string;
+    /** The type shown next to the size, e.g. `PDF`. */
+    kind: (kind: AttachmentKind) => string;
+    /** Text of the download action. */
+    download: string;
+    /** Text of the open-preview action. */
+    open: string;
+    /** Name of a media with no `title` and no filename. */
+    untitled: string;
+}
+/** `bytes` in decimal units (`1.5 MB`), formatted for `locale`. Under 1 kB, whole bytes (`512 bytes`). */
+declare function formatFileSize(bytes: number, locale: string): string;
+/** `seconds` as a clock: `0:42`, `1:05`, `1:02:03`. */
+declare function formatDuration(seconds: number): string;
+declare const defaultAttachmentLabels: AttachmentLabels;
+
+type MediaType = MediaRecord["type"];
+/** Every string `<MediaLibrary>` shows or announces. Pass any subset as `labels`; the rest stay English. */
+interface MediaLibraryLabels {
+    /** Accessible name of the search box. */
+    search: string;
+    searchPlaceholder: string;
+    /** Accessible name of the type filter. */
+    typeFilter: string;
+    /** The type filter's option for every kind. */
+    allTypes: string;
+    types: Record<MediaType, string>;
+    /** Accessible name of the list of media. */
+    results: string;
+    /** Shown while the first page loads. */
+    loading: string;
+    /** The library has nothing (of this type). */
+    empty: string;
+    /** Nothing matches the search. */
+    noResults: (search: string) => string;
+    loadMore: string;
+    /** The load-more button while the next page loads. */
+    loadingMore: string;
+    /** Shown when the library couldn't be loaded. Default: the Devultur error's message, if it is one. */
+    error: (error: unknown) => string;
+    retry: string;
+    /** A record's size. Not shown for a size of 0 (a video only `processVideo` recorded). */
+    size: (bytes: number) => string;
+}
+declare const defaultMediaLibraryLabels: MediaLibraryLabels;
+
+/**
+ * Every string `<MediaPicker>` shows or announces (the library's and the cards' have their own: `libraryLabels`,
+ * `attachmentLabels`). Pass any subset as `labels`; the rest stay English. Spanish: `mediaPickerLabels` from
+ * `@devultur/convex/locales/es`.
+ */
+interface MediaPickerLabels {
+    /** The upload button: one file, or several with `multiple`. */
+    upload: (multiple: boolean) => string;
+    /** Next to the upload button, for dragging files onto it. */
+    dropHint: (multiple: boolean) => string;
+    /** Accessible name of the list of uploads in progress. */
+    uploads: string;
+    /** Accessible name of a file's progress bar. */
+    progress: (filename: string) => string;
+    /** A file's progress as text. */
+    percent: (percent: number) => string;
+    /** Announced when a file starts uploading. */
+    uploading: (filename: string) => string;
+    /** Announced when a file has uploaded (and is selected). */
+    uploaded: (filename: string) => string;
+    cancel: string;
+    /** Accessible name of a file's cancel button. */
+    cancelUpload: (filename: string) => string;
+    /** Announced when an upload is cancelled. */
+    cancelled: (filename: string) => string;
+    /** A file `accept` turns away, before it uploads. */
+    notAccepted: (filename: string) => string;
+    /** Why an upload failed. Default: the Devultur error's message, if it is one. */
+    uploadError: (error: unknown) => string;
+    retry: string;
+    dismiss: string;
+    /** Heading and accessible name of the selection. */
+    selection: string;
+    /** Nothing is selected. */
+    empty: string;
+    remove: string;
+    /** Accessible name of an item's remove button. */
+    removeItem: (name: string) => string;
+    /** Removes every selected item. */
+    clear: string;
+    /** Picks another file in place of the selected one (single selection). */
+    replace: string;
+    /** Announced when an item is selected. */
+    selected: (name: string) => string;
+    /** Announced when an item is removed from the selection. */
+    removed: (name: string) => string;
+    /** Announced when the selection is cleared. */
+    cleared: string;
+}
+declare const defaultMediaPickerLabels: MediaPickerLabels;
+
+export { type AttachmentLabels as A, type MediaLibraryLabels as M, type MediaPickerLabels as a, type AttachmentKind as b, defaultMediaLibraryLabels as c, defaultAttachmentLabels as d, defaultMediaPickerLabels as e, formatDuration as f, formatFileSize as g };

package/dist/{pdf-render-CiCK6V1X.d.ts → pdf-render-BwJGagvz.d.ts}

@@ -40,4 +40,4 @@ interface PdfjsModule {
 /** Imports pdf.js, e.g. `() => import("pdfjs-dist/legacy/build/pdf.mjs")`. */
 type PdfjsLoader = () => Promise<PdfjsModule>;
 
-export type { PdfjsModule as P, PdfjsLoader as a };
+export type { PdfjsLoader as P, PdfjsModule as a };