@crievo/omni 0.0.0-stage → 0.1.1

package/studio/web/lib/format.ts

@@ -0,0 +1,93 @@
+/* Numbers and times as read in Portuguese: decimal comma, "há 3 min". */
+
+import type { StatusStage, Ticket } from "../types/api";
+
+export function formatSeconds(s: number | null | undefined, decimals = 1) {
+  if (s == null || Number.isNaN(s)) return "—";
+  return `${s.toLocaleString("pt-BR", { minimumFractionDigits: decimals, maximumFractionDigits: decimals })} s`;
+}
+
+/* "1,5 s" with one decimal, without locale grouping (voice samples) */
+export const formatSecondsComma = (s: number) => `${s.toFixed(1).replace(".", ",")} s`;
+
+export function formatElapsed(ms: number) {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}min${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(s / 3600)}h${String(Math.floor((s % 3600) / 60)).padStart(2, "0")}min`;
+}
+
+export function toMs(iso: string | number | null | undefined) {
+  if (iso == null) return null;
+  return typeof iso === "number" ? iso : Date.parse(iso);
+}
+
+export function timeAgo(iso: string | number | null | undefined, now = Date.now()) {
+  const t = toMs(iso);
+  if (t == null) return "—";
+  const s = (now - t) / 1000;
+  if (s < 10) return "agora";
+  if (s < 60) return `há ${Math.floor(s)} s`;
+  if (s < 3600) return `há ${Math.floor(s / 60)} min`;
+  if (s < 86400) return `há ${Math.floor(s / 3600)} h`;
+  return formatWhen(t);
+}
+
+export function formatWhen(iso: string | number | null | undefined) {
+  const t = toMs(iso);
+  if (t == null) return "—";
+  return new Date(t).toLocaleString("pt-BR", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" });
+}
+
+/* a scheduled time: "qua, 14/10 às 18:00" */
+export function formatDayTime(iso: string | number | null | undefined) {
+  const t = toMs(iso);
+  if (t == null) return "—";
+  const d = new Date(t);
+  const day = d.toLocaleDateString("pt-BR", { weekday: "short", day: "2-digit", month: "2-digit" }).replace(".", "");
+  return `${day} às ${d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" })}`;
+}
+
+/* value of <input type="datetime-local">: local time, no time zone */
+export function toLocalInputValue(d: Date) {
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}T${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+export function formatBytes(bytes: number) {
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / 1024 / 1024).toLocaleString("pt-BR", { maximumFractionDigits: 1 })} MB`;
+}
+
+/* an approval countdown: "4:59" */
+export function formatCountdown(ms: number) {
+  const s = Math.max(0, Math.ceil(ms / 1000));
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+
+/* --- stages ---------------------------------------------------------------------- */
+/* first letter upper case: nothing the user reads starts in lower case */
+export const capitalize = (s: string) => (s ? s[0].toUpperCase() + s.slice(1) : s);
+
+export function stageLabel(s: StatusStage) {
+  return capitalize(s.detail ? `${s.name} (${s.detail})` : s.name);
+}
+
+/* --- queue ------------------------------------------------------------------------ */
+export const TOOL_LABEL: Record<string, string> = {
+  voice: "Voz",
+  captions: "Legenda",
+  render: "Render final",
+  /* old tickets only: the preview stage no longer exists */
+  preview: "Prévia",
+  sound: "Som",
+  assembly: "Montagem e exportação",
+  "premiere-assemble": "Montar no Premiere",
+  "premiere-check": "Conferir no Premiere",
+  "premiere-export": "Exportar do Premiere",
+};
+
+export function ticketOrigin(t: Ticket) {
+  if (t.origin === "chat") return t.session ? `Chat ${t.session.slice(0, 8)}` : "Chat";
+  return capitalize(t.origin);
+}

package/studio/web/lib/media.ts

@@ -0,0 +1,29 @@
+/* Files of a video or of a reference, as URLs the browser can load. */
+
+import type { FileEntry, VideoDetail } from "../types/api";
+
+export function findFile(video: VideoDetail, path: string | undefined | null): FileEntry | null {
+  if (!path) return null;
+  return video.files.find(f => f.path === path) ?? null;
+}
+
+/* the chosen thumbnail (thumbnail/thumbnail.png): the video's cover wherever it shows still */
+export function chosenCover(video: VideoDetail): FileEntry | null {
+  return video.thumbnail?.selected ? findFile(video, "thumbnail/thumbnail.png") : null;
+}
+
+/* the mtime in the URL makes the browser fetch again only what changed */
+export function mediaUrl(video: { slug: string }, file: FileEntry | null) {
+  if (!file) return null;
+  return `/media/${encodeURIComponent(video.slug)}/${file.path.split("/").map(encodeURIComponent).join("/")}?v=${file.mtime}`;
+}
+
+export function aspectRatio(video: { format: { w: number; h: number } | null }) {
+  return video.format ? `${video.format.w} / ${video.format.h}` : "9 / 16";
+}
+
+/* a file inside a reference dir */
+export const referenceFileUrl = (name: string, file: FileEntry | null) =>
+  file
+    ? `/ref/${encodeURIComponent(name)}/${file.path.split("/").map(encodeURIComponent).join("/")}?v=${file.mtime}`
+    : null;

package/studio/web/lib/mic-device.ts

@@ -0,0 +1,72 @@
+/* The microphone Omni listens with. "Padrão do sistema" (no id) is what the browser picks; any other
+   is a deviceId the user chose in the Omni panel, remembered in the browser. If that device is gone
+   (unplugged), opening it falls back to the default instead of failing. */
+
+const STORAGE_KEY = "omni-mic-device";
+/* Radix Select can't have an empty value, and "default" is a real id in Chrome */
+export const SYSTEM_MIC = "__system";
+/* the browser's own aliases for the default; the list shows ours instead */
+const ALIASES = new Set(["default", "communications"]);
+
+export type MicDevice = { id: string; label: string };
+
+export function micConstraints(deviceId: string | null | undefined): MediaStreamConstraints {
+  return {
+    audio: {
+      echoCancellation: true,
+      noiseSuppression: true,
+      autoGainControl: true,
+      channelCount: 1,
+      ...(deviceId && deviceId !== SYSTEM_MIC ? { deviceId: { exact: deviceId } } : {}),
+    },
+  };
+}
+
+/* opens the chosen microphone (by default the one saved in the browser; null = the system's); a device
+   that is not there any more opens the default one */
+export async function openMic(
+  deviceId: string | null | undefined = loadMicChoice(),
+  getUserMedia: (c: MediaStreamConstraints) => Promise<MediaStream> = c => navigator.mediaDevices.getUserMedia(c),
+): Promise<MediaStream> {
+  try {
+    return await getUserMedia(micConstraints(deviceId));
+  } catch (e) {
+    const gone = e instanceof DOMException && (e.name === "OverconstrainedError" || e.name === "NotFoundError");
+    if (!gone || !deviceId || deviceId === SYSTEM_MIC) throw e;
+    return getUserMedia(micConstraints(null));
+  }
+}
+
+/* the audio inputs, without the browser's aliases and without the ones that have no id yet (no permission:
+   a Select item can't have an empty value); one without a name is numbered */
+export function micDevices(all: Pick<MediaDeviceInfo, "kind" | "deviceId" | "label">[]): MicDevice[] {
+  return all
+    .filter(d => d.kind === "audioinput" && d.deviceId && !ALIASES.has(d.deviceId)) /* no permission: no ids */
+    .map((d, i) => ({ id: d.deviceId, label: d.label.trim() || `Microfone ${i + 1}` }));
+}
+
+/* the browser hides the names until it has had a microphone permission */
+export const needsPermission = (all: Pick<MediaDeviceInfo, "kind" | "label">[]) =>
+  all.some(d => d.kind === "audioinput" && !d.label);
+
+/* what was chosen, if it is still plugged in */
+export function stillThere(id: string | null, devices: MicDevice[]) {
+  return id && id !== SYSTEM_MIC && devices.some(d => d.id === id) ? id : SYSTEM_MIC;
+}
+
+export function loadMicChoice(): string | null {
+  try {
+    return localStorage.getItem(STORAGE_KEY);
+  } catch {
+    return null;
+  }
+}
+
+export function saveMicChoice(id: string) {
+  try {
+    if (id === SYSTEM_MIC) localStorage.removeItem(STORAGE_KEY);
+    else localStorage.setItem(STORAGE_KEY, id);
+  } catch {
+    /* private mode: the choice lasts until the page closes */
+  }
+}

package/studio/web/lib/missing-dms.ts

@@ -0,0 +1,70 @@
+/* Pure pieces of the "Sem DM" panel (components/MissingDmsPanel): the send modes, the comments
+   that ask, what is still missing before sending and the send button's label. */
+
+import type { MissingDmItem, ThreadComment } from "../types/api";
+
+export type SendMode = "both" | "dm" | "comment";
+export const SEND_MODES: { id: SendMode; name: string }[] = [
+  { id: "both", name: "DM e resposta" },
+  { id: "dm", name: "Só a DM" },
+  { id: "comment", name: "Só a resposta no comentário" },
+];
+
+/* the comments that ask for the DM and can still get what goes (the DM has a 7-day deadline) */
+export const askingItems = (items: MissingDmItem[] | undefined, commentOnly: boolean) =>
+  items?.filter(c => c.triggers && (commentOnly || c.within_deadline)) ?? [];
+
+/* what is still missing before the batch can go; null = ready */
+export function missingBeforeSend({
+  n,
+  commentOnly,
+  written,
+  noRule,
+}: {
+  n: number;
+  commentOnly: boolean;
+  written: string;
+  noRule: boolean;
+}): string | null {
+  return !n
+    ? commentOnly
+      ? "Marque quem recebe a resposta"
+      : "Marque quem recebe a DM"
+    : commentOnly && !written
+      ? "Escreva a resposta"
+      : !commentOnly && noRule
+        ? "Grave a regra antes"
+        : written.length > 2200
+          ? "Resposta longa demais"
+          : null;
+}
+
+/* the batch send's label: "Responder 2 comentários", "Mandar a DM"… */
+export const sendActionLabel = (commentOnly: boolean, n: number) =>
+  commentOnly
+    ? `Responder ${n === 1 ? "1 comentário" : `${n} comentários`}`
+    : `Mandar ${n === 1 ? "a DM" : `${n} DMs`}`;
+
+/* Responder on a card: where the reply goes. Instagram threads two levels, so a reply to a reply goes to
+   its top-level comment with the person's @ in front, the way the app does it. */
+export type ReplyTarget = { id: string; parentId: string; username: string | null; nested: boolean };
+
+export function replyTarget(thread: ThreadComment[] | undefined, id: string | null): ReplyTarget | null {
+  for (const c of thread ?? []) {
+    if (c.id === id) return { id: c.id, parentId: c.id, username: c.username, nested: false };
+    const r = c.replies.find(x => x.id === id);
+    if (r) return { id: r.id, parentId: c.id, username: r.username, nested: true };
+  }
+  return null;
+}
+
+/* the text that goes: a reply to a reply opens with the @ of whoever it answers */
+export const replyText = (t: ReplyTarget, written: string) =>
+  t.nested && t.username ? `@${t.username} ${written}` : written;
+
+/* the DM state of a card, for its badge */
+export const GATE_LABEL: Record<string, string> = {
+  awaiting_tap: "Esperando o toque",
+  awaiting_follow: "Esperando seguir",
+  delivered: "Link entregue",
+};

package/studio/web/lib/omni-cards.ts

@@ -0,0 +1,42 @@
+/* What Omni shows inside its own panel (the show_card UI tool): typed cards, never free HTML. The tool
+   pushes a card here; components/Omni/OmniCards renders it with the studio's own data hooks. Newest
+   first, a few at a time, cleared when the call ends. */
+
+import { useSyncExternalStore } from "react";
+
+export { CARD_KINDS, type CardKind } from "../../shared/omni-screens";
+import type { CardKind } from "../../shared/omni-screens";
+export type OmniCard = { id: string; kind: CardKind; slug?: string; name?: string; scene?: string };
+
+const MAX = 4;
+let cards: OmniCard[] = [];
+const listeners = new Set<() => void>();
+const emit = () => {
+  for (const l of listeners) l();
+};
+
+export function showCard(c: Omit<OmniCard, "id">): OmniCard {
+  const card = { ...c, id: crypto.randomUUID().slice(0, 8) };
+  /* the same card again moves to the front instead of repeating */
+  const same = (x: OmniCard) => x.kind === c.kind && x.slug === c.slug && x.name === c.name && x.scene === c.scene;
+  cards = [card, ...cards.filter(x => !same(x))].slice(0, MAX);
+  emit();
+  return card;
+}
+
+export function dismissCard(id: string) {
+  cards = cards.filter(c => c.id !== id);
+  emit();
+}
+
+export function clearCards() {
+  if (!cards.length) return;
+  cards = [];
+  emit();
+}
+
+const subscribe = (fn: () => void) => {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+};
+export const useOmniCards = () => useSyncExternalStore(subscribe, () => cards);