@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/src/core/extras.ts

@@ -0,0 +1,106 @@
+/**
+ * @feat:chat
+ * Small pure helpers for migration 0002's features, shared by every platform: the links a
+ * message's text carries (the same rule the database uses to queue previews), https checks
+ * for preview images, search snippets split at their « » marks, scheduling quick picks, and
+ * topic keys.
+ */
+
+/** A query that looks like a credential (a reset token, a signed URL): never previewed. Mirrors genesis_chat.message_links. */
+const CREDENTIAL = /[?&#;](access_token|id_token|refresh_token|token|auth|code|key|api_key|apikey|sig|signature|x-amz-signature|x-amz-credential|x-goog-signature|x-goog-credential|otp|secret|password|session|sessionid)=/i;
+
+/** The https links in a message's text that get a preview, at most three, as genesis_chat.message_links finds them. */
+export function extractLinks(body: string, max = 3): string[] {
+  const out: string[] = [];
+  for (const m of body.matchAll(/(https:\/\/[^\s<>()"']{4,})/g)) {
+    const url = m[1]!;
+    if (url.length <= 2000 && !CREDENTIAL.test(url) && !out.includes(url)) out.push(url);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+
+/** An absolute https URL with a host: the only kind a preview image may load from. */
+export function isHttpsUrl(url: string | null | undefined): url is string {
+  if (!url) return false;
+  try {
+    const u = new URL(url);
+    return u.protocol === "https:" && Boolean(u.hostname);
+  } catch {
+    return false;
+  }
+}
+
+export interface SnippetPart {
+  text: string;
+  match: boolean;
+}
+
+/** "a «word» here" → [{a }, {word, match}, { here}]. Unbalanced marks are kept as text. */
+export function snippetParts(snippet: string): SnippetPart[] {
+  const parts: SnippetPart[] = [];
+  let rest = snippet;
+  for (;;) {
+    const open = rest.indexOf("«");
+    const close = open >= 0 ? rest.indexOf("»", open + 1) : -1;
+    if (open < 0 || close < 0) break;
+    if (open > 0) parts.push({ text: rest.slice(0, open), match: false });
+    parts.push({ text: rest.slice(open + 1, close), match: true });
+    rest = rest.slice(close + 1);
+  }
+  if (rest) parts.push({ text: rest, match: false });
+  return parts;
+}
+
+export interface QuickPick {
+  label: string;
+  at: Date;
+}
+
+/** At 09:00 local on the day `days` after `from`. */
+function nineAm(from: Date, days: number): Date {
+  const d = new Date(from.getFullYear(), from.getMonth(), from.getDate() + days, 9, 0, 0, 0);
+  return d;
+}
+
+/** "Tomorrow, 9:00 AM" and "Monday, 9:00 AM" (the next Monday after tomorrow; one pick when they're the same day). */
+export function scheduleQuickPicks(now: Date = new Date(), locale?: string): QuickPick[] {
+  const time = (d: Date) => d.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" });
+  const tomorrow = nineAm(now, 1);
+  const picks: QuickPick[] = [{ label: `Tomorrow, ${time(tomorrow)}`, at: tomorrow }];
+  const toMonday = ((8 - now.getDay()) % 7) || 7;
+  const monday = nineAm(now, toMonday);
+  if (monday.getTime() !== tomorrow.getTime()) {
+    picks.push({ label: `${monday.toLocaleDateString(locale, { weekday: "long" })}, ${time(monday)}`, at: monday });
+  }
+  return picks;
+}
+
+/** When a scheduled message goes: "Tomorrow, 9:00 AM", "Mon 12 Oct, 9:00 AM". */
+export function scheduleLabel(iso: string | Date, now: Date = new Date(), locale?: string): string {
+  const d = typeof iso === "string" ? new Date(iso) : iso;
+  const time = d.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" });
+  const start = (x: Date) => new Date(x.getFullYear(), x.getMonth(), x.getDate()).getTime();
+  const days = Math.round((start(d) - start(now)) / 86_400_000);
+  if (days === 0) return `Today, ${time}`;
+  if (days === 1) return `Tomorrow, ${time}`;
+  return `${d.toLocaleDateString(locale, { weekday: "short", day: "numeric", month: "short" })}, ${time}`;
+}
+
+/** The send time the database accepts: at least a minute and at most a year ahead. */
+export function isSchedulable(at: Date, now: Date = new Date()): boolean {
+  const t = at.getTime();
+  return Number.isFinite(t) && t >= now.getTime() + 60_000 && t <= now.getTime() + 365 * 86_400_000;
+}
+
+/** A topic's key from its title: "Week 1: Habits" → "week-1-habits" (at most 120 characters). */
+export function topicKey(title: string): string {
+  const key = title
+    .normalize("NFKD")
+    .replace(/[̀-ͯ]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 120);
+  return key || title.trim().slice(0, 120);
+}

package/src/core/media.ts

@@ -0,0 +1,144 @@
+/**
+ * @feat:chat
+ * Media rules shared by every platform: which files may be sent (the same list
+ * migration 0001 checks), what kind an upload becomes, the default limits, and
+ * the waveform a voice note carries so its bubble draws before the audio loads.
+ */
+import type { AttachmentKind } from "./types";
+
+/**
+ * A random UUID (v4): `crypto.randomUUID` where the platform has it (some React Native
+ * runtimes don't), else `crypto.getRandomValues`, else Math.random as a last resort. Ids
+ * only need to be unique per sender: the server checks (sender, client_id).
+ */
+export function randomId(): string {
+  const c = (globalThis as { crypto?: { randomUUID?: () => string; getRandomValues?: (a: Uint8Array) => Uint8Array } }).crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (c?.getRandomValues) c.getRandomValues(b);
+  else for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+  b[6] = (b[6]! & 0x0f) | 0x40;
+  b[8] = (b[8]! & 0x3f) | 0x80;
+  const h = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+
+/** Mirrors genesis_chat.allowed_extension. Never SVG or HTML, which a browser runs as a page. */
+export const ALLOWED_EXTENSIONS = [
+  "png", "jpg", "jpeg", "webp", "gif", "heic", "heif",
+  "m4a", "aac", "mp3", "ogg", "oga", "opus", "weba", "webm",
+  "mp4", "mov", "pdf", "txt", "csv", "docx", "xlsx", "pptx",
+] as const;
+
+const MIME_EXTENSIONS: Record<string, string> = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "audio/mp4": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/aac": "aac",
+  "audio/mpeg": "mp3",
+  "audio/ogg": "ogg",
+  "audio/webm": "webm",
+  "video/mp4": "mp4",
+  "video/quicktime": "mov",
+  "video/webm": "webm",
+  "application/pdf": "pdf",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+};
+
+/** The extension a file is stored under: from its content type, else its name. */
+export function fileExtension(name: string, contentType?: string): string {
+  const base = (contentType ?? "").split(";")[0]!.trim().toLowerCase();
+  const fromType = MIME_EXTENSIONS[base];
+  if (fromType) return fromType;
+  const dot = name.lastIndexOf(".");
+  return dot >= 0 ? name.slice(dot + 1).toLowerCase() : "";
+}
+
+export function isAllowedExtension(ext: string): boolean {
+  return (ALLOWED_EXTENSIONS as readonly string[]).includes(ext.toLowerCase());
+}
+
+/** What an upload becomes in a message. */
+export function attachmentKindFor(contentType: string, opts: { recordedVoice?: boolean } = {}): AttachmentKind {
+  const t = contentType.toLowerCase();
+  if (opts.recordedVoice || t.startsWith("audio/")) return "voice";
+  if (t.startsWith("image/")) return "image";
+  if (t.startsWith("video/")) return "video";
+  return "file";
+}
+
+/** Default limits (decision 5): an app may lower them, not raise them past the bucket's 100 MB. */
+export const CHAT_LIMITS = {
+  /** Voice notes and videos, for members. */
+  recordingMs: 5 * 60_000,
+  /** For owners, admins and observers (coaches, staff). */
+  staffRecordingMs: 10 * 60_000,
+  fileBytes: 50 * 1024 * 1024,
+  videoBytes: 100 * 1024 * 1024,
+  attachmentsPerMessage: 20,
+  bodyChars: 10_000,
+} as const;
+
+/** The longest recording this role may make. */
+export function recordingLimitMs(role: string | null | undefined): number {
+  return role === "owner" || role === "admin" || role === "observer" ? CHAT_LIMITS.staffRecordingMs : CHAT_LIMITS.recordingMs;
+}
+
+/**
+ * Peaks for a waveform: `count` values 0–100 from raw samples (-1…1), the loudest
+ * in each bucket, scaled so the loudest bucket is 100. Quiet recordings still show
+ * a shape; silence shows a flat line.
+ */
+export function waveformPeaks(samples: ArrayLike<number>, count = 48): number[] {
+  const n = Math.max(1, Math.min(128, Math.floor(count)));
+  if (samples.length === 0) return new Array(n).fill(0);
+  const size = samples.length / n;
+  const raw: number[] = [];
+  for (let i = 0; i < n; i++) {
+    let peak = 0;
+    const end = Math.min(samples.length, Math.floor((i + 1) * size));
+    for (let j = Math.floor(i * size); j < end; j++) {
+      const v = Math.abs(samples[j]!);
+      if (v > peak) peak = v;
+    }
+    raw.push(peak);
+  }
+  const max = Math.max(...raw);
+  if (max < 0.01) return raw.map(() => 0);
+  return raw.map((v) => Math.round((v / max) * 100));
+}
+
+/**
+ * Peaks from a level meter read while recording (expo-audio's `metering`, in dB,
+ * about -160…0): resampled to `count` values 0–100.
+ */
+export function waveformFromMetering(levelsDb: number[], count = 48): number[] {
+  const linear = levelsDb.map((db) => (Number.isFinite(db) ? Math.pow(10, Math.max(-60, Math.min(0, db)) / 20) : 0));
+  return waveformPeaks(linear, count);
+}
+
+/** 0:42, 1:05:09. */
+export function formatDuration(ms: number | null | undefined): string {
+  const total = Math.max(0, Math.round((ms ?? 0) / 1000));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor((total % 3600) / 60);
+  const s = total % 60;
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` : `${m}:${String(s).padStart(2, "0")}`;
+}
+
+/** Playback speeds offered for voice and video (free for everyone, decision 5). */
+export const PLAYBACK_RATES = [1, 1.5, 2] as const;
+
+export function nextPlaybackRate(rate: number): number {
+  const i = PLAYBACK_RATES.indexOf(rate as (typeof PLAYBACK_RATES)[number]);
+  return PLAYBACK_RATES[(i + 1) % PLAYBACK_RATES.length]!;
+}