@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/dist/chunk-A4YJX7KT.js

@@ -0,0 +1,544 @@
+import { randomId, attachmentKindFor, ChatError } from './chunk-GBJ3YI4E.js';
+
+// src/core/thread.ts
+function mergeThread(server, pending) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of server) byId.set(m.id, m);
+  const sorted = [...byId.values()].sort((a, b) => a.seq - b.seq);
+  const landed = new Set(sorted.map((m) => m.clientId));
+  const waiting = pending.filter((p) => !landed.has(p.clientId)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return [
+    ...sorted.map((message) => ({ type: "message", message })),
+    ...waiting.map((p) => ({ type: "pending", pending: p }))
+  ];
+}
+function upsertMessages(existing, incoming) {
+  const byId = new Map(existing.map((m) => [m.id, m]));
+  for (const m of incoming) byId.set(m.id, m);
+  return [...byId.values()].sort((a, b) => a.seq - b.seq);
+}
+function itemSender(item) {
+  return item.type === "message" ? item.message.senderId : item.pending.senderId;
+}
+function itemTime(item) {
+  return item.type === "message" ? item.message.createdAt : item.pending.createdAt;
+}
+function startsGroup(items, index, gapMs = 5 * 6e4) {
+  if (index === 0) return true;
+  const prev = items[index - 1];
+  const cur = items[index];
+  if (cur.type === "message" && cur.message.kind === "system") return true;
+  if (prev.type === "message" && prev.message.kind === "system") return true;
+  if (itemSender(prev) !== itemSender(cur)) return true;
+  return Date.parse(itemTime(cur)) - Date.parse(itemTime(prev)) > gapMs || !sameDay(itemTime(prev), itemTime(cur));
+}
+function sameDay(a, b) {
+  const x = new Date(a);
+  const y = new Date(b);
+  return x.getFullYear() === y.getFullYear() && x.getMonth() === y.getMonth() && x.getDate() === y.getDate();
+}
+function startsDay(items, index) {
+  return index === 0 || !sameDay(itemTime(items[index - 1]), itemTime(items[index]));
+}
+function dayLabel(iso, now = /* @__PURE__ */ new Date(), locale) {
+  const d = new Date(iso);
+  const startOf = (x) => new Date(x.getFullYear(), x.getMonth(), x.getDate()).getTime();
+  const days = Math.round((startOf(now) - startOf(d)) / 864e5);
+  if (days === 0) return "Today";
+  if (days === 1) return "Yesterday";
+  if (days > 1 && days < 7) return d.toLocaleDateString(locale, { weekday: "long" });
+  return d.toLocaleDateString(locale, { day: "numeric", month: "short", year: d.getFullYear() === now.getFullYear() ? void 0 : "numeric" });
+}
+function firstUnreadId(messages, lastReadSeq, me) {
+  return messages.find((m) => m.seq > lastReadSeq && m.senderId !== me && !m.deletedAt)?.id ?? null;
+}
+function summarizeReactions(message, me) {
+  const order = [];
+  const by = /* @__PURE__ */ new Map();
+  for (const r of message.reactions) {
+    if (!by.has(r.emoji)) {
+      by.set(r.emoji, []);
+      order.push(r.emoji);
+    }
+    by.get(r.emoji).push(r.userId);
+  }
+  return order.map((emoji) => ({ emoji, count: by.get(emoji).length, mine: by.get(emoji).includes(me), userIds: by.get(emoji) })).sort((a, b) => b.count - a.count || order.indexOf(a.emoji) - order.indexOf(b.emoji));
+}
+function currentActivity(activity, now = Date.now(), staleMs = 6e3) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const a of activity) {
+    if (now - a.at > staleMs) continue;
+    const prev = latest.get(a.userId);
+    if (!prev || prev.at < a.at) latest.set(a.userId, a);
+  }
+  return [...latest.values()];
+}
+function activityLine(activity, nameOf) {
+  if (activity.length === 0) return null;
+  const recording = activity.find((a) => a.activity !== "typing");
+  if (recording) {
+    return `${nameOf(recording.userId)} is recording ${recording.activity === "recording-video" ? "a video" : "a voice message"}\u2026`;
+  }
+  const names = activity.map((a) => nameOf(a.userId));
+  if (names.length === 1) return `${names[0]} is typing\u2026`;
+  if (names.length === 2) return `${names[0]} and ${names[1]} are typing\u2026`;
+  return "Several people are typing\u2026";
+}
+function throttle(fn, everyMs = 3e3) {
+  let last = 0;
+  return () => {
+    const now = Date.now();
+    if (now - last >= everyMs) {
+      last = now;
+      fn();
+    }
+  };
+}
+function parseMentions(body) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const m of body.matchAll(/@\[[^\]]{1,80}\]\(user:([0-9a-f-]{36})\)/gi)) ids.add(m[1].toLowerCase());
+  return [...ids];
+}
+function previewText(body, attachment, deleted = false) {
+  if (deleted) return "Message deleted";
+  const text = body.replace(/@\[([^\]]+)\]\(user:[0-9a-f-]{36}\)/gi, "@$1").replace(/[*_`#>~]/g, "").trim();
+  if (text) return text.length > 140 ? `${text.slice(0, 139)}\u2026` : text;
+  switch (attachment) {
+    case "image":
+      return "Photo";
+    case "voice":
+      return "Voice message";
+    case "video":
+      return "Video";
+    case "file":
+      return "File";
+    case null:
+    case void 0:
+      return "";
+    default:
+      return "Attachment";
+  }
+}
+
+// src/core/outbox.ts
+function describe(f) {
+  return {
+    name: f.name,
+    contentType: f.contentType,
+    kind: f.meta?.kind ?? attachmentKindFor(f.contentType),
+    meta: f.meta,
+    ...f.hosted ? { hosted: true } : {}
+  };
+}
+var memoryOutboxStore = () => {
+  let saved = [];
+  return { load: async () => saved, save: async (q) => void (saved = q) };
+};
+function releaseObjectUrl(url) {
+  if (!url.startsWith("blob:") || typeof URL === "undefined" || typeof URL.revokeObjectURL !== "function") return;
+  try {
+    URL.revokeObjectURL(url);
+  } catch {
+  }
+}
+function createOutbox(opts) {
+  const store = opts.store ?? memoryOutboxStore();
+  let queue = [];
+  let generation = 0;
+  const running = /* @__PURE__ */ new Map();
+  const aborts = /* @__PURE__ */ new Map();
+  const uploaded = /* @__PURE__ */ new Map();
+  const transfers = /* @__PURE__ */ new Map();
+  const hostedAborts = /* @__PURE__ */ new Map();
+  const release = opts.releasePreview ?? releaseObjectUrl;
+  const releasePreviews = (q) => {
+    for (const url of /* @__PURE__ */ new Set([...Object.values(q.previews ?? {}), ...q.files.map((f) => f.previewUrl)])) {
+      if (typeof url === "string" && url) release(url);
+    }
+  };
+  const newId = opts.newId ?? randomId;
+  const saveable = (q) => {
+    const slots = q.pendingFiles?.length ? q.pendingFiles : q.files.map(describe);
+    const here = [...q.files];
+    const files = [];
+    const pendingFiles = slots.map((slot) => {
+      if (slot.lost) return slot;
+      const f = here.shift();
+      if (f && typeof f.data === "string") {
+        files.push(f);
+        return { ...slot, lost: false };
+      }
+      return { ...slot, lost: true };
+    });
+    return { ...q, files, pendingFiles };
+  };
+  const emit = () => {
+    opts.onChange?.([...queue]);
+    void store.save(queue.map(saveable));
+  };
+  const setProgress = (q, index, sent, total) => {
+    const slots = q.pendingFiles;
+    if (!slots?.[index] || !queue.includes(q)) return;
+    const progress = total > 0 ? Math.round(Math.min(1, Math.max(0, sent / total)) * 100) / 100 : 0;
+    if (slots[index].progress === progress) return;
+    q.pendingFiles = slots.map((slot, j) => j === index ? { ...slot, progress } : slot);
+    opts.onChange?.([...queue]);
+  };
+  const stopHosted = (clientId) => {
+    hostedAborts.get(clientId)?.abort();
+    hostedAborts.delete(clientId);
+    for (const k of [...transfers.keys()]) if (k.startsWith(`${clientId}:`)) transfers.delete(k);
+  };
+  async function persist(q) {
+    if (!opts.persistFile) return;
+    for (let i = 0; i < q.files.length; i++) {
+      const f = q.files[i];
+      if (typeof f.data === "string") continue;
+      try {
+        q.files[i] = { ...f, data: await opts.persistFile(f) };
+      } catch {
+      }
+    }
+  }
+  let loading = null;
+  function ensureLoaded() {
+    loading ??= (async () => {
+      const gen = generation;
+      let saved = [];
+      try {
+        saved = await store.load() ?? [];
+      } catch {
+        saved = [];
+      }
+      if (gen !== generation) return;
+      const live = new Set(queue.map((q) => q.clientId));
+      const restored = saved.filter((q) => !live.has(q.clientId)).map((q) => {
+        const lost = (q.pendingFiles ?? []).filter((f) => f.lost).length;
+        const rest = { ...q };
+        delete rest.sentMessageId;
+        return {
+          ...rest,
+          status: q.status === "sending" || lost > 0 ? "failed" : q.status,
+          error: lost > 0 ? "Attach the file again to send" : q.error ?? "Not sent",
+          files: q.files ?? [],
+          attempts: q.attempts ?? 0,
+          lostFiles: lost
+        };
+      });
+      if (restored.length) {
+        queue = [...restored, ...queue];
+        opts.onChange?.([...queue]);
+      }
+    })();
+    return loading;
+  }
+  async function uploadFile(conversationId, file, signal, onProgress) {
+    if (opts.upload) return opts.upload(conversationId, file, { signal, onProgress });
+    const data = typeof file.data === "string" ? await (opts.readFile ?? notReadable)(file.data) : file.data;
+    return opts.client.upload(conversationId, opts.userId, data, { name: file.name, contentType: file.contentType, onProgress, signal });
+  }
+  const isHosted = (f) => Boolean(f.hosted && opts.hostedUpload);
+  async function startHosted(q, index, file) {
+    const key = `${q.clientId}:${index}`;
+    const known = q.hosted?.[index];
+    if (known && (known.uploaded || transfers.has(key))) return known;
+    let controller = hostedAborts.get(q.clientId);
+    if (!controller && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      hostedAborts.set(q.clientId, controller);
+    }
+    const started = await opts.hostedUpload(q.input.conversationId, file, {
+      signal: controller?.signal,
+      onProgress: (sent, total) => setProgress(q, index, sent, total),
+      ...known ? { resume: known } : {}
+    });
+    const record = { provider: started.provider, providerId: started.providerId, ...started.url ? { url: started.url } : {} };
+    q.hosted = { ...q.hosted, [index]: record };
+    if (queue.includes(q)) emit();
+    const transfer = Promise.resolve(started.done).then(
+      () => {
+        record.uploaded = true;
+        if (transfers.get(key) === transfer) transfers.delete(key);
+        setProgress(q, index, 1, 1);
+      },
+      (e) => {
+        if (transfers.get(key) === transfer) transfers.delete(key);
+        throw e;
+      }
+    );
+    transfer.catch(() => void 0);
+    transfers.set(key, transfer);
+    return record;
+  }
+  async function settleHosted(q, gen) {
+    const waiting = Object.entries(q.hosted ?? {}).filter(([, r]) => !r.uploaded).map(([i]) => transfers.get(`${q.clientId}:${i}`) ?? Promise.reject(new ChatError("The upload stopped", void 0, "upload")));
+    try {
+      await Promise.all(waiting);
+    } catch (e) {
+      if (gen !== generation || !queue.includes(q) || q.status !== "sending") return;
+      q.attempts += 1;
+      q.status = "failed";
+      q.error = e instanceof ChatError && e.code === "GSABORT" ? "The upload was cancelled" : "The video didn't finish uploading";
+      emit();
+      return;
+    }
+    if (gen !== generation || !queue.includes(q)) return;
+    if (Object.values(q.hosted ?? {}).some((r) => !r.uploaded)) return void settleHosted(q, gen);
+    queue = queue.filter((x) => x !== q);
+    hostedAborts.delete(q.clientId);
+    emit();
+    releasePreviews(q);
+  }
+  async function run(conversationId) {
+    const gen = generation;
+    if (running.get(conversationId) === gen) return;
+    running.set(conversationId, gen);
+    const stale = (q) => gen !== generation || !queue.includes(q);
+    try {
+      for (; ; ) {
+        if (gen !== generation) return;
+        const next = queue.find((q) => q.input.conversationId === conversationId && !q.sentMessageId);
+        if (!next || next.status !== "sending") break;
+        if ((next.lostFiles ?? 0) > 0) {
+          next.status = "failed";
+          next.error = "Attach the file again to send";
+          emit();
+          break;
+        }
+        const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+        if (controller) aborts.set(next.clientId, controller);
+        try {
+          const attachments = [...next.input.attachments ?? []];
+          for (let i = 0; i < next.files.length; i++) {
+            const file = next.files[i];
+            if (isHosted(file)) {
+              const hosted = await startHosted(next, i, file);
+              if (stale(next)) return;
+              attachments.push({
+                ...file.meta,
+                kind: file.meta?.kind ?? attachmentKindFor(file.contentType),
+                provider: hosted.provider,
+                providerId: hosted.providerId,
+                status: "pending",
+                name: file.meta?.name ?? file.name,
+                mime: file.contentType
+              });
+              continue;
+            }
+            const key = `${next.clientId}:${i}`;
+            let path = uploaded.get(key);
+            if (!path) {
+              const index = i;
+              path = await uploadFile(conversationId, file, controller?.signal, (sent, total) => setProgress(next, index, sent, total));
+              if (stale(next)) return;
+              uploaded.set(key, path);
+            }
+            attachments.push({
+              ...file.meta,
+              kind: file.meta?.kind ?? attachmentKindFor(file.contentType),
+              path,
+              name: file.meta?.name ?? file.name,
+              mime: file.contentType
+            });
+          }
+          if (stale(next)) return;
+          const message = await opts.client.send({ ...next.input, attachments });
+          if (gen !== generation) return;
+          for (let i = 0; i < next.files.length; i++) uploaded.delete(`${next.clientId}:${i}`);
+          if (Object.values(next.hosted ?? {}).some((r) => !r.uploaded)) {
+            next.sentMessageId = message.id;
+            emit();
+            opts.onSent?.(message, next.clientId);
+            void settleHosted(next, gen);
+            continue;
+          }
+          queue = queue.filter((q) => q.clientId !== next.clientId);
+          hostedAborts.delete(next.clientId);
+          emit();
+          opts.onSent?.(message, next.clientId);
+          releasePreviews(next);
+        } catch (e) {
+          if (stale(next)) return;
+          const err = e instanceof ChatError ? e : new ChatError(e instanceof Error ? e.message : String(e), void 0, "send");
+          next.attempts += 1;
+          next.status = "failed";
+          next.permanent = err.permanent;
+          next.error = err.forbidden ? "You can't post here" : err.transient ? "Not sent. Check your connection." : err.message;
+          emit();
+          break;
+        } finally {
+          if (controller && aborts.get(next.clientId) === controller) aborts.delete(next.clientId);
+        }
+      }
+    } finally {
+      if (running.get(conversationId) === gen) running.delete(conversationId);
+    }
+  }
+  const canAutoRetry = (x) => !x.permanent && !(x.lostFiles ?? 0) && x.files.every((f) => typeof f.data !== "string" || Boolean(isHosted(f) ? opts.hostedUpload : opts.readFile || opts.upload));
+  const requeue = (x) => {
+    x.status = "sending";
+    delete x.sentMessageId;
+  };
+  return {
+    /** Queues a message; it shows at once and sends in order. Returns its clientId. */
+    async send(input, files = []) {
+      await ensureLoaded();
+      const gen = generation;
+      const clientId = input.clientId ?? newId();
+      const previews = {};
+      files.forEach((f, i) => {
+        if (f.previewUrl) previews[i] = f.previewUrl;
+      });
+      const queued = {
+        clientId,
+        input: { ...input, clientId },
+        senderId: opts.userId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "sending",
+        previews,
+        files: [...files],
+        pendingFiles: files.map(describe),
+        attempts: 0
+      };
+      queue.push(queued);
+      opts.onChange?.([...queue]);
+      await persist(queued);
+      if (gen !== generation || !queue.includes(queued)) return clientId;
+      emit();
+      void run(input.conversationId);
+      return clientId;
+    },
+    async retry(clientId) {
+      await ensureLoaded();
+      const q = queue.find((x) => x.clientId === clientId);
+      if (!q) return;
+      for (const x of queue) {
+        if (x.input.conversationId !== q.input.conversationId || x.status !== "failed") continue;
+        if ((x.lostFiles ?? 0) > 0) break;
+        requeue(x);
+        x.permanent = false;
+      }
+      emit();
+      void run(q.input.conversationId);
+    },
+    /**
+     * Gives a message the files it lost on a relaunch and sends it. `files` fill the lost
+     * slots in order (`PendingMessage.files[i].lost`); the files that were kept stay. Pass
+     * one per lost slot; with fewer, the message keeps waiting for the rest.
+     */
+    async reattach(clientId, files) {
+      await ensureLoaded();
+      const q = queue.find((x) => x.clientId === clientId);
+      if (!q) return;
+      const slots = q.pendingFiles ?? [];
+      const kept = [...q.files];
+      const given = [...files];
+      const merged = [];
+      const described = [];
+      for (const slot of slots) {
+        if (slot.lost) {
+          const f = given.shift();
+          if (f) {
+            merged.push(f);
+            described.push(describe(f));
+          } else {
+            described.push(slot);
+          }
+        } else {
+          const f = kept.shift();
+          if (f) {
+            merged.push(f);
+            described.push(slot);
+          }
+        }
+      }
+      if (slots.length === 0) {
+        merged.push(...given);
+        described.push(...given.map(describe));
+      }
+      q.files = merged;
+      q.pendingFiles = described;
+      q.lostFiles = described.filter((d) => d.lost).length;
+      if (q.lostFiles > 0) {
+        emit();
+        return;
+      }
+      const gen = generation;
+      await persist(q);
+      if (gen !== generation || !queue.includes(q)) return;
+      requeue(q);
+      emit();
+      void run(q.input.conversationId);
+    },
+    /**
+     * Retries failed messages (after the connection comes back), in order per conversation,
+     * stopping at the first that can't go on its own: one waiting for a lost file, or one the
+     * server refused (`permanent`, retried only by hand). The ones after it keep waiting.
+     */
+    async retryAll() {
+      await ensureLoaded();
+      const conversations = /* @__PURE__ */ new Set();
+      const held = /* @__PURE__ */ new Set();
+      for (const x of queue) {
+        const c = x.input.conversationId;
+        if (held.has(c) || x.status !== "failed") continue;
+        if (!canAutoRetry(x)) {
+          if (!x.sentMessageId) held.add(c);
+          continue;
+        }
+        requeue(x);
+        conversations.add(c);
+      }
+      emit();
+      for (const c of conversations) void run(c);
+    },
+    /** Forgets every queued message, here and in the store (call it on sign-out). */
+    async clear() {
+      generation += 1;
+      for (const c of aborts.values()) c.abort();
+      aborts.clear();
+      for (const c of hostedAborts.values()) c.abort();
+      hostedAborts.clear();
+      transfers.clear();
+      running.clear();
+      const gone = queue;
+      queue = [];
+      uploaded.clear();
+      gone.forEach(releasePreviews);
+      opts.onChange?.([]);
+      await ensureLoaded();
+      await store.save([]);
+    },
+    async discard(clientId) {
+      await ensureLoaded();
+      const gone = queue.find((q) => q.clientId === clientId);
+      queue = queue.filter((q) => q.clientId !== clientId);
+      aborts.get(clientId)?.abort();
+      aborts.delete(clientId);
+      stopHosted(clientId);
+      if (gone) releasePreviews(gone);
+      emit();
+    },
+    /**
+     * Uploads one file to storage the way the outbox does (the `upload` hook, or `readFile` then
+     * the client's upload) and resolves with its path: for files sent outside the queue, such as
+     * a scheduled message's.
+     */
+    uploadFile(conversationId, file, o = {}) {
+      return uploadFile(conversationId, file, o.signal, o.onProgress);
+    },
+    pending(conversationId) {
+      return queue.filter((q) => !conversationId || q.input.conversationId === conversationId).map((q) => ({ ...q, files: q.pendingFiles }));
+    },
+    /** A new client id, made the way this outbox makes them. */
+    newId,
+    load: ensureLoaded
+  };
+}
+async function notReadable() {
+  throw new ChatError("This file can't be read on this device", "GSFILE", "upload");
+}
+
+export { activityLine, createOutbox, currentActivity, dayLabel, firstUnreadId, itemSender, itemTime, memoryOutboxStore, mergeThread, parseMentions, previewText, releaseObjectUrl, sameDay, startsDay, startsGroup, summarizeReactions, throttle, upsertMessages };
+//# sourceMappingURL=chunk-A4YJX7KT.js.map
+//# sourceMappingURL=chunk-A4YJX7KT.js.map