@marktiderman/genesis-chat 0.1.0 → 0.2.0

package/dist/{chunk-JQXZUEEL.js → chunk-7S6HYNWW.js}

@@ -1,3 +1,161 @@
+// src/core/availability.ts
+var WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+var SHORT = { mon: "Mon", tue: "Tue", wed: "Wed", thu: "Thu", fri: "Fri", sat: "Sat", sun: "Sun" };
+function minutesOf(hhmm) {
+  if (typeof hhmm !== "string") return null;
+  const m = /^(\d{1,2}):(\d{2})$/.exec(hhmm.trim());
+  if (!m) return null;
+  const h = Number(m[1]);
+  const min = Number(m[2]);
+  if (h > 24 || min > 59 || h === 24 && min > 0) return null;
+  return h * 60 + min;
+}
+var MAX_RANGES_PER_DAY = 4;
+function normalizeHours(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const src = raw;
+  const out = {};
+  let any = false;
+  for (const day of WEEKDAYS) {
+    if (!Object.prototype.hasOwnProperty.call(src, day)) continue;
+    const ranges = src[day];
+    if (!Array.isArray(ranges)) continue;
+    const kept = [];
+    for (const r of ranges) {
+      if (!Array.isArray(r) || r.length !== 2) continue;
+      const [from, to] = r;
+      if (typeof from !== "string" || typeof to !== "string" || minutesOf(from) == null || minutesOf(to) == null) continue;
+      kept.push([from, to]);
+      if (kept.length >= MAX_RANGES_PER_DAY) break;
+    }
+    if (kept.length) {
+      out[day] = kept;
+      any = true;
+    }
+  }
+  return any ? out : null;
+}
+function localClock(now, timeZone) {
+  let parts;
+  try {
+    parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timeZone || void 0,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(now);
+  } catch {
+    parts = new Intl.DateTimeFormat("en-US", { weekday: "short", hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(now);
+  }
+  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+  const day = get("weekday").slice(0, 3).toLowerCase();
+  const hour = Number(get("hour")) % 24;
+  return { day: WEEKDAYS.includes(day) ? day : "mon", minutes: hour * 60 + Number(get("minute")) };
+}
+function isWithinWorkingHours(raw, timeZone, now = /* @__PURE__ */ new Date()) {
+  const hours = normalizeHours(raw);
+  if (!hours) return true;
+  const { day, minutes } = localClock(now, timeZone);
+  const yesterday = WEEKDAYS[(WEEKDAYS.indexOf(day) + 6) % 7];
+  for (const [from, to] of hours[day] ?? []) {
+    const a = minutesOf(from);
+    const b = minutesOf(to);
+    if (a == null || b == null) continue;
+    if (b > a ? minutes >= a && minutes < b : minutes >= a) return true;
+  }
+  for (const [from, to] of hours[yesterday] ?? []) {
+    const a = minutesOf(from);
+    const b = minutesOf(to);
+    if (a == null || b == null) continue;
+    if (b <= a && minutes < b) return true;
+  }
+  return false;
+}
+function isAway(a, now = /* @__PURE__ */ new Date()) {
+  if (!a) return false;
+  if (a.awayUntil) return Date.parse(a.awayUntil) > now.getTime();
+  return Boolean(a.awayMessage?.trim());
+}
+function clock(hhmm) {
+  const total = minutesOf(hhmm) ?? 0;
+  const h = Math.floor(total / 60) % 24;
+  const m = total % 60;
+  const h12 = h % 12 === 0 ? 12 : h % 12;
+  return m ? `${h12}:${String(m).padStart(2, "0")}` : String(h12);
+}
+function hoursSummary(raw) {
+  const hours = normalizeHours(raw);
+  if (!hours) return "";
+  const key = (d) => (hours[d] ?? []).map(([a, b]) => `${clock(a)}\u2013${clock(b)}`).join(", ");
+  const runs = [];
+  for (const d of WEEKDAYS) {
+    const text = key(d);
+    if (!text) continue;
+    const last = runs[runs.length - 1];
+    if (last && last.text === text && WEEKDAYS.indexOf(last.to) === WEEKDAYS.indexOf(d) - 1) last.to = d;
+    else runs.push({ from: d, to: d, text });
+  }
+  return runs.map((r) => {
+    const days = r.from === r.to ? SHORT[r.from] : WEEKDAYS.indexOf(r.to) - WEEKDAYS.indexOf(r.from) === 1 ? `${SHORT[r.from]}, ${SHORT[r.to]}` : `${SHORT[r.from]}\u2013${SHORT[r.to]}`;
+    return `${days}, ${r.text}`;
+  }).join("; ");
+}
+function timeZoneLabel(timeZone, locale = "en-US") {
+  if (!timeZone) return "";
+  try {
+    const name = new Intl.DateTimeFormat(locale, { timeZone, timeZoneName: "longGeneric" }).formatToParts(/* @__PURE__ */ new Date()).find((p) => p.type === "timeZoneName")?.value;
+    if (name && !/^GMT|^UTC/.test(name)) return name.replace(/ Time$/, "");
+  } catch {
+  }
+  return (timeZone.split("/").pop() ?? timeZone).replace(/_/g, " ");
+}
+function untilLabel(iso, now = /* @__PURE__ */ new Date(), locale, timeZone) {
+  const d = new Date(iso);
+  if (!Number.isFinite(d.getTime())) return "later";
+  try {
+    return untilIn(d, now, locale, timeZone || void 0);
+  } catch {
+    return untilIn(d, now, void 0, void 0);
+  }
+}
+function untilIn(d, now, locale, tz) {
+  const dayKey = (x) => new Intl.DateTimeFormat("en-CA", { timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit" }).format(x);
+  if (dayKey(d) === dayKey(now)) return d.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit", timeZone: tz });
+  const days = (d.getTime() - now.getTime()) / 864e5;
+  if (days < 7) return d.toLocaleDateString(locale, { weekday: "long", timeZone: tz });
+  return d.toLocaleDateString(locale, { day: "numeric", month: "short", timeZone: tz });
+}
+function awayLine(a, name, opts = {}) {
+  if (!a) return null;
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const message = a.awayMessage?.trim();
+  if (isAway(a, now)) {
+    if (a.awayUntil) return `Away until ${untilLabel(a.awayUntil, now, opts.locale, a.timeZone)}${message ? `: ${message}` : ""}`;
+    return `${name} is away${message ? `: ${message}` : ""}`;
+  }
+  const summary = hoursSummary(a.hours);
+  if (!summary) return null;
+  if (!opts.always && isWithinWorkingHours(a.hours, a.timeZone, now)) return null;
+  const zone = timeZoneLabel(a.timeZone, opts.locale);
+  return `${name} replies ${summary}${zone ? ` (${zone})` : ""}`;
+}
+function namesLine(names) {
+  if (names.length <= 1) return names[0] ?? "";
+  if (names.length === 2) return `${names[0]} and ${names[1]}`;
+  const rest = names.length - 2;
+  return `${names[0]}, ${names[1]} and ${rest === 1 ? "1 other" : `${rest} others`}`;
+}
+function awaySummary(people, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const out = people.filter((p) => awayLine(p.availability, p.name, { ...opts, now, always: false }) !== null);
+  if (out.length === 0) return null;
+  if (out.length === 1) return awayLine(out[0].availability, out[0].name, { ...opts, now, always: false });
+  const away = out.filter((p) => isAway(p.availability, now)).length;
+  const what = away === out.length ? "away" : away === 0 ? "outside their hours" : "away or outside their hours";
+  return `${namesLine(out.map((p) => p.name))} are ${what}`;
+}
+
 // src/core/media.ts
 function randomId() {
   const c = globalThis.crypto;
@@ -147,6 +305,14 @@ var ChatError = class extends Error {
   get transient() {
     return this.code === void 0 || this.code === "" || /^(08|57|53)/.test(this.code) || this.code === "PGRST000";
   }
+  /**
+   * Sending it again won't help: the database refused what was sent (not allowed 42501, bad
+   * data 22xxx such as 22023, a conflict 23xxx such as 23505, another refusal 42xxx, or a
+   * function's own `raise` P0001). A person may still retry by hand; nothing retries it alone.
+   */
+  get permanent() {
+    return !this.transient && !this.rateLimited && /^(22|23|42|P0)/.test(this.code ?? "");
+  }
 };
 function must(operation, result) {
   if (result.error) throw new ChatError(result.error.message, result.error.code, operation);
@@ -204,6 +370,7 @@ function toMessage(r) {
     createdAt: String(r.created_at),
     editedAt: str(r.edited_at),
     deletedAt: str(r.deleted_at),
+    moderation: r.moderation === "hidden" || r.moderation === "flagged" ? r.moderation : null,
     attachments,
     reactions
   };
@@ -256,6 +423,94 @@ function toInboxItem(r) {
     } : null
   };
 }
+function toTopic(r) {
+  return {
+    conversationId: String(r.conversation_id),
+    topic: String(r.topic),
+    title: String(r.title ?? r.topic),
+    position: Number(r.position ?? 0),
+    closedAt: str(r.closed_at),
+    createdBy: str(r.created_by),
+    createdAt: String(r.created_at)
+  };
+}
+function fromAttachmentArg(a) {
+  const out = { kind: String(a.kind ?? "file") };
+  const map = [
+    ["path", "path"],
+    ["provider", "provider"],
+    ["providerId", "provider_id"],
+    ["url", "url"],
+    ["ref", "ref"],
+    ["status", "status"],
+    ["name", "name"],
+    ["mime", "mime"],
+    ["bytes", "bytes"],
+    ["width", "width"],
+    ["height", "height"],
+    ["durationMs", "duration_ms"],
+    ["waveform", "waveform"],
+    ["posterPath", "poster_path"],
+    ["thumbhash", "thumbhash"]
+  ];
+  for (const [k, col] of map) if (a[col] != null) out[k] = a[col];
+  return out;
+}
+function toScheduled(r) {
+  const sentMessageId = str(r.sent_message_id);
+  const cancelledAt = str(r.cancelled_at);
+  const error = str(r.error);
+  return {
+    id: String(r.id),
+    conversationId: String(r.conversation_id),
+    clientId: String(r.client_id),
+    body: String(r.body ?? ""),
+    attachments: (r.attachments ?? []).map(fromAttachmentArg),
+    replyToId: str(r.reply_to_id),
+    topic: str(r.topic),
+    mentions: r.mentions ?? [],
+    silent: Boolean(r.silent),
+    sendAt: String(r.send_at),
+    sentMessageId,
+    cancelledAt,
+    error,
+    createdAt: String(r.created_at),
+    status: sentMessageId ? "sent" : cancelledAt ? "cancelled" : error ? "failed" : "scheduled"
+  };
+}
+function toAvailability(r) {
+  return {
+    userId: String(r.user_id),
+    awayMessage: str(r.away_message),
+    awayUntil: str(r.away_until),
+    timeZone: str(r.time_zone),
+    // Someone else's hours: only well-formed days and ranges reach the renderers.
+    hours: normalizeHours(r.hours)
+  };
+}
+function toSearchHit(r) {
+  return {
+    messageId: String(r.message_id),
+    conversationId: String(r.conversation_id),
+    seq: Number(r.seq),
+    senderId: str(r.sender_id),
+    createdAt: String(r.created_at),
+    snippet: String(r.snippet ?? ""),
+    inTranscript: Boolean(r.in_transcript)
+  };
+}
+function toLinkPreview(r) {
+  const image = str(r.image_url);
+  return {
+    url: String(r.url),
+    status: r.status ?? "ok",
+    title: str(r.title),
+    description: str(r.description),
+    imageUrl: image && /^https:\/\//i.test(image) ? image : null,
+    siteName: str(r.site_name),
+    fetchedAt: String(r.fetched_at)
+  };
+}
 var MESSAGE_COLUMNS = "*, attachments(*), reactions(emoji, user_id)";
 function createChatClient(supabase, options = {}) {
   const db = () => supabase.schema(CHAT_SCHEMA);
@@ -277,20 +532,24 @@ function createChatClient(supabase, options = {}) {
   }
   return {
     supabase,
+    /** Your conversations: one `kind`, several `kinds`, or all but `excludeKinds` (e.g. Messages without `support`). */
     async inbox(opts = {}) {
       const rows = await rpc("inbox", {
         p_kind: opts.kind ?? null,
         p_archived: opts.archived ?? false,
         p_limit: opts.limit ?? 50,
-        p_before: opts.before ?? null
+        p_before: opts.before ?? null,
+        ...opts.kinds?.length ? { p_kinds: opts.kinds } : {},
+        ...opts.excludeKinds?.length ? { p_exclude_kinds: opts.excludeKinds } : {}
       });
       return rows.map(toInboxItem);
     },
     async observed(kind, opts = {}) {
       return rpc("observed", { p_kind: kind, p_status: opts.status ?? null, p_limit: opts.limit ?? 50, p_before: opts.before ?? null });
     },
-    async unreadTotal() {
-      return rpc("unread_total", {});
+    /** Unread across your conversations (for a badge), leaving out `excludeKinds` to match an inbox that does. */
+    async unreadTotal(opts = {}) {
+      return rpc("unread_total", opts.excludeKinds?.length ? { p_exclude_kinds: opts.excludeKinds } : {});
     },
     async conversation(id) {
       const row = must("conversation", await db().from("conversations").select("*").eq("id", id).maybeSingle());
@@ -423,6 +682,115 @@ function createChatClient(supabase, options = {}) {
     async report(messageId, reason, note) {
       return rpc("report_message", { p_message_id: messageId, p_reason: reason, p_note: note ?? null });
     },
+    // ── Migration 0002 ──────────────────────────────────────────────────────
+    /** A conversation's topics, in order (position, then key). */
+    async topics(conversationId) {
+      const rows = must(
+        "topics",
+        await db().from("topics").select("*").eq("conversation_id", conversationId).order("position", { ascending: true }).order("topic", { ascending: true })
+      );
+      return rows.map(toTopic);
+    },
+    /** Adds a topic, or renames, reorders, closes (`closed: true`) or reopens it. Owners and admins. */
+    async setTopic(conversationId, topic, input = {}) {
+      await rpc("set_topic", {
+        p_conversation_id: conversationId,
+        p_topic: topic,
+        p_title: input.title ?? null,
+        p_position: input.position ?? null,
+        p_closed: input.closed ?? null
+      });
+    },
+    /** Schedules a message (a minute to a year ahead) and returns its id. Safe to retry with the same clientId. */
+    async schedule(input) {
+      const sendAt = typeof input.sendAt === "string" ? input.sendAt : input.sendAt.toISOString();
+      return rpc("schedule_message", {
+        p_conversation_id: input.conversationId,
+        p_client_id: input.clientId,
+        p_send_at: sendAt,
+        p_body: input.body ?? "",
+        p_attachments: (input.attachments ?? []).map(attachmentArg),
+        p_reply_to_id: input.replyToId ?? null,
+        p_topic: input.topic ?? null,
+        p_mentions: input.mentions ?? [],
+        p_silent: input.silent ?? false
+      });
+    },
+    /** Your messages still waiting to go (and ones that failed when due), soonest first; in one conversation or all. */
+    async scheduled(conversationId) {
+      let q = db().from("scheduled").select("*").is("sent_message_id", null).is("cancelled_at", null);
+      if (conversationId) q = q.eq("conversation_id", conversationId);
+      const rows = must("scheduled", await q.order("send_at", { ascending: true }).limit(200));
+      return rows.map(toScheduled);
+    },
+    async cancelScheduled(id) {
+      await rpc("cancel_scheduled", { p_id: id });
+    },
+    /** The away message and hours of a conversation's members who set them (not observers). */
+    async availabilityFor(conversationId) {
+      const rows = await rpc("availability_for", { p_conversation_id: conversationId });
+      return (rows ?? []).map(toAvailability);
+    },
+    /** Your own away message and hours, or null when never set. */
+    async myAvailability() {
+      const row = must("myAvailability", await db().from("availability").select("*").maybeSingle());
+      return row ? toAvailability(row) : null;
+    },
+    /** Replaces your away message and hours (a field left out is cleared). */
+    async setAvailability(input) {
+      const until = input.awayUntil ?? null;
+      await rpc("set_availability", {
+        p_away_message: input.awayMessage ?? null,
+        p_away_until: until,
+        p_time_zone: input.timeZone ?? null,
+        p_hours: input.hours ?? null
+      });
+    },
+    /**
+     * Sends one text message into each of these conversations where you may post (a coach to
+     * each client's direct conversation), so replies come back privately. Text only. Safe to
+     * retry with the same clientId. Returns the ids of the messages sent.
+     */
+    async broadcast(conversationIds, clientId, body, opts = {}) {
+      const ids = await rpc("broadcast_message", {
+        p_conversation_ids: conversationIds,
+        p_client_id: clientId,
+        p_body: body,
+        p_attachments: [],
+        p_silent: opts.silent ?? false
+      });
+      return (ids ?? []).map(String);
+    },
+    /** Messages (and transcripts) you can read that match, newest first: in one conversation or all of yours. Two characters at least. */
+    async search(query, conversationId, opts = {}) {
+      if (query.trim().length < 2) return [];
+      const rows = await rpc("search_messages", {
+        p_query: query,
+        p_conversation_id: conversationId ?? null,
+        p_limit: opts.limit ?? 30
+      });
+      return (rows ?? []).map(toSearchHit);
+    },
+    /**
+     * The previews the server has fetched for the links in these messages, by message id (only
+     * `ok` ones; links not fetched yet are left out). Read through link_previews_for, one call
+     * per message (up to 6 at once), which answers only for messages you can read: the preview
+     * table itself is closed, since a URL can carry a secret.
+     */
+    async linkPreviewsFor(messageIds) {
+      const ids = [...new Set(messageIds.filter(Boolean))].slice(0, 200);
+      const out = {};
+      let next = 0;
+      const worker = async () => {
+        while (next < ids.length) {
+          const id = ids[next++];
+          const rows = await rpc("link_previews_for", { p_message_id: id });
+          out[id] = (rows ?? []).map(toLinkPreview).filter((p) => p.status === "ok");
+        }
+      };
+      await Promise.all(Array.from({ length: Math.min(6, ids.length) }, worker));
+      return out;
+    },
     /**
      * Uploads a file into the conversation's folder for the signed-in person and
      * returns its path, ready to attach. Resumable for big files is the native
@@ -468,8 +836,10 @@ function createChatClient(supabase, options = {}) {
       return { unsubscribe: join(channel) };
     },
     /**
-     * A conversation's live hints, plus who is typing or recording. `onReconnect`
-     * runs whenever the channel (re)joins, the moment to fetch what was missed.
+     * A conversation's live hints, plus who is typing or recording. `onJoin` runs every
+     * time the channel joins, the first time included: the moment to fetch what arrived
+     * before the subscription was live. `onReconnect` (kept for older callers) runs on
+     * re-joins only.
      */
     subscribeConversation(conversationId, me, handlers) {
       let joinedOnce = false;
@@ -484,14 +854,18 @@ function createChatClient(supabase, options = {}) {
       ).on("broadcast", { event: "members" }, () => handlers.onSignal({ type: "members", conversationId })).on("broadcast", { event: "conversation" }, () => handlers.onSignal({ type: "conversation", conversationId })).on("broadcast", { event: "activity" }, ({ payload }) => {
         if (payload?.userId && payload.userId !== me) handlers.onActivity?.({ userId: payload.userId, activity: payload.activity, at: Date.now() });
       });
+      let joined = false;
       const leave = join(channel, (status) => {
+        joined = status === "SUBSCRIBED";
         if (status === "SUBSCRIBED") {
+          handlers.onJoin?.();
           if (joinedOnce) handlers.onReconnect?.();
           joinedOnce = true;
         }
       });
       return {
         signal(activity) {
+          if (!joined) return;
           void channel.send({ type: "broadcast", event: "activity", payload: { userId: me, activity } });
         },
         unsubscribe: leave
@@ -520,6 +894,6 @@ function attachmentArg(a) {
   };
 }
 
-export { ALLOWED_EXTENSIONS, CHAT_BUCKET, CHAT_LIMITS, CHAT_SCHEMA, ChatError, PLAYBACK_RATES, attachmentKindFor, conversationTopic, createChatClient, fileExtension, formatDuration, isAllowedExtension, nextPlaybackRate, randomId, recordingLimitMs, toAttachment, toMessage, userTopic, waveformFromMetering, waveformPeaks };
-//# sourceMappingURL=chunk-JQXZUEEL.js.map
-//# sourceMappingURL=chunk-JQXZUEEL.js.map
+export { ALLOWED_EXTENSIONS, CHAT_BUCKET, CHAT_LIMITS, CHAT_SCHEMA, ChatError, MAX_RANGES_PER_DAY, PLAYBACK_RATES, WEEKDAYS, attachmentKindFor, awayLine, awaySummary, conversationTopic, createChatClient, fileExtension, formatDuration, hoursSummary, isAllowedExtension, isAway, isWithinWorkingHours, localClock, minutesOf, namesLine, nextPlaybackRate, normalizeHours, randomId, recordingLimitMs, timeZoneLabel, toAttachment, toAvailability, toLinkPreview, toMessage, toScheduled, toSearchHit, toTopic, untilLabel, userTopic, waveformFromMetering, waveformPeaks };
+//# sourceMappingURL=chunk-7S6HYNWW.js.map
+//# sourceMappingURL=chunk-7S6HYNWW.js.map