@marktiderman/genesis-notifications 0.0.0-stage → 0.1.0

package/dist/types-BilguCPW.d.ts

@@ -0,0 +1,332 @@
+/**
+ * `defineNotifications`: the one list of what an app notifies people about,
+ * as `defineFeatures` is the list of what it does. Each type names its
+ * category, the channels it may use (and which are on by default), and two
+ * flags: `critical` (preferences can't turn it off) and `transactional` (no
+ * unsubscribe link, no quiet hours, no digest). The registry also defines the
+ * device notification categories (iOS action buttons) and the Android
+ * channels the app makes on the phone.
+ *
+ * It is plain data plus small render functions, so the browser, the phone
+ * and the server import the same list. `toTypeRows()` is what is mirrored
+ * into the database's `notification_types`.
+ */
+/** Where a notification can go. `in_app` is the feed. */
+declare const CHANNELS: readonly ["in_app", "push", "email"];
+type Channel = (typeof CHANNELS)[number];
+/** Lower case letters, digits, ".", "_" or "-", up to 64 characters: type keys, category ids. */
+declare const KEY_PATTERN: RegExp;
+/** Device category and action ids: Expo asks for no ":" or "-". */
+declare const IOS_ID_PATTERN: RegExp;
+/** Android channel importance (Expo's `AndroidImportance`). */
+type ChannelImportance = "min" | "low" | "default" | "high" | "max";
+interface NotificationCategoryDef {
+    /** What a person sees in their preferences ("Messages"). */
+    label: string;
+    description?: string;
+    /** Preferences can't turn this category off (account security, say). */
+    critical?: boolean;
+    /** The Android channel made for it (its id is the category id). Default importance `"default"`. */
+    android?: {
+        importance?: ChannelImportance;
+        name?: string;
+    };
+}
+/** An action button on a notification. */
+interface NotificationActionDef {
+    id: string;
+    title: string;
+    /** A reply field instead of a plain button. */
+    textInput?: {
+        placeholder?: string;
+        submitTitle?: string;
+    };
+    /** Opens the app (default false: the action is handled in the background). */
+    opensApp?: boolean;
+    destructive?: boolean;
+    /** Needs the phone unlocked. */
+    requiresAuth?: boolean;
+}
+/** A notification category on the device (iOS's word): the actions a notification shows. */
+interface NotificationActionSetDef {
+    actions: readonly NotificationActionDef[];
+    /** Shown when the person has hidden previews for the app. */
+    previewPlaceholder?: string;
+}
+/** What a notification says, made from its `data`. */
+interface RenderedText {
+    title: string;
+    body?: string;
+    /** The app path a tap opens (`/messages/42`). */
+    url?: string;
+    /**
+     * Push-only extras, for a type whose app reads more than the link: `ids` always travel
+     * (a Reply action needs the conversation and message), `display` only when previews are
+     * shown (a sender's name and photo for iOS rich push), and `mutableContent` lets the app's
+     * Notification Service Extension run (dropped with hidden previews). Flat values only; the
+     * notifier's own keys (`notification_id`, `type`, `url`, `thread_key`) can't be replaced.
+     */
+    push?: {
+        ids?: Record<string, string | number>;
+        display?: Record<string, string | number>;
+        mutableContent?: boolean;
+    };
+}
+/** A notification's `data`: references and display values, never a secret. */
+type NotificationData = Record<string, unknown>;
+interface NotificationTypeDef<C extends string = string, A extends string = string> {
+    category: C;
+    /**
+     * The channels this type may use, and whether each is on for someone who
+     * never chose: `{ in_app: true, push: true, email: false }` offers email
+     * as an opt-in. A channel left out is never used.
+     */
+    channels: Partial<Record<Channel, boolean>>;
+    /** Preferences can't turn it off: each channel it offers stays as defaulted. */
+    critical?: boolean;
+    /**
+     * Mail the person needs for something they did (a receipt, a reset): no
+     * unsubscribe link, never held by quiet hours or folded into a digest.
+     * Rate caps are the domain's.
+     */
+    transactional?: boolean;
+    /**
+     * Wait this long before emailing, and skip the email if the person read
+     * the notification in the app meanwhile. Default 0 (send at once).
+     */
+    emailDelaySeconds?: number;
+    /** The device category (a key of `actions`) its pushes carry. */
+    actions?: A;
+    /** `"generic"` always sends neutral push text, whatever the person chose. */
+    pushPrivacy?: "default" | "generic";
+    /**
+     * The email holds a secret link (a one-time token). It is never stored in
+     * `data` or pushed: the server builds it at send time with
+     * `resolveSecretLink(type, ref)`.
+     */
+    secretLink?: boolean;
+    /** What the feed and the push say. */
+    render: (data: NotificationData) => RenderedText;
+}
+interface NotificationsInput<C extends Record<string, NotificationCategoryDef>, A extends Record<string, NotificationActionSetDef>, T extends Record<string, NotificationTypeDef<Extract<keyof C, string>, Extract<keyof A, string>>>> {
+    categories: C;
+    actions?: A;
+    types: T;
+    /** Neutral text for hidden previews. Default "New notification". */
+    hiddenPreview?: {
+        title: string;
+        body?: string;
+    };
+}
+/** One row of `notification_types`, as `genesis_notifications_sync_types` takes it. */
+interface NotificationTypeRow {
+    key: string;
+    category: string;
+    channels: Partial<Record<Channel, boolean>>;
+    critical: boolean;
+    transactional: boolean;
+    email_delay_seconds: number;
+    secret_link: boolean;
+    push_privacy: "default" | "generic";
+    ios_category: string | null;
+}
+interface MatrixRow {
+    id: string;
+    label: string;
+    description?: string;
+    critical: boolean;
+    /** The channels some type in the category offers, in `CHANNELS` order. */
+    channels: Channel[];
+    /** Each offered channel's default: on when any type in the category has it on. */
+    defaults: Partial<Record<Channel, boolean>>;
+}
+interface NotificationRegistry<C extends Record<string, NotificationCategoryDef> = Record<string, NotificationCategoryDef>, A extends Record<string, NotificationActionSetDef> = Record<string, NotificationActionSetDef>, T extends Record<string, NotificationTypeDef> = Record<string, NotificationTypeDef>> {
+    readonly categories: C;
+    readonly actions: A;
+    readonly types: T;
+    readonly hiddenPreview: {
+        title: string;
+        body?: string;
+    };
+    /** The type, or throws: an unknown key is a bug, never dropped quietly. */
+    type(key: string): NotificationTypeDef;
+    has(key: string): boolean;
+    /** Preferences can't turn it off: a critical type, or a type in a critical category. */
+    isCritical(key: string): boolean;
+    /** What the feed and the push say. A render that throws gives the type's key as the title. */
+    render(key: string, data: NotificationData): RenderedText;
+    /** The rows mirrored into `notification_types`. */
+    toTypeRows(): NotificationTypeRow[];
+    /** For a preferences matrix: each category with the channels its types offer. */
+    matrix(): MatrixRow[];
+    /** The device categories to register (`setNotificationCategoryAsync`). */
+    deviceCategories(): {
+        identifier: string;
+        actions: NotificationActionDef[];
+        previewPlaceholder?: string;
+    }[];
+    /** The Android channels, one per category. */
+    androidChannels(): {
+        id: string;
+        name: string;
+        description?: string;
+        importance: ChannelImportance;
+    }[];
+}
+/** Thrown by `defineNotifications`; lists every problem at once. */
+declare class NotificationRegistryError extends Error {
+    readonly problems: string[];
+    constructor(problems: string[]);
+}
+/** The longest email delay: a week. */
+declare const MAX_EMAIL_DELAY_SECONDS: number;
+/**
+ * The notification registry.
+ *
+ * ```ts
+ * export const notifications = defineNotifications({
+ *   categories: { messages: { label: "Messages", android: { importance: "high" } } },
+ *   actions: { message: { actions: [{ id: "reply", title: "Reply", textInput: {} }, { id: "mark_read", title: "Mark as read" }] } },
+ *   types: {
+ *     "chat.message": {
+ *       category: "messages",
+ *       channels: { in_app: true, push: true, email: true },
+ *       emailDelaySeconds: 600,
+ *       actions: "message",
+ *       render: (d) => ({ title: String(d.sender_name), body: String(d.preview), url: `/messages/${d.conversation_id}` }),
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @stability Beta
+ */
+declare function defineNotifications<const C extends Record<string, NotificationCategoryDef>, const A extends Record<string, NotificationActionSetDef>, const T extends Record<string, NotificationTypeDef<Extract<keyof C, string>, Extract<keyof A, string>>>>(input: NotificationsInput<C, A, T>): NotificationRegistry<C, A, T>;
+/**
+ * The actions a message notification shows: Reply (a text field) and Mark as
+ * read. Put it in `actions` under an id (`message`) and name that id in the
+ * message type's `actions`. A tap on either reaches the push block's
+ * `onResponse`; `notificationAction(response)` gives the action id, the typed
+ * text and the notification id (use it as the reply's client id, so a
+ * retried reply stays one reply).
+ */
+declare const MESSAGE_ACTIONS: {
+    readonly actions: readonly [{
+        readonly id: "reply";
+        readonly title: "Reply";
+        readonly textInput: {
+            readonly placeholder: "Message";
+            readonly submitTitle: "Send";
+        };
+    }, {
+        readonly id: "mark_read";
+        readonly title: "Mark as read";
+    }];
+};
+/** The category and type of Admin -> Send a test (`genesis.test`, which the migration creates). Spread them into your registry. */
+declare const GENESIS_TEST_CATEGORY: {
+    readonly genesis: {
+        readonly label: "Tests";
+        readonly description: "Test notifications an admin sends themself.";
+    };
+};
+declare const GENESIS_TEST_TYPE: {
+    readonly "genesis.test": {
+        readonly category: "genesis";
+        readonly channels: {
+            readonly in_app: true;
+            readonly push: true;
+            readonly email: true;
+        };
+        readonly critical: true;
+        readonly transactional: true;
+        readonly render: () => {
+            title: string;
+            body: string;
+        };
+    };
+};
+
+/**
+ * The shapes the notifier's parts share: what a domain passes to `notify()`,
+ * a feed row as the database returns it, and a person's preferences.
+ */
+
+/** A recipient with a login, by user id. */
+interface UserRecipient {
+    userId: string;
+    /** Their own app icon badge (an unread count), over the call's `badge`. */
+    badge?: number;
+}
+/**
+ * Someone with no login (an invitee, a form respondent): email only, never a
+ * feed. `ref` is the domain's id for them ("people:42"), so erasing them
+ * finds their rows.
+ */
+interface EmailRecipient {
+    email: string;
+    name?: string;
+    ref?: string;
+}
+/** A user id string, or one of the two shapes. */
+type Recipient = string | UserRecipient | EmailRecipient;
+/** A brand the caller passes (the tenant's default is used for what it leaves out). */
+interface NotificationBrand {
+    name?: string;
+    logoUrl?: string;
+    /** A CSS colour (`#1d4ed8`), for the email's accent. */
+    color?: string;
+    /** Where a recipient goes from the email's footer. */
+    url?: string;
+}
+/** What a domain asks for. The notifier decides channel, timing and preferences. */
+interface NotifyInput<K extends string = string> {
+    type: K;
+    recipients: readonly Recipient[];
+    /** References and display values the type's render reads. Never a secret or a secret link. */
+    data?: NotificationData;
+    /** Unique per recipient: the same key again is the same notification, never a second one. */
+    idempotencyKey: string;
+    /** Groups pushes on the lock screen (iOS `threadId`): a conversation id. */
+    threadKey?: string;
+    /** A newer one replaces an older one with the same key that hasn't gone out (and on screen). */
+    collapseKey?: string;
+    /** The app icon badge, as the caller counts it. */
+    badge?: number;
+    /** The practice, workspace or organization it belongs to: its sender identity and defaults apply. */
+    tenantId?: string;
+    brand?: NotificationBrand;
+    /**
+     * A plaintext token that exists only hashed in the domain's tables (an
+     * invite). It travels only on the email's send job, encrypted, and is
+     * cleared once the email is sent; `resolveSecretLink` receives it.
+     */
+    secret?: string;
+}
+/** One row `notify()` made or found again. */
+interface NotifyResult {
+    notificationId: string;
+    recipientKey: string;
+    /** False when the idempotency key had been used for this recipient already. */
+    created: boolean;
+}
+/** A feed row, as the browser reads it under row level security. */
+interface NotificationRow {
+    id: string;
+    type: string;
+    category: string;
+    tenant_id: string | null;
+    data: NotificationData;
+    thread_key: string | null;
+    created_at: string;
+    seen_at: string | null;
+    read_at: string | null;
+    archived_at: string | null;
+}
+/** Delivery states. */
+declare const DELIVERY_STATUSES: readonly ["pending", "sending", "sent", "delivered", "failed", "skipped", "cancelled"];
+type DeliveryStatus = (typeof DELIVERY_STATUSES)[number];
+/** A person's explicit choices: category id → channel → on. Absent means the default. */
+type ChannelChoices = Record<string, Partial<Record<Channel, boolean>>>;
+
+export { CHANNELS as C, DELIVERY_STATUSES as D, type EmailRecipient as E, GENESIS_TEST_CATEGORY as G, IOS_ID_PATTERN as I, KEY_PATTERN as K, MAX_EMAIL_DELAY_SECONDS as M, type NotificationData as N, type Recipient as R, type UserRecipient as U, type Channel as a, type ChannelChoices as b, type ChannelImportance as c, type DeliveryStatus as d, GENESIS_TEST_TYPE as e, MESSAGE_ACTIONS as f, type MatrixRow as g, type NotificationActionDef as h, type NotificationActionSetDef as i, type NotificationBrand as j, type NotificationCategoryDef as k, type NotificationRegistry as l, NotificationRegistryError as m, type NotificationRow as n, type NotificationTypeDef as o, type NotificationTypeRow as p, type NotificationsInput as q, type NotifyInput as r, type NotifyResult as s, type RenderedText as t, defineNotifications as u };

package/dist/web.d.ts

@@ -0,0 +1,79 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { a as Channel } from './types-BilguCPW.js';
+import { FeedItem } from './react.js';
+import './supabase.js';
+
+declare const CHANNEL_LABELS: Record<Channel, string>;
+interface FeedRowProps {
+    item: FeedItem;
+    onOpen?: (item: FeedItem) => void;
+    testID?: string;
+}
+/** One feed row: unread dot, title, body, age. */
+declare function NotificationRowView({ item, onOpen, testID }: FeedRowProps): react.JSX.Element;
+interface NotificationBellProps {
+    /** Opens a notification's link (your router's navigate). Marked read first. */
+    onOpen?: (item: FeedItem) => void;
+    /** Where "See all" goes. */
+    onSeeAll?: () => void;
+    /** How many to show. Default 8. */
+    limit?: number;
+    className?: string;
+}
+/**
+ * The bell. Opening it marks what it shows as seen; opening a row marks it read.
+ *
+ * @stability Beta
+ */
+declare function NotificationBell({ onOpen, onSeeAll, limit, className }: NotificationBellProps): react.JSX.Element;
+interface NotificationFeedProps {
+    onOpen?: (item: FeedItem) => void;
+    limit?: number;
+    title?: ReactNode;
+}
+/**
+ * The whole feed, in a card: mark read on open, archive, mark all read.
+ *
+ * @stability Beta
+ */
+declare function NotificationFeed({ onOpen, limit, title }: NotificationFeedProps): react.JSX.Element;
+/**
+ * Categories × channels, a switch each. Critical categories are locked on.
+ * Saves each change at once and puts it back if the save fails.
+ *
+ * @stability Beta
+ */
+declare function PreferencesMatrix({ channelLabels }: {
+    channelLabels?: Partial<Record<Channel, string>>;
+}): react.JSX.Element;
+/**
+ * Admin: the delivery log, newest first. Row level security shows an admin
+ * their tenants' rows only; content and full addresses are never here.
+ *
+ * @stability Beta
+ */
+declare function DeliveryLog({ tenantId, limit }: {
+    tenantId?: string | null;
+    limit?: number;
+}): react.JSX.Element;
+/**
+ * Admin: addresses the app won't email (by a masked address; the list keeps
+ * only a hash), and lifting one.
+ *
+ * @stability Beta
+ */
+declare function SuppressionList({ limit }: {
+    limit?: number;
+}): react.JSX.Element;
+/**
+ * Admin: send yourself a test notification (in the app, push and email).
+ *
+ * @stability Beta
+ */
+declare function SendTestNotification({ tenantId, label }: {
+    tenantId?: string | null;
+    label?: string;
+}): react.JSX.Element;
+
+export { CHANNEL_LABELS, DeliveryLog, type FeedRowProps, NotificationBell, type NotificationBellProps, NotificationFeed, type NotificationFeedProps, NotificationRowView, PreferencesMatrix, SendTestNotification, SuppressionList };

package/dist/web.js

@@ -0,0 +1,233 @@
+import { useUnreadCount, useNotifications, usePreferences, useNotificationsContext } from './chunk-2BG336II.js';
+import './chunk-EWZB35V6.js';
+import { useState, useEffect } from 'react';
+import { Bell } from 'lucide-react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { Button, cn, Popover, PopoverTrigger, Badge, PopoverContent, Separator, EmptyState, ScrollArea, Card, CardHeader, CardTitle, CardContent, Table, TableHeader, TableRow, TableHead, TableBody, TableCell, Switch, toast, CardDescription } from '@marktiderman/genesis-ui';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+var CHANNEL_LABELS = { in_app: "In the app", push: "Push", email: "Email" };
+function relative(iso, now = Date.now()) {
+  const s = Math.max(0, Math.round((now - Date.parse(iso)) / 1e3));
+  if (s < 60) return "just now";
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`;
+  return new Date(iso).toLocaleDateString();
+}
+function NotificationRowView({ item, onOpen, testID }) {
+  return /* @__PURE__ */ jsxs(
+    Button,
+    {
+      variant: "ghost",
+      "data-testid": testID ?? `notification-${item.id}`,
+      onClick: () => onOpen?.(item),
+      className: cn("h-auto w-full items-start justify-start gap-3 whitespace-normal px-3 py-2 text-left font-normal", item.unread && "bg-muted/40"),
+      children: [
+        /* @__PURE__ */ jsx("span", { "aria-hidden": true, className: cn("mt-1.5 h-2 w-2 shrink-0 rounded-full", item.unread ? "bg-primary" : "bg-transparent") }),
+        /* @__PURE__ */ jsxs("span", { className: "min-w-0 flex-1", children: [
+          /* @__PURE__ */ jsx("span", { className: cn("block truncate text-sm", item.unread ? "font-semibold" : "font-medium"), children: item.title }),
+          item.body ? /* @__PURE__ */ jsx("span", { className: "block truncate text-sm text-muted-foreground", children: item.body }) : null
+        ] }),
+        /* @__PURE__ */ jsx("span", { className: "shrink-0 text-xs text-muted-foreground", children: relative(item.created_at) }),
+        item.unread ? /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Unread" }) : null
+      ]
+    }
+  );
+}
+function NotificationBell({ onOpen, onSeeAll, limit = 8, className }) {
+  const unread = useUnreadCount();
+  const { items, markRead, markAllRead, markAllSeen } = useNotifications({ limit });
+  const label = unread > 0 ? `Notifications, ${unread} unread` : "Notifications";
+  return /* @__PURE__ */ jsxs(Popover, { onOpenChange: (open) => open && items.some((i) => !i.seen_at) ? void markAllSeen() : void 0, children: [
+    /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "ghost", size: "icon", "aria-label": label, "data-testid": "notification-bell", className: cn("relative", className), children: [
+      /* @__PURE__ */ jsx(Bell, { "aria-hidden": true, className: "h-5 w-5" }),
+      unread > 0 ? /* @__PURE__ */ jsx(Badge, { "data-testid": "notification-bell-count", className: "absolute -right-1 -top-1 h-5 min-w-5 justify-center px-1 text-xs", children: unread > 99 ? "99+" : unread }) : null
+    ] }) }),
+    /* @__PURE__ */ jsxs(PopoverContent, { align: "end", className: "w-80 p-0", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-3 py-2", children: [
+        /* @__PURE__ */ jsx("span", { className: "text-sm font-semibold", children: "Notifications" }),
+        unread > 0 ? /* @__PURE__ */ jsx(Button, { variant: "link", size: "sm", className: "h-auto p-0", "data-testid": "notification-bell-mark-all", onClick: () => void markAllRead(), children: "Mark all read" }) : null
+      ] }),
+      /* @__PURE__ */ jsx(Separator, {}),
+      items.length === 0 ? /* @__PURE__ */ jsx(EmptyState, { title: "No notifications", description: "When you get one, it'll show up here.", className: "py-8" }) : /* @__PURE__ */ jsx(ScrollArea, { className: "max-h-96", children: /* @__PURE__ */ jsx("div", { className: "p-1", children: items.map((item) => /* @__PURE__ */ jsx(
+        NotificationRowView,
+        {
+          item,
+          onOpen: (i) => {
+            if (i.unread) void markRead(i.id);
+            onOpen?.(i);
+          }
+        },
+        item.id
+      )) }) }),
+      onSeeAll ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Separator, {}),
+        /* @__PURE__ */ jsx(Button, { variant: "ghost", className: "w-full rounded-t-none", "data-testid": "notification-bell-see-all", onClick: onSeeAll, children: "See all" })
+      ] }) : null
+    ] })
+  ] });
+}
+function NotificationFeed({ onOpen, limit = 100, title = "Notifications" }) {
+  const { items, isLoading, error, markRead, markAllRead, archive } = useNotifications({ limit });
+  const anyUnread = items.some((i) => i.unread);
+  return /* @__PURE__ */ jsxs(Card, { "data-testid": "notification-feed", children: [
+    /* @__PURE__ */ jsxs(CardHeader, { className: "flex flex-row items-center justify-between space-y-0", children: [
+      /* @__PURE__ */ jsx(CardTitle, { children: title }),
+      anyUnread ? /* @__PURE__ */ jsx(Button, { variant: "outline", size: "sm", "data-testid": "notification-feed-mark-all", onClick: () => void markAllRead(), children: "Mark all read" }) : null
+    ] }),
+    /* @__PURE__ */ jsx(CardContent, { className: "p-2", children: error ? /* @__PURE__ */ jsx(EmptyState, { title: "Couldn't load notifications", description: "Check your connection and try again." }) : isLoading ? /* @__PURE__ */ jsx("p", { className: "p-4 text-sm text-muted-foreground", children: "Loading\u2026" }) : items.length === 0 ? /* @__PURE__ */ jsx(EmptyState, { title: "No notifications", description: "When you get one, it'll show up here." }) : /* @__PURE__ */ jsx("ul", { className: "divide-y divide-border", children: items.map((item) => /* @__PURE__ */ jsxs("li", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(
+        NotificationRowView,
+        {
+          item,
+          onOpen: (i) => {
+            if (i.unread) void markRead(i.id);
+            onOpen?.(i);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(Button, { variant: "ghost", size: "sm", "aria-label": `Archive ${item.title}`, "data-testid": `notification-archive-${item.id}`, onClick: () => void archive(item.id), children: "Archive" })
+    ] }, item.id)) }) })
+  ] });
+}
+function PreferencesMatrix({ channelLabels = CHANNEL_LABELS }) {
+  const { rows, status, set } = usePreferences();
+  const columns = ["in_app", "push", "email"].filter((ch) => rows.some((r) => r.channels.includes(ch)));
+  if (status === "error") return /* @__PURE__ */ jsx(EmptyState, { title: "Couldn't load your notification settings", description: "Check your connection and try again." });
+  return /* @__PURE__ */ jsxs(Table, { "data-testid": "notification-preferences", children: [
+    /* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+      /* @__PURE__ */ jsx(TableHead, { children: "Notify me about" }),
+      columns.map((ch) => /* @__PURE__ */ jsx(TableHead, { className: "text-center", children: channelLabels[ch] ?? CHANNEL_LABELS[ch] }, ch))
+    ] }) }),
+    /* @__PURE__ */ jsx(TableBody, { children: rows.map((row) => /* @__PURE__ */ jsxs(TableRow, { children: [
+      /* @__PURE__ */ jsxs(TableCell, { children: [
+        /* @__PURE__ */ jsx("div", { className: "font-medium", children: row.label }),
+        row.description ? /* @__PURE__ */ jsx("div", { className: "text-sm text-muted-foreground", children: row.description }) : null,
+        row.critical ? /* @__PURE__ */ jsx("div", { className: "text-xs text-muted-foreground", children: "Always on" }) : null
+      ] }),
+      columns.map((ch) => /* @__PURE__ */ jsx(TableCell, { className: "text-center", children: row.channels.includes(ch) ? /* @__PURE__ */ jsx(
+        Switch,
+        {
+          "aria-label": `${row.label}: ${channelLabels[ch] ?? CHANNEL_LABELS[ch]}`,
+          "data-testid": `notification-preference-${row.id}-${ch}`,
+          checked: Boolean(row.values[ch]),
+          disabled: status !== "ready" || row.critical,
+          onCheckedChange: (on) => void set(row.id, ch, on).catch(() => toast.error("Couldn't save that change. Check your connection and try again."))
+        }
+      ) : /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", "aria-label": "Not available", children: "\u2013" }) }, ch))
+    ] }, row.id)) })
+  ] });
+}
+var STATUS_VARIANT = {
+  delivered: "success",
+  sent: "success",
+  pending: "info",
+  sending: "info",
+  failed: "destructive",
+  skipped: "muted",
+  cancelled: "muted"
+};
+function DeliveryLog({ tenantId, limit = 100 }) {
+  const { client, userId } = useNotificationsContext();
+  const query = useQuery({ queryKey: ["genesis-notifications", userId, "log", tenantId ?? "all", limit], queryFn: () => client.deliveryLog({ tenantId, limit }), enabled: userId !== null });
+  const rows = query.data ?? [];
+  return /* @__PURE__ */ jsxs(Card, { "data-testid": "notification-delivery-log", children: [
+    /* @__PURE__ */ jsxs(CardHeader, { children: [
+      /* @__PURE__ */ jsx(CardTitle, { children: "Delivery log" }),
+      /* @__PURE__ */ jsx(CardDescription, { children: "Every push and email the app sent, and what became of it." })
+    ] }),
+    /* @__PURE__ */ jsx(CardContent, { children: query.isError ? /* @__PURE__ */ jsx(EmptyState, { title: "Couldn't load the log", description: "You may not be an admin of this workspace." }) : rows.length === 0 ? /* @__PURE__ */ jsx(EmptyState, { title: "Nothing sent yet" }) : /* @__PURE__ */ jsxs(Table, { children: [
+      /* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+        /* @__PURE__ */ jsx(TableHead, { children: "When" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Type" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Channel" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "To" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Status" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Detail" })
+      ] }) }),
+      /* @__PURE__ */ jsx(TableBody, { children: rows.map((r) => /* @__PURE__ */ jsxs(TableRow, { "data-testid": `notification-delivery-${r.id}`, children: [
+        /* @__PURE__ */ jsx(TableCell, { className: "whitespace-nowrap text-sm", children: new Date(r.created_at).toLocaleString() }),
+        /* @__PURE__ */ jsx(TableCell, { className: "font-mono text-xs", children: r.type }),
+        /* @__PURE__ */ jsx(TableCell, { children: r.channel === "email" ? "Email" : "Push" }),
+        /* @__PURE__ */ jsx(TableCell, { className: "text-sm", children: r.recipient_masked ?? "\u2014" }),
+        /* @__PURE__ */ jsx(TableCell, { children: /* @__PURE__ */ jsx(Badge, { variant: STATUS_VARIANT[r.status] ?? "muted", children: r.status }) }),
+        /* @__PURE__ */ jsx(TableCell, { className: "text-sm text-muted-foreground", children: r.skip_reason ?? r.error ?? (r.attempts > 1 ? `${r.attempts} attempts` : "") })
+      ] }, r.id)) })
+    ] }) })
+  ] });
+}
+var REASONS = { bounce: "Bounced", complaint: "Marked as spam", unsubscribe: "Unsubscribed", manual: "Added by an admin" };
+function SuppressionList({ limit = 200 }) {
+  const { client, userId } = useNotificationsContext();
+  const queryClient = useQueryClient();
+  const key = ["genesis-notifications", userId, "suppressions", limit];
+  const query = useQuery({ queryKey: key, queryFn: () => client.suppressions({ limit }), enabled: userId !== null });
+  const rows = query.data ?? [];
+  return /* @__PURE__ */ jsxs(Card, { "data-testid": "notification-suppressions", children: [
+    /* @__PURE__ */ jsxs(CardHeader, { children: [
+      /* @__PURE__ */ jsx(CardTitle, { children: "Suppressed addresses" }),
+      /* @__PURE__ */ jsx(CardDescription, { children: "Bounces and spam complaints stop email to an address; lift one once it's fixed." })
+    ] }),
+    /* @__PURE__ */ jsx(CardContent, { children: query.isError ? /* @__PURE__ */ jsx(EmptyState, { title: "Couldn't load the list", description: "Only the app's admins can see it." }) : rows.length === 0 ? /* @__PURE__ */ jsx(EmptyState, { title: "No suppressed addresses" }) : /* @__PURE__ */ jsxs(Table, { children: [
+      /* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+        /* @__PURE__ */ jsx(TableHead, { children: "Address" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Why" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Category" }),
+        /* @__PURE__ */ jsx(TableHead, { children: "Since" }),
+        /* @__PURE__ */ jsx(TableHead, {})
+      ] }) }),
+      /* @__PURE__ */ jsx(TableBody, { children: rows.map((r) => /* @__PURE__ */ jsxs(TableRow, { children: [
+        /* @__PURE__ */ jsx(TableCell, { children: r.email_masked ?? `${r.email_hash.slice(0, 8)}\u2026` }),
+        /* @__PURE__ */ jsx(TableCell, { children: REASONS[r.reason] ?? r.reason }),
+        /* @__PURE__ */ jsx(TableCell, { children: r.category === "*" ? "All" : r.category }),
+        /* @__PURE__ */ jsx(TableCell, { className: "whitespace-nowrap text-sm", children: new Date(r.created_at).toLocaleDateString() }),
+        /* @__PURE__ */ jsx(TableCell, { className: "text-right", children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "outline",
+            size: "sm",
+            "data-testid": `notification-suppression-lift-${r.email_hash.slice(0, 12)}`,
+            onClick: async () => {
+              try {
+                await client.removeSuppression(r.email_hash, r.category);
+                await queryClient.invalidateQueries({ queryKey: key });
+              } catch {
+                toast.error("Couldn't lift it. Try again.");
+              }
+            },
+            children: "Lift"
+          }
+        ) })
+      ] }, `${r.email_hash}:${r.category}`)) })
+    ] }) })
+  ] });
+}
+function SendTestNotification({ tenantId = null, label = "Send a test" }) {
+  const { client } = useNotificationsContext();
+  const [busy, setBusy] = useState(false);
+  const [mounted, setMounted] = useState(true);
+  useEffect(() => () => setMounted(false), []);
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      "data-testid": "notification-send-test",
+      disabled: busy,
+      onClick: async () => {
+        setBusy(true);
+        try {
+          await client.sendTest(tenantId);
+          toast.success("Test sent. It reaches you on each channel you have on.");
+        } catch {
+          toast.error("Couldn't send the test. Only admins can.");
+        } finally {
+          if (mounted) setBusy(false);
+        }
+      },
+      children: label
+    }
+  );
+}
+
+export { CHANNEL_LABELS, DeliveryLog, NotificationBell, NotificationFeed, NotificationRowView, PreferencesMatrix, SendTestNotification, SuppressionList };
+//# sourceMappingURL=web.js.map
+//# sourceMappingURL=web.js.map