@signalcore/ui 0.1.0 → 1.0.0-beta.0

package/src/kit/dates.ts

@@ -0,0 +1,150 @@
+/**
+ * Days and times as the kit's controls hold them, "YYYY-MM-DD", "HH:MM" and
+ * "YYYY-MM-DDTHH:MM", as pure functions: reading them, writing them in a language, and which
+ * of them a control offers.
+ */
+
+/** What bounds a day: the only days to pick, and the first and last. */
+export interface DayBounds {
+  dates?: string[] | undefined;
+  earliest?: string | undefined;
+  latest?: string | undefined;
+}
+
+export const DAY = /^\d{4}-\d{2}-\d{2}$/;
+export const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+export const MOMENT = /^\d{4}-\d{2}-\d{2}T([01]\d|2[0-3]):[0-5]\d$/;
+
+/** A day "YYYY-MM-DD" as a local date, or null. */
+export function dayOf(iso: string): Date | null {
+  if (!DAY.test(iso)) return null;
+  const [year = 0, month = 1, day = 1] = iso.split("-").map(Number);
+  const date = new Date(year, month - 1, day);
+  return date.getMonth() === month - 1 ? date : null;
+}
+
+/** A local date as "YYYY-MM-DD". */
+export function isoDay(date: Date): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/** A day in words: its weekday, day and month, and its year when not this one. */
+export function formatDay(iso: string, code: string, today: Date = new Date()): string {
+  const day = dayOf(iso);
+  if (!day) return iso;
+  return new Intl.DateTimeFormat(code, {
+    weekday: "long",
+    day: "numeric",
+    month: "long",
+    ...(day.getFullYear() !== today.getFullYear() && { year: "numeric" }),
+  }).format(day);
+}
+
+/** A time "HH:MM" as the language writes it: "10:30", or "10:30 AM". */
+export function formatTime(time: string, code: string): string {
+  const [hours = 0, minutes = 0] = time.split(":").map(Number);
+  const at = new Date(2000, 0, 1, hours, minutes);
+  const clock = new Intl.DateTimeFormat(code, { hour: "numeric", minute: "2-digit" });
+  // The day's end, as a 24-hour clock writes it ("24:00"), not as the next day's start.
+  if (hours === 24 && clock.resolvedOptions().hourCycle === "h23") {
+    return new Intl.DateTimeFormat(code, {
+      hour: "numeric",
+      minute: "2-digit",
+      hourCycle: "h24",
+    }).format(at);
+  }
+  return clock.format(at);
+}
+
+/** A moment in words; a half-picked one reads as the half there is. */
+export function formatMoment(moment: string, code: string, today: Date = new Date()): string {
+  const [date, time] = momentParts(moment);
+  if (!date || !TIME.test(time)) return date ? formatDay(date, code, today) : time;
+  const day = dayOf(date);
+  if (!day) return moment;
+  const [hours = 0, minutes = 0] = time.split(":").map(Number);
+  day.setHours(hours, minutes);
+  return new Intl.DateTimeFormat(code, {
+    weekday: "long",
+    day: "numeric",
+    month: "long",
+    ...(day.getFullYear() !== today.getFullYear() && { year: "numeric" }),
+    hour: "numeric",
+    minute: "2-digit",
+  }).format(day);
+}
+
+/** Whether a day is offered: one of the `dates` when there are, within the bounds. */
+export function dayAllowed(bounds: DayBounds, iso: string): boolean {
+  if (!DAY.test(iso)) return false;
+  if (bounds.dates && !bounds.dates.includes(iso)) return false;
+  if (bounds.earliest !== undefined && iso < bounds.earliest) return false;
+  if (bounds.latest !== undefined && iso > bounds.latest) return false;
+  return true;
+}
+
+/** Whether a time is offered: one of the `times` when there are. */
+export function slotAllowed(times: string[] | undefined, time: string): boolean {
+  return times === undefined || times.includes(time);
+}
+
+/** The day a calendar opens on: the one picked, else the first offered, else today. */
+export function openingDay(bounds: DayBounds, picked: string | null, today: Date): string {
+  if (picked && DAY.test(picked)) return picked;
+  const first = bounds.dates?.toSorted()[0] ?? bounds.earliest;
+  const now = isoDay(today);
+  if (first !== undefined && (bounds.dates || first > now)) return first;
+  return bounds.latest !== undefined && bounds.latest < now ? bounds.latest : now;
+}
+
+/** The first and last days a calendar can go to, when they are bounded. */
+export function daySpan(bounds: DayBounds): { first?: string; last?: string } {
+  const sorted = bounds.dates?.toSorted();
+  const first = sorted?.[0] ?? bounds.earliest;
+  const last = sorted?.at(-1) ?? bounds.latest;
+  return { ...(first !== undefined && { first }), ...(last !== undefined && { last }) };
+}
+
+/** A moment's day and time, either "" while not picked: "2026-10-14T" is a day alone. */
+export function momentParts(moment: string | null): [date: string, time: string] {
+  if (!moment) return ["", ""];
+  const at = moment.indexOf("T");
+  return at < 0 ? [moment, ""] : [moment.slice(0, at), moment.slice(at + 1, at + 6)];
+}
+
+/** A moment from its parts, held while half picked; null when neither is. */
+export function momentOf(date: string, time: string): string | null {
+  return date === "" && time === "" ? null : `${date}T${time}`;
+}
+
+/** Every half hour of a day, "00:00" to "23:30": what a time offers without its own slots. */
+export function halfHours(): string[] {
+  return Array.from({ length: 48 }, (_, index) => {
+    const hours = String(Math.floor(index / 2)).padStart(2, "0");
+    return `${hours}:${index % 2 === 0 ? "00" : "30"}`;
+  });
+}
+
+/** The day's end, where a stretch of it can end: midnight at its close. */
+export const DAY_END = "24:00";
+
+/** A time a stretch of the day ends at, as typed: any time, or the day's end ("24", "24:00"). */
+export function parseEndTime(typed: string): string | null {
+  return /^24(?:[:.h]?00)?$/i.test(typed.trim()) ? DAY_END : parseTime(typed);
+}
+
+/** A time as a person types it, as "HH:MM", or null: "9", "930", "9:30", "21.30", "9:30 pm". */
+export function parseTime(typed: string): string | null {
+  const match = /^(\d{1,2})(?:[:.h]?(\d{2}))?\s*([ap])?\.?\s*m?\.?$/i.exec(typed.trim());
+  if (!match) return null;
+  let hours = Number(match[1]);
+  const minutes = Number(match[2] ?? "0");
+  const half = match[3]?.toLowerCase();
+  if (half) {
+    if (hours < 1 || hours > 12) return null;
+    hours = (hours % 12) + (half === "p" ? 12 : 0);
+  }
+  if (hours > 23 || minutes > 59) return null;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}

package/src/kit/messages.ts

@@ -0,0 +1,160 @@
+import type { DayPickerLocale } from "react-day-picker";
+
+import { AUTOMATION_MESSAGES, type AutomationMessages } from "../automation/messages";
+
+/**
+ * The language the kit's dates are read in: a locale from `@signalcore/ui/locale` (the
+ * calendar's, with its words), whose `code` also formats days, times, numbers and lists.
+ */
+export type KitLocale = DayPickerLocale;
+
+/** The words the kit's controls say; a host gives its own, in its language. */
+export interface KitMessages {
+  /** A field left empty that must be filled. */
+  required: string;
+  /** A day, a time, both, an option, a rating still to pick; also an empty picker's invitation. */
+  chooseDate: string;
+  chooseTime: string;
+  chooseMoment: string;
+  chooseOption: string;
+  chooseRating: string;
+  /** A box that must be ticked to go on. */
+  check: string;
+  invalidEmail: string;
+  invalidPhone: string;
+  invalidUrl: string;
+  invalidNumber: string;
+  /** A time typed in a shape that is not one. */
+  invalidTime: string;
+  /** A number under its least, or over its most, given formatted. */
+  atLeast: (min: string) => string;
+  atMost: (max: string) => string;
+  /** A day or a time that is not offered. */
+  unavailableDate: string;
+  unavailableTime: string;
+  /** Beside the label of a field that may stay empty. */
+  optional: string;
+  /** In a long list's box while nothing is picked. */
+  pick: string;
+  /** In that box while the person types. */
+  search: string;
+  noResults: string;
+  /** The button that shows or hides a secret as it is typed. */
+  show: string;
+  hide: string;
+  /** A number's steppers, for screen readers. */
+  increase: string;
+  decrease: string;
+  /** A picked tag's remove button, for screen readers. */
+  remove: (label: string) => string;
+  /** A box ticked or not, as an answer reads. */
+  yes: string;
+  no: string;
+  /** A rating, as an answer reads. */
+  rated: (value: number, max: number) => string;
+  /** One star of a rating, for screen readers. */
+  stars: (count: number) => string;
+  /** A choice's last row, to answer in one's own words, and its box while empty. */
+  other: string;
+  otherPlaceholder: string;
+  /** A form's submit when the agent gave it no words. */
+  send: string;
+  /** Where a form's submit was, once it is sent. */
+  sent: string;
+  /** A file field left empty that must be filled. */
+  chooseFile: string;
+  /** A file field's drop zone: what it asks, and how. */
+  upload: (multiple: boolean) => string;
+  drop: string;
+  /**
+   * Under them, what it takes: the kinds (named and joined, "" when anything) and the most a
+   * file may weigh, formatted.
+   */
+  limits: (kinds: string, size: string) => string;
+  /** A family of kinds as the limits name it: "image" for any image, "video", "audio", "text". */
+  anyOf: (family: string) => string;
+  /** A file on its way, beside how much has gone. */
+  uploading: string;
+  /** A file that was not sent: heavier than the most (formatted), a kind not taken, one too many. */
+  tooBig: (size: string) => string;
+  wrongType: string;
+  tooMany: (max: number) => string;
+  /** A file whose upload failed, and the button that tries it again. */
+  uploadFailed: string;
+  retry: string;
+  /** A form sent while a file is still on its way, or one failed. */
+  stillUploading: string;
+  fixFiles: string;
+  /** A file's chip, opened on a click, for screen readers. */
+  open: (name: string) => string;
+  /** A file whose name is not known yet. */
+  file: string;
+  /** An audio player's button, and its way through, for screen readers. */
+  play: string;
+  pause: string;
+  position: string;
+  /** An automation and its runs: when it runs, how it stands, what each run did. */
+  automation: AutomationMessages;
+}
+
+const FAMILIES: Readonly<Record<string, string>> = {
+  image: "images",
+  video: "videos",
+  audio: "audio",
+  text: "text",
+};
+
+export const KIT_MESSAGES: KitMessages = {
+  required: "This field is required",
+  chooseDate: "Choose a day",
+  chooseTime: "Choose a time",
+  chooseMoment: "Choose a day and a time",
+  chooseOption: "Choose an option",
+  other: "Another answer",
+  otherPlaceholder: "Write your answer",
+  chooseRating: "Choose a rating",
+  check: "Tick the box to go on",
+  invalidEmail: "Enter a valid email",
+  invalidPhone: "Enter a valid phone number",
+  invalidUrl: "Enter a valid address",
+  invalidNumber: "Enter a number",
+  invalidTime: "Write a time like 9:30",
+  atLeast: (min) => `At least ${min}`,
+  atMost: (max) => `At most ${max}`,
+  unavailableDate: "That day is not available",
+  unavailableTime: "That time is not available",
+  optional: "Optional",
+  pick: "Choose…",
+  search: "Search…",
+  noResults: "No results",
+  show: "Show",
+  hide: "Hide",
+  increase: "Increase",
+  decrease: "Decrease",
+  remove: (label) => `Remove ${label}`,
+  yes: "Yes",
+  no: "No",
+  rated: (value, max) => `${value} of ${max}`,
+  stars: (count) => (count === 1 ? "1 star" : `${count} stars`),
+  send: "Send",
+  sent: "Sent",
+  chooseFile: "Add a file",
+  upload: (multiple) => (multiple ? "Upload files" : "Upload a file"),
+  drop: "Drop it here or choose",
+  limits: (kinds, size) => (kinds ? `${kinds}, up to ${size}` : `Up to ${size}`),
+  anyOf: (family) => FAMILIES[family] ?? family,
+  uploading: "Uploading",
+  tooBig: (size) => `Over ${size}`,
+  wrongType: "This kind of file isn't taken here",
+  tooMany: (max) => `At most ${max} files`,
+  uploadFailed: "Couldn't upload it",
+  retry: "Retry",
+  stillUploading: "Wait for the upload to finish",
+  fixFiles: "Remove or retry the files that failed",
+  open: (name) => `Open ${name}`,
+  file: "File",
+  play: "Play",
+  pause: "Pause",
+  position: "Position",
+  automation: AUTOMATION_MESSAGES,
+};

package/src/kit/numbers.ts

@@ -0,0 +1,44 @@
+/** Numbers as the kit's controls hold and write them, as pure functions. */
+
+/** What bounds a number: its least, its most, the step between values. */
+export interface NumberBounds {
+  min?: number | undefined;
+  max?: number | undefined;
+  step?: number | undefined;
+}
+
+export function formatNumber(value: number, code: string): string {
+  return new Intl.NumberFormat(code, { maximumFractionDigits: 6 }).format(value);
+}
+
+/** A number with its unit after it: "3 personas", "25 €". */
+export function withUnit(text: string, unit: string | undefined): string {
+  return unit ? `${text} ${unit}` : text;
+}
+
+/**
+ * A number one step up or down (`direction` 1 or -1), kept within its bounds and on its step's
+ * decimals; from nothing, it starts at its least, or 0.
+ */
+export function stepped(bounds: NumberBounds, value: number | null, direction: 1 | -1): number {
+  const step = bounds.step ?? 1;
+  const next = value === null ? (bounds.min ?? 0) : value + direction * step;
+  const decimals = (String(step).split(".")[1] ?? "").length;
+  const rounded = Number(next.toFixed(decimals));
+  return Math.min(bounds.max ?? Infinity, Math.max(bounds.min ?? -Infinity, rounded));
+}
+
+const UNITS = ["B", "KB", "MB", "GB"] as const;
+
+/** A file's size as people read it: whole bytes, one decimal under ten of a larger unit. */
+export function formatSize(bytes: number, locale?: string): string {
+  let size = Math.max(0, bytes);
+  let unit = 0;
+  while (size >= 1024 && unit < UNITS.length - 1) {
+    size /= 1024;
+    unit += 1;
+  }
+  const digits = unit === 0 || size >= 10 ? 0 : 1;
+  const number = new Intl.NumberFormat(locale, { maximumFractionDigits: digits }).format(size);
+  return `${number} ${UNITS[unit]}`;
+}

package/src/kit/options.ts

@@ -0,0 +1,30 @@
+/** The options a control offers, as pure functions: finding one, ticking one on and off. */
+
+/** One thing to pick: its id (what comes back), its label, and a quiet line under it. */
+export interface Option {
+  id: string;
+  label: string;
+  hint?: string | undefined;
+}
+
+/** Whether an option is what the person is looking for: in its label, hint or id, any case or accent. */
+export function matches(option: Option, query: string): boolean {
+  const wanted = fold(query.trim());
+  if (wanted === "") return true;
+  return [option.label, option.hint ?? "", option.id].some((text) => fold(text).includes(wanted));
+}
+
+function fold(text: string): string {
+  return text
+    .normalize("NFD")
+    .replace(/\p{Diacritic}/gu, "")
+    .toLowerCase();
+}
+
+/** The ids picked once the person ticks one on or off, in the options' order. */
+export function toggled(options: Option[], picked: readonly string[], id: string): string[] {
+  const on = !picked.includes(id);
+  return options
+    .filter((option) => (option.id === id ? on : picked.includes(option.id)))
+    .map((option) => option.id);
+}

package/src/kit/uploads.ts

@@ -0,0 +1,244 @@
+/**
+ * Files a person picks, as pure functions: whether a field takes one (its kind, its weight), how
+ * a field's kinds and limits read, what family a file is of (for its glyph), and the words for
+ * what went wrong. Nothing here touches the page or the network.
+ */
+import type { Attachment } from "../types";
+import type { KitMessages } from "./messages";
+import { formatSize } from "./numbers";
+
+/** The most a file may weigh anywhere, in MB: the API's ceiling. */
+export const MAX_MB = 50;
+const MB = 1024 * 1024;
+
+/**
+ * Sends one file where it belongs, telling how much of it has gone (0 to 1) as it goes; aborting
+ * `signal` lets it go. Resolves to the file as stored.
+ */
+export type Uploader = (
+  file: File,
+  progress: (share: number) => void,
+  signal: AbortSignal,
+) => Promise<Attachment>;
+
+/** Where a field's files go and how the ones already sent are found: the conversation's. */
+export interface FileHost {
+  upload: Uploader;
+  /** The files known by id: said in the conversation, uploaded to it. */
+  known: ReadonlyMap<string, Attachment>;
+  /** Asks for files it does not know yet, by id: read back from the conversation. */
+  find?: ((ids: readonly string[]) => void) | undefined;
+  /** Opens one, when the host shows files. */
+  open?: ((file: Attachment) => void) | undefined;
+  /**
+   * Where a picture, a video or a sound plays from in the page's own player: an address the
+   * player streams with no credential, for a while.
+   */
+  play?: ((file: Attachment) => Promise<string>) | undefined;
+}
+
+/** A file as picked: its name, its type as the browser gave it ("" when none), its weight. */
+export interface Picked {
+  name: string;
+  type: string;
+  size: number;
+}
+
+/** A name's extension, lowercase, without its dot; "" for one without (`README`, `.env`). */
+export function extensionOf(name: string): string {
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 ? "" : name.slice(dot + 1).toLowerCase();
+}
+
+/** The types a browser often leaves out, by extension. */
+const TYPES: Readonly<Record<string, string>> = {
+  pdf: "application/pdf",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  heic: "image/heic",
+  heif: "image/heif",
+  csv: "text/csv",
+  txt: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  zip: "application/zip",
+};
+
+/** A file's type: the browser's, else the one its extension names, else "". */
+export function typeOf(file: Pick<Picked, "name" | "type">): string {
+  return (file.type || TYPES[extensionOf(file.name)] || "").toLowerCase();
+}
+
+/**
+ * Whether a file is of a kind `accept` lists, read as an <input accept> reads it: a type
+ * ("application/pdf"), a family ("image/*") or an extension (".xlsx"); none takes anything.
+ */
+export function accepts(
+  accept: readonly string[] | undefined,
+  file: Pick<Picked, "name" | "type">,
+): boolean {
+  if (accept === undefined || accept.length === 0) return true;
+  const type = typeOf(file);
+  const extension = extensionOf(file.name);
+  return accept.some((raw) => {
+    const rule = raw.trim().toLowerCase();
+    if (rule === "*" || rule === "*/*") return true;
+    if (rule.startsWith(".")) return extension !== "" && rule === `.${extension}`;
+    if (rule.endsWith("/*")) return type.startsWith(rule.slice(0, -1));
+    return type === rule;
+  });
+}
+
+/** The most a field takes per file, in MB: its own, within the ceiling. */
+export function limitOf(maxMb: number | undefined): number {
+  return maxMb !== undefined && maxMb > 0 ? Math.min(maxMb, MAX_MB) : MAX_MB;
+}
+
+/** That most, as people read it: "10 MB". */
+function limitWords(maxMb: number | undefined, code: string): string {
+  return formatSize(limitOf(maxMb) * MB, code);
+}
+
+/** What keeps a file from being sent, in words: a kind not taken, or past the most; else null. */
+export function refusalOf(
+  file: Picked,
+  accept: readonly string[] | undefined,
+  maxMb: number | undefined,
+  code: string,
+  messages: KitMessages,
+): string | null {
+  if (!accepts(accept, file)) return messages.wrongType;
+  if (file.size > limitOf(maxMb) * MB) return messages.tooBig(limitWords(maxMb, code));
+  return null;
+}
+
+/**
+ * What a failed upload says: past what the server takes (413), a kind it refused (415), or that
+ * it failed, to be tried again.
+ */
+export function failureOf(
+  error: unknown,
+  maxMb: number | undefined,
+  code: string,
+  messages: KitMessages,
+): string {
+  const status =
+    typeof error === "object" && error !== null && "status" in error ? error.status : undefined;
+  if (status === 413) return messages.tooBig(limitWords(maxMb, code));
+  if (status === 415) return messages.wrongType;
+  return messages.uploadFailed;
+}
+
+/** Whether an upload's failure is the person letting it go: nothing to show. */
+export function isAbort(error: unknown): boolean {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+
+/** Short names for the types people know by one. */
+const SHORT: Readonly<Record<string, string>> = Object.fromEntries(
+  Object.entries(TYPES).map(([extension, type]) => [type, extension.toUpperCase()]),
+);
+
+/**
+ * The kinds a field takes as people name them, each once: a family ("image/*") by `anyOf`, a type
+ * by its short name ("PDF", "XLSX"), an extension by its letters; none when it takes anything.
+ */
+export function kindsOf(accept: readonly string[] | undefined, messages: KitMessages): string[] {
+  const rules = (accept ?? []).map((rule) => rule.trim().toLowerCase());
+  if (rules.some((rule) => rule === "*" || rule === "*/*")) return [];
+  const names = rules.map((rule) => {
+    if (rule.startsWith(".")) return rule.slice(1).toUpperCase();
+    if (rule.endsWith("/*")) return messages.anyOf(rule.slice(0, -2));
+    return SHORT[rule] ?? (rule.split("/")[1] ?? rule).toUpperCase();
+  });
+  return [...new Set(names.filter((name) => name !== ""))];
+}
+
+/** The line under a drop zone: the kinds it takes, joined ("Images or PDF"), and its most. */
+export function limitsOf(
+  accept: readonly string[] | undefined,
+  maxMb: number | undefined,
+  code: string,
+  messages: KitMessages,
+): string {
+  const kinds = kindsOf(accept, messages);
+  const joined =
+    kinds.length === 0 ? "" : new Intl.ListFormat(code, { type: "disjunction" }).format(kinds);
+  const line = messages.limits(joined, limitWords(maxMb, code));
+  return line.charAt(0).toLocaleUpperCase(code) + line.slice(1);
+}
+
+/** The families a file's glyph tells apart. */
+export type FileFamily =
+  "image" | "pdf" | "sheet" | "doc" | "slides" | "text" | "archive" | "audio" | "video" | "other";
+
+const FAMILIES: Readonly<Record<string, FileFamily>> = {
+  png: "image",
+  jpg: "image",
+  jpeg: "image",
+  gif: "image",
+  webp: "image",
+  avif: "image",
+  heic: "image",
+  heif: "image",
+  svg: "image",
+  bmp: "image",
+  pdf: "pdf",
+  csv: "sheet",
+  tsv: "sheet",
+  xls: "sheet",
+  xlsx: "sheet",
+  ods: "sheet",
+  numbers: "sheet",
+  doc: "doc",
+  docx: "doc",
+  odt: "doc",
+  rtf: "doc",
+  pages: "doc",
+  ppt: "slides",
+  pptx: "slides",
+  odp: "slides",
+  key: "slides",
+  txt: "text",
+  md: "text",
+  markdown: "text",
+  json: "text",
+  yaml: "text",
+  yml: "text",
+  xml: "text",
+  html: "text",
+  log: "text",
+  zip: "archive",
+  rar: "archive",
+  "7z": "archive",
+  tar: "archive",
+  gz: "archive",
+  mp3: "audio",
+  wav: "audio",
+  m4a: "audio",
+  ogg: "audio",
+  mp4: "video",
+  mov: "video",
+  webm: "video",
+};
+
+/** A file's family, by its name's extension first, then by its type. */
+export function familyOf(name: string, type: string): FileFamily {
+  const known = FAMILIES[extensionOf(name)];
+  if (known) return known;
+  const media = type.toLowerCase();
+  if (media === "application/pdf") return "pdf";
+  const family = media.split("/")[0];
+  return family === "image" || family === "audio" || family === "video" || family === "text"
+    ? family
+    : "other";
+}