@12-apps/notifications 4.6.0 → 4.7.1

package/src/react/page-lazy.tsx

@@ -0,0 +1,73 @@
+/**
+ * The routed preferences screen, fetched when a host actually routes to it.
+ *
+ * `createWebNotifications` returns two different KINDS of thing, and its own
+ * docstring says so: `page` is "the standalone surface … the one thing a host
+ * routes to", while the bell and the panel "are a PAIR a host drops into its own
+ * chrome". Chrome is on screen from the first paint; a routed surface is not.
+ *
+ * A static import made that distinction invisible to a bundler. Every host that
+ * put the bell in its header also shipped the preferences matrix — its channel
+ * toggles, the per-browser push enable step, and the design-system `Switch`
+ * behind them — in the same chunk as the header. A storefront paid for a
+ * settings screen a shopper never opens, before its first screen could render;
+ * a host that renders its OWN preferences page paid for this one twice.
+ *
+ * So `page` now loads on demand. Nothing else moves: the bell, the panel and
+ * `BellWithPanel` stay exactly as eager as the chrome they belong to, because
+ * that is what they are.
+ *
+ * NO PREFETCH, deliberately, and this is the opposite call from a surface a
+ * host opens from chrome it already has. A routed surface is reached by
+ * NAVIGATION, and every host here already code-splits its routes — so the
+ * fetch happens while the route is being entered, which is the moment a
+ * prefetch would have been trying to anticipate. Warming it at factory time
+ * would put the screen back on the boot path of every app, which is the whole
+ * cost this removes.
+ */
+import { Suspense, lazy, type ComponentType, type JSX } from 'react';
+
+import type { NotificationMessages } from '../messages';
+
+import type { NotificationsApiClient } from './api';
+import type { PreferencesScreenProps } from './preferences-screen';
+import type { WebPushSetupConfig } from './web-push-setup';
+
+/** What the factory binds into the screen, and the host never passes. */
+interface PreferencesPageParts {
+  api: NotificationsApiClient;
+  messages: NotificationMessages;
+  webPush: WebPushSetupConfig;
+}
+
+/**
+ * The routed screen, bound and loaded on first render.
+ *
+ * `lazy` memoises its factory, so the binding below happens once however many
+ * times a host mounts the page — the same guarantee the direct call gave.
+ *
+ * The fallback is `null` because a host routes to this: whatever it renders
+ * around the route is already on screen, and a second spinner inside it would
+ * be one more thing appearing and disappearing during a navigation the host is
+ * already indicating.
+ */
+export function lazyPreferencesPage(
+  parts: PreferencesPageParts,
+): ComponentType<PreferencesScreenProps> {
+  const Bound = lazy(async () => {
+    const { PreferencesScreen } = await import('./preferences-screen');
+    return {
+      default: (props: PreferencesScreenProps): JSX.Element => (
+        <PreferencesScreen {...props} {...parts} />
+      ),
+    };
+  });
+
+  return function NotificationsPreferencesPage(props: PreferencesScreenProps): JSX.Element {
+    return (
+      <Suspense fallback={null}>
+        <Bound {...props} />
+      </Suspense>
+    );
+  };
+}

package/src/react/panel-lazy.tsx

@@ -0,0 +1,74 @@
+/**
+ * The inbox slide-over, fetched the first time somebody opens it.
+ *
+ * The bell and the panel are a PAIR a host drops into its chrome, and that is
+ * still true — but only the BELL is on screen when a page paints. The panel is
+ * behind a tap, and a static import made every host pay for it up front: the
+ * design-system `Drawer` and, through it, MUI's `SwipeableDrawer`, `Modal`,
+ * `Slide` and the focus trap, plus the row, the empty state and the pager. On a
+ * storefront that is a slide-over most visits never open, parsed before the
+ * first screen can render.
+ *
+ * ## Why the gate is "ever opened" rather than `open`
+ *
+ * `lazy` fetches when a component first RENDERS, so a boundary that still
+ * rendered the panel while closed would fetch immediately and buy nothing. This
+ * renders `null` until the panel has been open once, which is what actually
+ * defers the download to the tap.
+ *
+ * And once opened it STAYS mounted. Unmounting on close would throw away the
+ * drawer's transition state, so the panel would vanish instead of sliding out,
+ * and the entrance animation would re-run on every reopen — which someone
+ * working through an inbox does repeatedly. The fetch happens once.
+ *
+ * The initial state reads `open` rather than starting at `false`, so a host that
+ * mounts the panel already open renders it in the same commit instead of a frame
+ * later.
+ *
+ * ## Why `null` for the fallback
+ *
+ * The only frame this can show anything is the one right after the tap, where a
+ * spinner reads as a stall rather than as progress. The chunk is small and
+ * same-origin.
+ */
+import { Suspense, lazy, useEffect, useState, type ComponentType, type JSX } from 'react';
+
+import type { NotificationMessages } from '../messages';
+
+import type { InboxStore } from './inbox-state';
+import type { NotificationsPanelProps } from './panel';
+
+/** What the factory binds into the panel, and the host never passes. */
+interface PanelParts {
+  store: InboxStore;
+  messages: NotificationMessages;
+}
+
+export function lazyNotificationsPanel(
+  parts: PanelParts,
+): ComponentType<NotificationsPanelProps> {
+  const Bound = lazy(async () => {
+    const { NotificationsPanel } = await import('./panel');
+    return {
+      default: (props: NotificationsPanelProps): JSX.Element => (
+        <NotificationsPanel {...props} {...parts} />
+      ),
+    };
+  });
+
+  return function NotificationsPanelSlot(props: NotificationsPanelProps): JSX.Element | null {
+    const [everOpened, setEverOpened] = useState(props.open);
+
+    useEffect(() => {
+      if (props.open) setEverOpened(true);
+    }, [props.open]);
+
+    if (!everOpened) return null;
+
+    return (
+      <Suspense fallback={null}>
+        <Bound {...props} />
+      </Suspense>
+    );
+  };
+}

package/src/server/context.ts

@@ -32,6 +32,16 @@ export interface NotificationsRequest {
   body?: unknown;
   /** Headers the surface reads (`user-agent`, for the device hint). */
   headers?: Record<string, string | undefined>;
+  /**
+   * The language to answer this caller in, as a language tag (`pt-BR`,
+   * `en-US`) — the same field `@12-apps/wiring`'s `WireRequest` carries.
+   *
+   * Populated by the host's adapter, which is the only layer that can
+   * negotiate one. Absent is meaningful and not an error: a host with one
+   * audience never sets it, and this surface must then answer with the words
+   * it was configured with rather than invent a language.
+   */
+  locale?: string;
 }
 
 /** What a handler answers with; the adapter maps it onto its response type. */

package/src/server/create-api-notifications.ts

@@ -1,5 +1,8 @@
 import { createGeneratorRegistry, type NotificationGeneratorRegistry } from '../generators';
-import { messagesOf, type NotificationWireMessages } from '../messages';
+import type {
+  NotificationsCopySource,
+  NotificationWireMessages,
+} from '../messages';
 import type { ChannelRow } from '../preferences-core';
 import {
   taxonomyOf,
@@ -104,8 +107,15 @@ export interface NotificationsServerConfig {
   onInboxChanged?: (userId: string) => void;
   /** The host's authorization engine, for `notifyByPermission`. */
   audience?: NotificationAudienceDirectory;
-  /** User-facing copy overrides (pt-BR product copy by default). */
-  messages: NotificationWireMessages;
+  /**
+   * Every user-facing sentence this surface can produce — REQUIRED host config.
+   *
+   * A pack, or a RESOLVER for a host whose callers do not share a language.
+   * Passed to the routes UNRESOLVED: this factory runs once per process (and
+   * at least one host memoises its call), so resolving here would answer every
+   * later request in the language the process started with.
+   */
+  messages: NotificationsCopySource<NotificationWireMessages>;
   /** The host's logger. Defaults to the console. */
   logger?: NotificationLogger;
 }
@@ -132,8 +142,14 @@ export interface ApiNotifications {
   registerGenerator: NotificationGeneratorRegistry['register'];
   /** The declared transports, for diagnostics and availability probes. */
   transports: TransportRegistry;
-  /** The copy in force, so a host's own screens can reuse a sentence. */
-  messages: NotificationWireMessages;
+  /**
+   * The copy source in force, so a host's own screens can reuse a sentence.
+   *
+   * The SOURCE rather than a resolved pack, for the same reason the routes get
+   * one: a host screen serving two readers must be able to ask per reader.
+   * Read it with `messagesOf({ messages }, locale)`.
+   */
+  messages: NotificationsCopySource<NotificationWireMessages>;
 }
 
 /** Drop the keys the host left unset, so an absent seam stays absent. */
@@ -150,7 +166,15 @@ const consoleLogger: NotificationLogger = {
 };
 
 export function createApiNotifications(config: NotificationsServerConfig): ApiNotifications {
-  const messages = messagesOf(config);
+  /**
+   * The SOURCE travels; nothing is resolved here.
+   *
+   * This factory runs once per process — and at least one host memoises its
+   * call behind an `if (assembled) return assembled;` — so a `messagesOf(config)`
+   * on this line would word every later request in the language the process
+   * started with. The handlers resolve per request instead.
+   */
+  const messages = config.messages;
   const taxonomy = taxonomyOf(config);
   const logger = config.logger ?? consoleLogger;
 

package/src/server/routes.ts

@@ -1,4 +1,8 @@
-import type { NotificationWireMessages } from '../messages';
+import {
+  messagesOf,
+  type NotificationsCopySource,
+  type NotificationWireMessages,
+} from '../messages';
 import { NOTIFICATION_CHANNELS, type NotificationChannel } from '../types';
 
 import {
@@ -40,7 +44,11 @@ interface NotificationRoutesDeps {
   transports: TransportRegistry;
   contacts: NotificationContactDirectory;
   categories: readonly string[];
-  messages: NotificationWireMessages;
+  /**
+   * The SOURCE, not a resolved pack — the route table is built once per
+   * process and every handler below runs per request.
+   */
+  messages: NotificationsCopySource<NotificationWireMessages>;
   /** Told when a write actually changed something (for a realtime hint). */
   onInboxChanged?: (userId: string) => void;
 }
@@ -98,8 +106,13 @@ function inboxRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
     {
       method: 'GET',
       path: '/notifications',
-      handle: guarded(async ({ actor, query }) =>
-        ok(await deps.inbox.list(actor.userId, parseListQuery(query, deps.messages))),
+      handle: guarded(async ({ actor, query, locale }) =>
+        ok(
+          await deps.inbox.list(
+            actor.userId,
+            parseListQuery(query, messagesOf(deps, locale)),
+          ),
+        ),
       ),
     },
     {
@@ -113,8 +126,8 @@ function inboxRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
     {
       method: 'POST',
       path: '/notifications/mark-read',
-      handle: guarded(async ({ actor, body }) => {
-        const target = parseMarkReadBody(body, deps.messages);
+      handle: guarded(async ({ actor, body, locale }) => {
+        const target = parseMarkReadBody(body, messagesOf(deps, locale));
         const updated =
           'all' in target
             ? await deps.inbox.markAllRead(actor.userId)
@@ -131,10 +144,10 @@ function inboxRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
       method: 'POST',
       // POST, not DELETE, because the ids travel in a JSON body.
       path: '/notifications/delete',
-      handle: guarded(async ({ actor, body }) => {
+      handle: guarded(async ({ actor, body, locale }) => {
         const deleted = await deps.inbox.softDelete(
           actor.userId,
-          parseDeleteBody(body, deps.messages),
+          parseDeleteBody(body, messagesOf(deps, locale)),
         );
         // Same rule as mark-read. A delete can move the badge too — an UNREAD
         // row that is removed takes its place in the count with it.
@@ -155,10 +168,13 @@ function preferenceRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
     {
       method: 'PUT',
       path: '/notification-preferences',
-      handle: guarded(async ({ actor, body }) => {
+      handle: guarded(async ({ actor, body, locale }) => {
         // The dispatch pipeline reads these on every emit, so a save takes
         // effect immediately — no cache to invalidate.
-        await deps.preferences.save(actor.userId, parsePreferencesBody(body, deps.messages));
+        await deps.preferences.save(
+          actor.userId,
+          parsePreferencesBody(body, messagesOf(deps, locale)),
+        );
         return ok(await preferencesPayload(deps, actor.userId));
       }),
     },
@@ -170,8 +186,8 @@ function pushRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
     {
       method: 'GET',
       path: '/push-subscriptions',
-      handle: guarded(async ({ actor, query }) => {
-        const endpoint = parsePushEndpointQuery(query, deps.messages);
+      handle: guarded(async ({ actor, query, locale }) => {
+        const endpoint = parsePushEndpointQuery(query, messagesOf(deps, locale));
         return ok({
           // null = web push is not configured on this deployment.
           vapidPublicKey: deps.transports.webPushPublicKey(),
@@ -188,8 +204,8 @@ function pushRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
     {
       method: 'POST',
       path: '/push-subscriptions',
-      handle: guarded(async ({ actor, body, headers }) => {
-        const input = parsePushSubscriptionBody(body, deps.messages);
+      handle: guarded(async ({ actor, body, headers, locale }) => {
+        const input = parsePushSubscriptionBody(body, messagesOf(deps, locale));
         const userAgent = headers?.['user-agent'];
         await deps.pushSubscriptions.save(actor.userId, {
           ...input,
@@ -202,10 +218,10 @@ function pushRoutes(deps: NotificationRoutesDeps): NotificationsRoute[] {
       method: 'DELETE',
       // The endpoint is a long opaque URL, unusable as a path param.
       path: '/push-subscriptions',
-      handle: guarded(async ({ actor, body }) => {
+      handle: guarded(async ({ actor, body, locale }) => {
         await deps.pushSubscriptions.remove(
           actor.userId,
-          parsePushEndpointBody(body, deps.messages),
+          parsePushEndpointBody(body, messagesOf(deps, locale)),
         );
         return ok({ count: await deps.pushSubscriptions.count(actor.userId) });
       }),

package/dist/chunk-4TTYQVPK.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/types.ts","../src/messages.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 */\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  generate: (payload: TPayload) => 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  /** 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","/**\n * Every sentence this package can say to a USER, stated by the HOST.\n *\n * The copy lives in ONE table rather than in each screen so the api half and\n * the react half can never disagree about a sentence — the 401 body the wire\n * returns and the error the panel renders come from the same key.\n *\n * THE pt-BR TABLE THAT USED TO BE THE DEFAULT IS GONE. Its own docstring said\n * what it was: \"the product copy the surface shipped with\", labelled in the\n * source as one named application's \"exact copy\". A description of one adopter,\n * shipped inside the package every other adopter installs, and reached by\n * saying nothing.\n *\n * `categoryLabels` is the sharpest of the forty. The categories themselves\n * became required config in the release before this one, precisely because\n * WHICH categories exist is product vocabulary — and their LABELS kept\n * defaulting, so a host that declared `['loans', 'fines']` got a labels map\n * describing somebody else's four. Required categories with defaulted labels\n * for a different host's categories is not a smaller version of the bug; it is\n * the same bug with a compile-time gesture in front of it.\n *\n * So `messages` is REQUIRED and whole. The interface is the checklist, and the\n * compiler names the sentences a host has not written yet.\n */\n/**\n * The sentences the SERVER half renders — and the whole of what a backend mount\n * has to state.\n *\n * Split out when `messages` became required. Requiring the full forty on a\n * server config would have made a backend-only adopter write three dozen\n * sentences for screens it does not serve, which is the kind of tax that gets a\n * required-config migration reverted rather than adopted. These four are the\n * ones the router and the route descriptors actually put on a wire.\n */\nexport interface NotificationWireMessages {\n  unauthenticated: string;\n  invalidBody: string;\n  operationFailed: string;\n  /** `POST /notifications/mark-read` with neither `ids` nor `all`. */\n  markReadTargetRequired: string;\n}\n\n/** Every sentence, wire and screen — what the REACT half needs. */\nexport interface NotificationMessages extends NotificationWireMessages {\n  // --- the inbox panel -----------------------------------------------------\n  panelTitle: string;\n  markAllRead: string;\n  loading: string;\n  loadMore: string;\n  loadingMore: string;\n  loadFailedTitle: string;\n  loadFailedBody: string;\n  retry: string;\n  emptyTitle: string;\n  emptyBody: string;\n  openBell: string;\n  /** `(count) => 'Abrir notificações (3 não lidas)'`. */\n  openBellWithUnread: (count: number) => string;\n  unreadSuffix: string;\n  deleteOne: (title: string) => string;\n\n  // --- relative timestamps -------------------------------------------------\n  justNow: string;\n  minutesAgo: (minutes: number) => string;\n  hoursAgo: (hours: number) => string;\n  daysAgo: (days: number) => string;\n  /** Locale for the fallback absolute date on rows older than a week. */\n  dateLocale: string;\n\n  // --- the preferences screen ---------------------------------------------\n  preferencesTitle: string;\n  preferencesLead: string;\n  channelLabels: Record<string, string>;\n  channelUnavailableHints: Record<string, string>;\n  categoryLabels: Record<string, { title: string; description: string }>;\n  /** Fallback title for a category the host added but did not label. */\n  categoryFallbackTitle: (category: string) => string;\n  devicePushTitle: string;\n  devicePushIdle: string;\n  devicePushOn: string;\n  devicePushDenied: string;\n  devicePushFailed: string;\n  devicePushEnable: string;\n  devicePushEnabling: string;\n}\n\n/**\n * The messages in force.\n *\n * A pass-through rather than a merge: there is nothing left to merge WITH, and\n * that is the point of the change. The old version spread the host's table over\n * the origin's, including PER KEY inside `channelLabels`,\n * `channelUnavailableHints` and `categoryLabels` — so a host that relabelled one\n * channel kept the origin's wording for the other three, and a host that\n * labelled its own two categories kept the origin's four sitting beside them in\n * the same screen.\n *\n * Kept as a function because all three mounts read it off a config object, and\n * because a later rule (a blank-string refusal, say) belongs in one place.\n */\nexport function messagesOf<T extends NotificationWireMessages>(config: { messages: T }): T {\n  return config.messages;\n}\n"],"mappings":";;;;;AAgBO,IAAM,wBAAwB,CAAC,SAAS,OAAO,YAAY,UAAU;AA4IrE,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;;;ACxDT,SAAS,WAA+C,QAA4B;AACzF,SAAO,OAAO;AAChB;AAFgB;","names":[]}