@12-apps/notifications 4.9.0 → 4.10.0

package/src/react/live-config.ts

@@ -0,0 +1,79 @@
+/**
+ * The host's half of live activities: where they come from, and what they say.
+ *
+ * Both are the host's because neither can be this package's. It has no idea
+ * what is happening — only the application does — and it has no words, for the
+ * same reason `NotificationMessages` is required rather than defaulted: a
+ * package that ships one product's sentences ships them to every other product
+ * too, and the adopter reached by saying nothing is the one who never notices.
+ */
+import type { ReactNode } from 'react';
+
+import type { LiveActivity } from '../live';
+
+/**
+ * Where the surface gets the activities that are live RIGHT NOW.
+ *
+ * A HOOK rather than a fetcher, and rather than a factory-time `subscribe`,
+ * because the answer almost always lives in React context: the tenant, the
+ * session, the host's query client. `NotificationsSignalHook` exists for
+ * exactly this reason one seam over, and a host in that shape had no way to
+ * pass anything at all.
+ *
+ * `active` is whether the surface currently needs the answer. It is a HINT
+ * about need, never about correctness: a host that ignores it and always
+ * answers is behaving correctly and merely paying for it.
+ *
+ * What it is NOT is the only thing standing between a shut panel and a query.
+ * The panel is fetched lazily and renders nothing until somebody first opens
+ * the bell, and the drawer unmounts its content on close — so a host that
+ * simply reads `active` and ignores it still issues nothing while the panel is
+ * away. `active` is `false` for the frames of the closing transition, which is
+ * where it earns its keep: a query told to stand down there does not fire one
+ * last time on the way out.
+ *
+ * Return whatever is live, newest activity first or in whatever order the host
+ * means; the surface renders them in the order given. An empty array is the
+ * normal answer and renders nothing — no heading, no empty state, no gap.
+ */
+export type LiveActivitiesHook = (options: {
+  active: boolean;
+}) => readonly LiveActivity[];
+
+/** The three sentences the live section says. */
+export interface LiveActivityMessages {
+  /** The heading over the pinned entries, e.g. "Em andamento". */
+  sectionTitle: string;
+  /** The link's accessible name, e.g. `(title) => `Abrir ${title}``. */
+  openActivity: (title: string) => string;
+  /**
+   * The "last moved" line, given an already-relative time.
+   *
+   * Takes the phrase rather than the instant so the relative wording stays in
+   * ONE place — `relativeTime` and the inbox rows' `há 5 min` — and a host
+   * cannot end up with two vocabularies for the same duration in one panel.
+   */
+  updated: (relative: string) => string;
+}
+
+/** Live activities, as a host turns them on. */
+export interface LiveActivitiesConfig {
+  useActivities: LiveActivitiesHook;
+  messages: LiveActivityMessages;
+  /**
+   * The mark on the left of a card — the fastest read, before any words.
+   *
+   * A node rather than a field on {@link LiveActivity} so the contract stays
+   * framework-free: the root entry is shared with the server half, and a
+   * `ReactNode` in it would put React on that import path for a backend that
+   * only ever writes rows. The host switches on `kind`, which is what `kind` is
+   * for. No renderer, no mark, and the card is text — never a placeholder box.
+   *
+   * **Return something PRESENTATIONAL.** The mark is drawn inside the card's
+   * own `<button>` and inside an `aria-hidden` wrapper, so a focusable node
+   * here is a button inside a button — invalid HTML, and the exact defect the
+   * card's structure exists to prevent — as well as a control hidden from the
+   * accessibility tree. An icon or an `<svg>`; not a control.
+   */
+  renderIcon?: (activity: LiveActivity) => ReactNode;
+}

package/src/react/live-section.tsx

@@ -0,0 +1,141 @@
+/**
+ * The pinned block at the top of the panel: everything that is happening NOW,
+ * above everything that has already happened.
+ *
+ * ## Why it is here and not a second surface
+ *
+ * The notification centre is where a person goes to find out what they missed.
+ * Splitting "happening" into its own bell would make them check two places to
+ * answer one question, and the half they would stop checking is the one that
+ * only has something in it occasionally — which is this one. Above the list,
+ * inside the same drawer, it is on the path they already walk.
+ *
+ * ## What it deliberately does NOT do
+ *
+ * - It does not touch `unread`. A live entry is not news; counting it would put
+ *   a number on the bell that no amount of reading can clear.
+ * - It renders nothing at all when there is nothing live — no heading, no empty
+ *   state, no reserved space. A panel with one permanent empty section in it is
+ *   a panel that has taught its reader to skip the top.
+ * - It does not fetch. `useActivities` is the host's, and `active` tells it
+ *   whether anyone is looking.
+ */
+import { useEffect, useId, useState, type JSX } from 'react';
+
+import { Box } from '@12-apps/ui/mui/Box';
+import { Text } from '@12-apps/ui/typography/Text';
+
+import type { LiveActivity } from '../live';
+import type { NotificationMessages } from '../messages';
+
+import { LiveActivityCard } from './live-card';
+import type { LiveActivitiesConfig } from './live-config';
+
+/**
+ * How often the section re-reads the clock.
+ *
+ * Every minute, because the timestamps under the cards are in minutes and a
+ * tick that cannot change what is on screen is a wasted render — which is why
+ * it is gated on there being something to tick as well as on the panel being
+ * open. An open panel with nothing live schedules nothing at all; the earlier
+ * gate was `active` alone, and it re-rendered a section that renders `null`
+ * once a minute for as long as somebody left the inbox open.
+ */
+const TICK_MS = 60_000;
+
+/**
+ * The current minute, re-read on a timer while there is something to tick.
+ *
+ * The caller passes `active && there are activities` — see {@link TICK_MS} for
+ * why both halves are in it.
+ */
+function useMinuteTick(active: boolean): number {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!active) return;
+    // Re-read once on becoming active too: a panel reopened after ten minutes
+    // would otherwise show the minute it was closed at until the first tick.
+    setNow(Date.now());
+    const timer = setInterval(() => setNow(Date.now()), TICK_MS);
+    return () => clearInterval(timer);
+  }, [active]);
+  return now;
+}
+
+export interface LiveSectionProps {
+  config: LiveActivitiesConfig;
+  messages: NotificationMessages;
+  /** Whether the panel is open — passed straight through to the host's hook. */
+  active: boolean;
+  /**
+   * Follow a card's link.
+   *
+   * Optional, and the panel omits it for a host with no router: a card that
+   * cannot go anywhere renders as text rather than as a named control that
+   * does nothing.
+   */
+  onOpen?: (activity: LiveActivity) => void;
+}
+
+
+
+export function LiveSection({
+  config,
+  messages,
+  active,
+  onOpen,
+}: LiveSectionProps): JSX.Element | null {
+  // Unconditional, because it is a hook. `active` is how it is told nobody is
+  // looking — the same arrangement `useSignal` has one seam over.
+  const activities = config.useActivities({ active });
+  const now = useMinuteTick(active && activities.length > 0);
+  // Per MOUNT, not per module: `LiveSection` is exported, and a host with a
+  // desktop and a mobile panel would otherwise emit one id twice and have both
+  // regions resolve their label to whichever came first.
+  const headingId = useId();
+
+  if (activities.length === 0) return null;
+
+  return (
+    // A NAMED region. Without the label a screen-reader user meets a loose run
+    // of controls ahead of the inbox with nothing saying what they are; the
+    // panel's own title is the drawer's heading and cannot describe this block.
+    <Box
+      component="section"
+      aria-labelledby={headingId}
+      data-testid="live-activities"
+      sx={{ pb: 1.5 }}
+    >
+      {/*
+        A SPAN, not a heading. `aria-labelledby` names the region perfectly well
+        from one, and an `<h2>` here would sit under the drawer's own `<h6>`
+        title and ABOVE the inbox's `<h3>` empty state — an outline in which the
+        inbox's states read as part of the live block, which is the opposite of
+        what the two blocks are.
+      */}
+      <Text
+        id={headingId}
+        variant="caption"
+        size="xs"
+        color="secondary"
+        weight="semibold"
+        as="span"
+      >
+        {config.messages.sectionTitle}
+      </Text>
+      <Box sx={{ pt: 0.75 }}>
+        {activities.map((activity) => (
+          <LiveActivityCard
+            key={activity.id}
+            activity={activity}
+            messages={messages}
+            live={config.messages}
+            now={now}
+            {...(onOpen ? { onOpen } : {})}
+            {...(config.renderIcon ? { renderIcon: config.renderIcon } : {})}
+          />
+        ))}
+      </Box>
+    </Box>
+  );
+}

package/src/react/panel-lazy.tsx

@@ -36,12 +36,15 @@ import { Suspense, lazy, useEffect, useState, type ComponentType, type JSX } fro
 import type { NotificationMessages } from '../messages';
 
 import type { InboxStore } from './inbox-state';
+import type { LiveActivitiesConfig } from './live-config';
 import type { NotificationsPanelProps } from './panel';
 
 /** What the factory binds into the panel, and the host never passes. */
 interface PanelParts {
   store: InboxStore;
   messages: NotificationMessages;
+  /** Absent unless the host turned live activities on — see `./live-config`. */
+  live?: LiveActivitiesConfig;
 }
 
 export function lazyNotificationsPanel(

package/src/react/panel.tsx

@@ -17,12 +17,15 @@ import { Box } from '@12-apps/ui/mui/Box';
 import { useMediaQuery } from '@12-apps/ui/mui/useMediaQuery';
 import { useTheme } from '@12-apps/ui/mui/styles';
 
+import type { LiveActivity } from '../live';
 import type { NotificationMessages } from '../messages';
 import type { InboxNotification } from '../wire';
 
 import { BellIcon } from './bell-icon';
 import { useInboxList } from './hooks';
 import type { InboxState, InboxStore } from './inbox-state';
+import type { LiveActivitiesConfig } from './live-config';
+import { LiveSection } from './live-section';
 import { NotificationRow } from './row';
 
 interface PanelBodyProps {
@@ -105,6 +108,43 @@ function PanelBody({
   );
 }
 
+/**
+ * The two open gestures, which are ONE deep-link path with a mark-read in front
+ * of half of it.
+ *
+ * Lifted out of the component because both kinds of entry follow a link the
+ * same way and a host with no router follows neither — one rule, stated once,
+ * rather than the same three lines written twice.
+ */
+function usePanelOpeners(
+  store: InboxStore,
+  onClose: () => void,
+  onNavigate?: (link: string) => void,
+): {
+  openNotification: (notification: InboxNotification) => void;
+  openLive: (activity: LiveActivity) => void;
+} {
+  const follow = useCallback(
+    (link: string | null) => {
+      if (!link || !onNavigate) return;
+      onClose();
+      onNavigate(link);
+    },
+    [onClose, onNavigate],
+  );
+
+  return {
+    openNotification: useCallback(
+      (notification: InboxNotification) => {
+        if (notification.readAt === null) store.markRead([notification.id]);
+        follow(notification.link);
+      },
+      [store, follow],
+    ),
+    openLive: useCallback((activity: LiveActivity) => follow(activity.link), [follow]),
+  };
+}
+
 export interface NotificationsPanelProps {
   open: boolean;
   onClose: () => void;
@@ -118,9 +158,11 @@ export function NotificationsPanel({
   onNavigate,
   store,
   messages,
+  live,
 }: NotificationsPanelProps & {
   store: InboxStore;
   messages: NotificationMessages;
+  live?: LiveActivitiesConfig;
 }): JSX.Element {
   // `useTheme` from @mui/material/styles falls back to the DEFAULT theme when
   // no provider is mounted, where the callback form of `useMediaQuery` would
@@ -130,16 +172,7 @@ export function NotificationsPanel({
   const isMobile = useMediaQuery(theme.breakpoints.down('sm'));
   const state = useInboxList(store, open);
 
-  const openNotification = useCallback(
-    (notification: InboxNotification) => {
-      if (notification.readAt === null) store.markRead([notification.id]);
-      if (notification.link && onNavigate) {
-        onClose();
-        onNavigate(notification.link);
-      }
-    },
-    [store, onClose, onNavigate],
-  );
+  const { openNotification, openLive } = usePanelOpeners(store, onClose, onNavigate);
 
   const hasUnread = state.items.some((item) => item.readAt === null);
 
@@ -154,6 +187,20 @@ export function NotificationsPanel({
     >
       <DrawerHeader onClose={onClose}>{messages.panelTitle}</DrawerHeader>
       <DrawerContent>
+        {/*
+          Above the mark-all control as well as above the list, deliberately:
+          "marcar todas como lidas" belongs to the INBOX, and a live entry has
+          nothing to mark. A control between the two blocks would read as
+          applying to both.
+        */}
+        {live ? (
+          <LiveSection
+            config={live}
+            messages={messages}
+            active={open}
+            {...(onNavigate ? { onOpen: openLive } : {})}
+          />
+        ) : null}
         {hasUnread ? (
           <Box sx={{ display: 'flex', justifyContent: 'flex-end', pb: 1 }}>
             <Button

package/src/react/relative-time.ts

@@ -4,9 +4,21 @@ import type { NotificationMessages } from '../messages';
  * "há 5 min"-style relative timestamp, falling back to an absolute date for
  * anything older than a week. Every word comes from the messages table, so a
  * host in another locale changes the copy and the locale together.
+ *
+ * `now` is a parameter rather than a read, and the live section is why. A
+ * relative phrase is only true for the instant it was computed, so something
+ * has to CAUSE the render that recomputes it — and the live entries' own data
+ * cannot: a host backed by react-query gets the previous object back whenever a
+ * poll is deep-equal (`structuralSharing`, on by default), which within one
+ * stage it always is. The section therefore ticks a clock and hands it down.
+ * Defaulted, so every existing caller reads the wall clock exactly as before.
  */
-export function relativeTime(iso: string, messages: NotificationMessages): string {
-  const elapsedMs = Date.now() - new Date(iso).getTime();
+export function relativeTime(
+  iso: string,
+  messages: NotificationMessages,
+  now: number = Date.now(),
+): string {
+  const elapsedMs = now - new Date(iso).getTime();
   const minutes = Math.round(elapsedMs / 60_000);
   if (minutes < 1) return messages.justNow;
   if (minutes < 60) return messages.minutesAgo(minutes);

package/src/server/transports/web-push.ts

@@ -1,3 +1,4 @@
+import { livePushTag } from '../../live';
 import type {
   NotificationContent,
   NotificationLogger,
@@ -52,6 +53,26 @@ export interface WebPushMessage {
   body: string;
   link: string | null;
   data: Record<string, unknown>;
+  /**
+   * The OS tray tag, or `null` for an ordinary event.
+   *
+   * Present for a notification about a LIVE SUBJECT (see `../../live`), and
+   * this is the whole of the live feature's reach onto a locked phone: a tag
+   * makes the next push about the same subject REPLACE the one already in the
+   * tray — silently — instead of stacking under it. Four stages then cost one
+   * entry and one buzz, and the entry that remains is the current one.
+   *
+   * {@link formatWebPush} always sets it, `null` included, so on the WIRE the
+   * key is always there and a service worker reads one shape. A worker that
+   * ignores it keeps today's behaviour exactly, which is what makes this safe
+   * to ship ahead of the workers.
+   *
+   * OPTIONAL in the type, and only in the type: a host that hand-writes its own
+   * `NotificationTransport<WebPushMessage>` — a fixture, a second driver —
+   * would otherwise stop compiling on a field it has no way to know about and
+   * no reason to set.
+   */
+  tag?: string | null;
 }
 
 export interface WebPushDriverDeclaration extends DriverDeclarationBase {
@@ -120,6 +141,7 @@ export function formatWebPush(content: NotificationContent): WebPushMessage {
     body: content.body,
     link: content.link ?? null,
     data: content.data ?? {},
+    tag: livePushTag(content.data),
   };
 }
 

package/src/types.ts

@@ -64,7 +64,16 @@ export interface NotificationContent {
   body: string;
   /** In-app deep link (a same-origin path such as `/orders/123`). */
   link?: string;
-  /** Structured extras for consumers that want more than text. */
+  /**
+   * Structured extras for consumers that want more than text.
+   *
+   * ONE KEY IS RESERVED: `liveSubject` (`LIVE_SUBJECT_KEY` in `./live`) ties
+   * this notification to a live activity, and the WEB_PUSH transport turns it
+   * into the tray `tag` that collapses every push about one subject onto a
+   * single entry. A host already using that name for something else acquires
+   * that behaviour without asking for it — so it is named here, on the field a
+   * generator actually writes, and not only where the feature is documented.
+   */
   data?: Record<string, unknown>;
 }
 

package/dist/chunk-BGI4BQ66.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/**\n * Core types of the channel-agnostic notification system (12-15).\n *\n * Three decoupled layers, each open for extension without touching the others:\n *   - GENERATORS map a typed domain event to agnostic content (title/body/…).\n *   - The CHANNEL ROUTER always writes the notification-centre inbox record,\n *     then fans out one delivery per enabled channel.\n *   - TRANSPORTS format the agnostic content for one channel and send it.\n *\n * Nothing here knows about a concrete channel's wire format — that lives\n * entirely inside each transport adapter — and nothing here knows about a\n * concrete DOMAIN either: the event `type` set, the preference categories and\n * the channel list are all host config (see {@link NotificationTaxonomy}).\n */\n\n/** Transport channels a notification can fan out to (DB CHECK mirrors this). */\nexport const NOTIFICATION_CHANNELS = ['EMAIL', 'SMS', 'WHATSAPP', 'WEB_PUSH'] as const;\nexport type NotificationChannel = (typeof NOTIFICATION_CHANNELS)[number];\n\n/**\n * The preference categories are the HOST's, and required.\n *\n * There used to be a `NOTIFICATION_CATEGORIES = ['orders','payments','stock',\n * 'system']` here — one product's set — and `taxonomyOf` fell back to it\n * whenever a host passed none. The docstring argued the case itself: \"it is\n * product vocabulary, not machinery\", and then shipped the vocabulary anyway as\n * the default, which is the only part a forgetful host would ever see.\n *\n * The consequence was quiet rather than loud: the settings screen renders four\n * rows a foreign host never chose, its own categories are absent, and every\n * preference a user sets is filed against a taxonomy nothing else in that\n * system uses. Nothing throws, because `category` is deliberately a free string\n * — the packaged migration puts **no CHECK** on it, precisely because a closed\n * set would be wrong for every host but the first. That freedom is what made\n * the default undetectable.\n *\n * `channel` and `status` are different and keep their CHECKs: those ARE this\n * library's own closed sets.\n */\nexport type NotificationCategory = string;\n\n/**\n * Per-channel delivery lifecycle (DB CHECK mirrors this).\n *\n * `SENDING` is the CLAIM: exactly one dispatcher moves a row out of `QUEUED`,\n * so two dispatchers can never both send the same delivery. A row left\n * `SENDING` is a dispatcher that died mid-send, and the sweep reclaims it once\n * it is older than the cutoff.\n *\n * `DEAD` is terminal: the attempt ceiling was reached (or the recipient no\n * longer exists), and no sweep will pick the row up again. Without it a\n * permanently invalid destination is a billed provider call on every sweep,\n * forever, and the sweep's working set only grows.\n */\nexport type DeliveryStatus = 'QUEUED' | 'SENDING' | 'SENT' | 'FAILED' | 'DEAD';\n\n/**\n * Channel-agnostic content a generator produces. This is what the inbox stores\n * verbatim and what every transport's formatter receives — no channel may leak\n * its wire format into it.\n */\nexport interface NotificationContent {\n  title: string;\n  body: string;\n  /** In-app deep link (a same-origin path such as `/orders/123`). */\n  link?: string;\n  /** Structured extras for consumers that want more than text. */\n  data?: Record<string, unknown>;\n}\n\n/** Who receives a notification. `clientId` scopes it to a tenant when set. */\nexport interface NotificationRecipient {\n  userId: string;\n  clientId?: string;\n}\n\n/**\n * A typed domain event handed to `notify`. `type` selects the registered\n * generator; `payload` is that generator's typed input. Callers never touch\n * channels, formatting, or preferences.\n */\nexport interface NotificationEvent<TPayload = unknown> {\n  type: string;\n  recipient: NotificationRecipient;\n  payload: TPayload;\n}\n\n/**\n * Maps one domain event type to agnostic content. Registered through the\n * server config (or `registerGenerator` for a late arrival); adding a\n * generator never touches existing generators, the router, or any transport\n * (open/closed).\n */\n/**\n * Who the content is being rendered FOR — the reader, at the moment the\n * generator is asked.\n *\n * A notification is stored as rendered TEXT: title and body are columns, so\n * the language is chosen once, when the row is written, and never again. That\n * makes this the only honest place to ask. A generator is registered at BOOT —\n * a host that resolved its words there would pin every future reader to\n * whichever language the process happened to start in, invisibly, because a\n * single-locale host cannot tell the difference.\n *\n * The tag is the RECIPIENT's, never the request's. The person who triggers a\n * notification is routinely not the person who reads it: an invite is sent\n * because an administrator acted and is read by the invitee. Reading\n * `Accept-Language` here would be a bug that only ever surfaces as somebody\n * being told things in a language they do not speak.\n *\n * Absent means \"nobody said\" — a host with one audience, or one that stores no\n * per-user language, populates nothing and every generator answers with its\n * own default exactly as it did before this existed.\n */\nexport interface NotificationGenerateContext {\n  readonly locale?: string | null;\n}\n\nexport interface NotificationGenerator<TPayload = unknown> {\n  /** The event key, dot-namespaced (\"order.paid\"). One generator per type. */\n  type: string;\n  /** The preference category the router gates this type's fan-out on. */\n  category: NotificationCategory;\n  /**\n   * Render this event's content for ONE recipient.\n   *\n   * `context` is OPTIONAL, and that is what keeps every generator written\n   * before it working: a one-parameter `generate` is assignable to this\n   * signature unchanged. A host that passes nothing is stating a fact — it has\n   * no language for this reader — rather than asserting a default.\n   */\n  generate: (payload: TPayload, context?: NotificationGenerateContext) => NotificationContent;\n}\n\n/**\n * The recipient as a transport sees them: resolved destinations only. Built by\n * the router from the host's contact directory + the push subscriptions this\n * package owns; transports use it to answer\n * {@link NotificationTransport.supports}.\n */\nexport interface TransportRecipient {\n  userId: string;\n  email: string | null;\n  /**\n   * The recipient's own language, when the host's contact directory states\n   * one. Absent means \"nobody said\" — see {@link NotificationGenerateContext}.\n   */\n  locale?: string | null;\n  /** Phone as the host stores it (transports normalize per provider rules). */\n  phone: string | null;\n  /** How many active browser push subscriptions the user holds. */\n  pushSubscriptionCount: number;\n}\n\n/**\n * One pluggable channel adapter: a FORMATTER (agnostic content → channel\n * message) plus a SENDER. Adding a channel = registering one of these; the\n * router dispatches through the registry and needs no change.\n *\n * `send` resolves on success and THROWS on failure — the router records the\n * error on the delivery row and isolates it from other channels. Sends must be\n * retry-safe: the router may re-dispatch a QUEUED/FAILED delivery.\n */\nexport interface NotificationTransport<TMessage = unknown> {\n  channel: NotificationChannel;\n  /**\n   * Whether this recipient is addressable on this channel right now — the\n   * destination exists (e-mail / phone / push subscription) AND the provider\n   * is configured. `false` simply skips the channel (no delivery row).\n   */\n  supports(recipient: TransportRecipient): boolean;\n  /** Transform the agnostic content into this channel's message shape. */\n  format(content: NotificationContent): TMessage;\n  /** Deliver the formatted message to the recipient. Throws on failure. */\n  send(message: TMessage, recipient: TransportRecipient): Promise<void>;\n}\n\n/**\n * The host's product vocabulary. Everything below the surface (routing,\n * delivery rows, retries, the wire) is identical for every host; WHICH\n * categories exist and how they are labelled is not.\n */\nexport interface NotificationTaxonomy {\n  /** The preference categories, in the order the settings screen lists them. */\n  categories: readonly NotificationCategory[];\n}\n\n/**\n * The taxonomy in force. `categories` is REQUIRED — see above.\n *\n * The empty check was already here and stays: an empty list and a missing one\n * are the same mistake, and both now fail at assembly rather than rendering an\n * empty settings screen or somebody else's four rows.\n */\nexport function taxonomyOf(config: {\n  categories: readonly NotificationCategory[];\n}): NotificationTaxonomy {\n  const categories = config.categories;\n  if (!categories || categories.length === 0) {\n    throw new Error(\n      '@12-apps/notifications: `categories` is required and must not be empty — ' +\n        'the preference categories are the host\\'s product vocabulary.',\n    );\n  }\n  return { categories: [...categories] };\n}\n\n/** The host's logger. Defaults to the console (the @12-apps/jobs precedent). */\nexport interface NotificationLogger {\n  info(message: string, ...meta: unknown[]): void;\n  error(message: string, ...meta: unknown[]): void;\n}\n"],"mappings":";;;;;AAgBO,IAAM,wBAAwB,CAAC,SAAS,OAAO,YAAY,UAAU;AAkLrE,SAAS,WAAW,QAEF;AACvB,QAAM,aAAa,OAAO;AAC1B,MAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C,UAAM,IAAI;AAAA,MACR;AAAA,IAEF;AAAA,EACF;AACA,SAAO,EAAE,YAAY,CAAC,GAAG,UAAU,EAAE;AACvC;AAXgB;","names":[]}