@micha.bigler/ui-core-micha 2.14.0 → 2.16.0

package/dist/components/charts/formatters.js

@@ -0,0 +1,23 @@
+import { useTranslation } from 'react-i18next';
+export function formatPercentage(value, locale, options = {}) {
+    return new Intl.NumberFormat(locale, Object.assign({ style: 'percent', maximumFractionDigits: 1 }, options)).format(value);
+}
+export function formatCompact(value, locale, options = {}) {
+    return new Intl.NumberFormat(locale, Object.assign({ notation: 'compact', maximumFractionDigits: 1 }, options)).format(value);
+}
+export function formatRatio(value, locale, options = {}) {
+    return new Intl.NumberFormat(locale, Object.assign({ maximumFractionDigits: 2 }, options)).format(value);
+}
+/** Creates locale-aware formatter functions for use in chart axes and tooltips. */
+export function createChartFormatters(locale) {
+    return {
+        percentage: (value, options) => formatPercentage(value, locale, options),
+        compact: (value, options) => formatCompact(value, locale, options),
+        ratio: (value, options) => formatRatio(value, locale, options),
+    };
+}
+/** Resolves formatter locale from the active react-i18next instance. */
+export function useChartFormatters() {
+    const { i18n } = useTranslation();
+    return createChartFormatters(i18n.language);
+}

package/dist/components/charts/palette.js

@@ -0,0 +1,21 @@
+import { useTheme } from '@mui/material/styles';
+/**
+ * Returns neutral chart colours derived only from the active MUI theme.
+ * Consumers may replace either array with their own domain palette.
+ */
+export function getNeutralChartPalette(theme) {
+    const palette = theme.palette;
+    const isDark = palette.mode === 'dark';
+    return {
+        categorical: isDark
+            ? [palette.primary.light, palette.secondary.light, palette.info.light, palette.success.light, palette.warning.light]
+            : [palette.primary.main, palette.secondary.main, palette.info.main, palette.success.main, palette.warning.main],
+        sequential: isDark
+            ? [palette.action.disabled, palette.text.secondary, palette.primary.light, palette.primary.main, palette.primary.dark]
+            : [palette.action.disabled, palette.divider, palette.text.secondary, palette.primary.light, palette.primary.main],
+    };
+}
+/** Resolves the kit's neutral palette from the nearest MUI ThemeProvider. */
+export function useNeutralChartPalette() {
+    return getNeutralChartPalette(useTheme());
+}

package/dist/i18n/chartsTranslations.js

@@ -0,0 +1,38 @@
+export const chartsTranslations = {
+    'ChartFrame.LOADING': {
+        de: 'Diagramm wird geladen.',
+        fr: 'Chargement du graphique.',
+        en: 'Loading chart.',
+        sw: 'Inapakia chati.',
+    },
+    'ChartFrame.EMPTY_DEFAULT': {
+        de: 'Keine Daten verfügbar.',
+        fr: 'Aucune donnée disponible.',
+        en: 'No data available.',
+        sw: 'Hakuna data inayopatikana.',
+    },
+    'ChartFrame.ERROR_DEFAULT': {
+        de: 'Das Diagramm konnte nicht geladen werden.',
+        fr: 'Impossible de charger le graphique.',
+        en: 'The chart could not be loaded.',
+        sw: 'Chati haikuweza kupakiwa.',
+    },
+    'ChartFrame.EXPORT_SVG_LABEL': {
+        de: 'SVG exportieren',
+        fr: 'Exporter en SVG',
+        en: 'Export SVG',
+        sw: 'Hamisha SVG',
+    },
+    'ChartFrame.EXPORT_PNG_LABEL': {
+        de: 'PNG exportieren',
+        fr: 'Exporter en PNG',
+        en: 'Export PNG',
+        sw: 'Hamisha PNG',
+    },
+    'ChartFrame.EXPORT_ERROR': {
+        de: 'Das Diagramm konnte nicht exportiert werden.',
+        fr: 'Impossible d’exporter le graphique.',
+        en: 'The chart could not be exported.',
+        sw: 'Chati haikuweza kuhamishwa.',
+    },
+};

package/dist/i18n/messagingTranslations.js

@@ -0,0 +1,81 @@
+export const messagingTranslations = {
+    'MessagingList.LABEL': { de: 'Unterhaltungen', en: 'Conversations', fr: 'Conversations' },
+    'MessagingList.EMPTY': { de: 'Noch keine Unterhaltungen.', en: 'No conversations yet.', fr: 'Aucune conversation pour le moment.' },
+    'MessagingList.NO_MESSAGES': { de: 'Noch keine Nachrichten', en: 'No messages yet', fr: 'Aucun message pour le moment' },
+    'MessagingList.UNTITLED': { de: 'Unbenannte Unterhaltung', en: 'Untitled conversation', fr: 'Conversation sans titre' },
+    'MessagingList.ACTIONS': { de: 'Aktionen für Unterhaltung', en: 'Conversation actions', fr: 'Actions de la conversation' },
+    'MessagingList.LOAD_MORE': { de: 'Mehr laden', en: 'Load more', fr: 'Charger plus' },
+    'MessagingList.LOAD_ERROR': { de: 'Unterhaltungen konnten nicht geladen werden.', en: 'Conversations could not be loaded.', fr: 'Impossible de charger les conversations.' },
+    'MessagingList.ARCHIVE': { de: 'Archivieren', en: 'Archive', fr: 'Archiver' },
+    'MessagingList.ARCHIVE_ERROR': { de: 'Unterhaltung konnte nicht archiviert werden.', en: 'Conversation could not be archived.', fr: 'Impossible d’archiver la conversation.' },
+    'MessagingList.MUTE': { de: 'Stummschalten', en: 'Mute', fr: 'Mettre en sourdine' },
+    'MessagingList.UNMUTE': { de: 'Stummschaltung aufheben', en: 'Unmute', fr: 'Réactiver le son' },
+    'MessagingList.PREFERENCES_ERROR': { de: 'Einstellungen konnten nicht gespeichert werden.', en: 'Preferences could not be saved.', fr: 'Impossible d’enregistrer les préférences.' },
+    'MessagingLaunchers.OPEN_GROUP': { de: 'Gruppenunterhaltung öffnen', en: 'Open group conversation', fr: 'Ouvrir la conversation de groupe' },
+    'MessagingLaunchers.OPEN_BROADCAST': { de: 'Ankündigungen öffnen', en: 'Open announcements', fr: 'Ouvrir les annonces' },
+    'MessagingLaunchers.OPEN_ERROR': { de: 'Unterhaltung konnte nicht geöffnet werden.', en: 'Conversation could not be opened.', fr: 'Impossible d’ouvrir la conversation.' },
+    'MessagingThread.TIMELINE': { de: 'Nachrichtenverlauf', en: 'Message timeline', fr: 'Chronologie des messages' },
+    'MessagingThread.MESSAGE': { de: 'Nachricht', en: 'Message', fr: 'Message' },
+    'MessagingThread.EMPTY': { de: 'Noch keine Nachrichten.', en: 'No messages yet.', fr: 'Aucun message pour le moment.' },
+    'MessagingThread.LOAD_OLDER': { de: 'Ältere Nachrichten laden', en: 'Load older messages', fr: 'Charger les messages plus anciens' },
+    'MessagingThread.LOAD_ERROR': { de: 'Nachrichten konnten nicht geladen werden.', en: 'Messages could not be loaded.', fr: 'Impossible de charger les messages.' },
+    'MessagingThread.REPLIES_ERROR': { de: 'Antworten konnten nicht geladen werden.', en: 'Replies could not be loaded.', fr: 'Impossible de charger les réponses.' },
+    'MessagingThread.DELETED': { de: 'Diese Nachricht wurde gelöscht.', en: 'This message was deleted.', fr: 'Ce message a été supprimé.' },
+    'MessagingThread.EDITED': { de: 'bearbeitet', en: 'edited', fr: 'modifié' },
+    'MessagingThread.REPLY': { de: 'Antworten', en: 'Reply', fr: 'Répondre' },
+    'MessagingThread.REPLY_TO': { de: 'Antwort auf {{sender}}', en: 'Reply to {{sender}}', fr: 'Réponse à {{sender}}' },
+    'MessagingThread.REPLYING_TO': { de: 'Antwort an {{sender}}', en: 'Replying to {{sender}}', fr: 'Réponse à {{sender}}' },
+    'MessagingThread.SHOW_REPLIES': { de: '{{count}} Antworten anzeigen', en: 'Show {{count}} replies', fr: 'Afficher {{count}} réponses' },
+    'MessagingThread.HIDE_REPLIES': { de: 'Antworten ausblenden', en: 'Hide replies', fr: 'Masquer les réponses' },
+    'MessagingThread.UNKNOWN_SENDER': { de: 'Unbekannte Person', en: 'Unknown person', fr: 'Personne inconnue' },
+    'MessagingReadTicks.ALL_READ': { de: 'Von allen gelesen', en: 'Read by everyone', fr: 'Lu par tout le monde' },
+    'MessagingReadTicks.DELIVERED': { de: 'Zugestellt an {{count}}', en: 'Delivered to {{count}}', fr: 'Distribué à {{count}}' },
+    'MessagingComposer.LABEL': { de: 'Nachricht verfassen', en: 'Compose message', fr: 'Rédiger un message' },
+    'MessagingComposer.MESSAGE': { de: 'Nachricht', en: 'Message', fr: 'Message' },
+    'MessagingComposer.SEND': { de: 'Senden', en: 'Send', fr: 'Envoyer' },
+    'MessagingComposer.RETRY': { de: 'Erneut versuchen', en: 'Retry', fr: 'Réessayer' },
+    'MessagingComposer.ADD_ATTACHMENT': { de: 'Anhang hinzufügen', en: 'Add attachment', fr: 'Ajouter une pièce jointe' },
+    'MessagingComposer.FILES_SELECTED': { de: '{{count}} Anhänge ausgewählt', en: '{{count}} attachments selected', fr: '{{count}} pièces jointes sélectionnées' },
+    'MessagingComposer.REPLYING_TO': { de: 'Antwort an {{sender}}', en: 'Replying to {{sender}}', fr: 'Réponse à {{sender}}' },
+    'MessagingComposer.SEND_ERROR': { de: 'Nachricht konnte nicht gesendet werden: {{message}}', en: 'Message could not be sent: {{message}}', fr: 'Impossible d’envoyer le message : {{message}}' },
+    'MessagingComposer.UPLOAD_ERROR': { de: 'Anhang wurde abgelehnt: {{message}}', en: 'Attachment was rejected: {{message}}', fr: 'La pièce jointe a été rejetée : {{message}}' },
+    'MessagingAttachments.LABEL': { de: 'Anhänge', en: 'Attachments', fr: 'Pièces jointes' },
+    'MessagingAttachments.DOWNLOAD': { de: '{{name}} herunterladen', en: 'Download {{name}}', fr: 'Télécharger {{name}}' },
+    'MessagingReactions.LABEL': { de: 'Reaktionen', en: 'Reactions', fr: 'Réactions' },
+    'MessagingReactions.ADD': { de: 'Reaktion hinzufügen', en: 'Add reaction', fr: 'Ajouter une réaction' },
+    'MessagingReactions.TOGGLE': { de: '{{emoji}} Reaktion mit {{count}} Stimmen umschalten', en: 'Toggle {{emoji}} reaction with {{count}} votes', fr: 'Basculer la réaction {{emoji}} avec {{count}} votes' },
+    'MessagingReactions.ERROR': { de: 'Reaktion konnte nicht gespeichert werden: {{message}}', en: 'Reaction could not be saved: {{message}}', fr: 'Impossible d’enregistrer la réaction : {{message}}' },
+    'MessagingPoll.LABEL': { de: 'Umfrage', en: 'Poll', fr: 'Sondage' },
+    'MessagingPoll.VOTE': { de: 'Abstimmen', en: 'Vote', fr: 'Voter' },
+    'MessagingPoll.CLOSE': { de: 'Umfrage schliessen', en: 'Close poll', fr: 'Clore le sondage' },
+    'MessagingPoll.CLOSED': { de: 'Geschlossen', en: 'Closed', fr: 'Clos' },
+    'MessagingPoll.SELECT_OPTION': { de: 'Wähle mindestens eine Option.', en: 'Select at least one option.', fr: 'Sélectionnez au moins une option.' },
+    'MessagingPoll.VOTE_ERROR': { de: 'Stimme konnte nicht gespeichert werden: {{message}}', en: 'Vote could not be saved: {{message}}', fr: 'Impossible d’enregistrer le vote : {{message}}' },
+    'MessagingPoll.CLOSE_ERROR': { de: 'Umfrage konnte nicht geschlossen werden: {{message}}', en: 'Poll could not be closed: {{message}}', fr: 'Impossible de clore le sondage : {{message}}' },
+    'MessagingPoll.CREATE': { de: 'Umfrage erstellen', en: 'Create poll', fr: 'Créer un sondage' },
+    'MessagingPoll.CREATE_ERROR': { de: 'Umfrage konnte nicht erstellt werden: {{message}}', en: 'Poll could not be created: {{message}}', fr: 'Impossible de créer le sondage : {{message}}' },
+    'MessagingPoll.CREATE_VALIDATION': { de: 'Frage und mindestens zwei Optionen sind erforderlich.', en: 'A question and at least two options are required.', fr: 'Une question et au moins deux options sont requises.' },
+    'MessagingPoll.QUESTION': { de: 'Frage', en: 'Question', fr: 'Question' },
+    'MessagingPoll.OPTION': { de: 'Option {{count}}', en: 'Option {{count}}', fr: 'Option {{count}}' },
+    'MessagingPoll.ADD_OPTION': { de: 'Option hinzufügen', en: 'Add option', fr: 'Ajouter une option' },
+    'MessagingPoll.ALLOW_MULTIPLE': { de: 'Mehrfachauswahl erlauben', en: 'Allow multiple choices', fr: 'Autoriser plusieurs choix' },
+    'MessagingPoll.CANCEL': { de: 'Abbrechen', en: 'Cancel', fr: 'Annuler' },
+    'MessagingConfig.LABEL': { de: 'Nachrichten-Einstellungen', en: 'Messaging settings', fr: 'Paramètres de messagerie' },
+    'MessagingConfig.TITLE': { de: 'Nachrichten-Einstellungen', en: 'Messaging settings', fr: 'Paramètres de messagerie' },
+    'MessagingConfig.LOADING': { de: 'Einstellungen werden geladen…', en: 'Loading settings…', fr: 'Chargement des paramètres…' },
+    'MessagingConfig.LOAD_ERROR': { de: 'Einstellungen konnten nicht geladen werden: {{message}}', en: 'Settings could not be loaded: {{message}}', fr: 'Impossible de charger les paramètres : {{message}}' },
+    'MessagingConfig.SAVE_ERROR': { de: 'Einstellungen konnten nicht gespeichert werden: {{message}}', en: 'Settings could not be saved: {{message}}', fr: 'Impossible d’enregistrer les paramètres : {{message}}' },
+    'MessagingConfig.DM_POLICY': { de: 'Direktnachrichten-Regel', en: 'Direct-message policy', fr: 'Règle des messages directs' },
+    'MessagingConfig.DM_ALL': { de: 'Alle', en: 'Everyone', fr: 'Tout le monde' },
+    'MessagingConfig.DM_SHARED': { de: 'Nur gemeinsame Gruppen', en: 'Shared groups only', fr: 'Groupes communs uniquement' },
+    'MessagingConfig.DM_TEAM': { de: 'Nur Team', en: 'Team only', fr: 'Équipe uniquement' },
+    'MessagingConfig.GROUP_ENABLED': { de: 'Gruppenchat aktivieren', en: 'Enable group chat', fr: 'Activer le chat de groupe' },
+    'MessagingConfig.EVERYONE_POSTS': { de: 'Alle dürfen schreiben', en: 'Everyone can post', fr: 'Tout le monde peut publier' },
+    'MessagingAnnouncement.CREATE': { de: 'Ankündigung erstellen', en: 'Create announcement', fr: 'Créer une annonce' },
+    'MessagingAnnouncement.TITLE': { de: 'Titel', en: 'Title', fr: 'Titre' },
+    'MessagingAnnouncement.BODY': { de: 'Text', en: 'Body', fr: 'Texte' },
+    'MessagingAnnouncement.SEND': { de: 'Ankündigung senden', en: 'Send announcement', fr: 'Envoyer l’annonce' },
+    'MessagingAnnouncement.CANCEL': { de: 'Abbrechen', en: 'Cancel', fr: 'Annuler' },
+    'MessagingAnnouncement.VALIDATION': { de: 'Ein Titel ist erforderlich.', en: 'A title is required.', fr: 'Un titre est requis.' },
+    'MessagingAnnouncement.ERROR': { de: 'Ankündigung konnte nicht gesendet werden: {{message}}', en: 'Announcement could not be sent: {{message}}', fr: 'Impossible d’envoyer l’annonce : {{message}}' },
+};

package/dist/index.js

@@ -27,9 +27,15 @@ export { RegistrationMethodsManager } from './components/RegistrationMethodsMana
 export { AuthFactorRequirementCard } from './components/AuthFactorRequirementCard';
 export { AccessCodeSingleUseToggle } from './components/AccessCodeSingleUseToggle';
 export { QrSignupManager } from './components/QrSignupManager';
-// --- 6. Translations ---
+// --- 6. Charts ---
+export { ChartFrame } from './components/charts/ChartFrame';
+export { BarChart } from './components/charts/BarChart';
+export { LineChart } from './components/charts/LineChart';
+export { getNeutralChartPalette, useNeutralChartPalette } from './components/charts/palette';
+export { formatPercentage, formatCompact, formatRatio, createChartFormatters, useChartFormatters, } from './components/charts/formatters';
+// --- 7. Translations ---
 export { authTranslations } from './i18n/authTranslations';
-// --- 7. Notifications ---
+// --- 8. Notifications ---
 export { NotificationSettings } from './notifications/NotificationSettings';
 export * from './notifications/api';
 export { NotificationsProvider, useNotifications } from './notifications/NotificationsProvider';
@@ -37,7 +43,20 @@ export { useRealtime } from './notifications/realtime';
 export { NotificationBell } from './notifications/NotificationBell';
 export { PopupSurface } from './notifications/PopupSurface';
 export { getNotificationFeed, getUnreadCount, markNotifications } from './notifications/feedApi';
-// --- 8. Onboarding ---
+// --- 9. Messaging ---
+export * from './messaging/api';
+export { MessagingProvider, useMessaging } from './messaging/MessagingProvider';
+export { ConversationList } from './messaging/ConversationList';
+export { ConversationLaunchers } from './messaging/ConversationLaunchers';
+export { Thread } from './messaging/Thread';
+export { MessageBubble } from './messaging/MessageBubble';
+export { ReadTicks } from './messaging/ReadTicks';
+export { Composer } from './messaging/Composer';
+export { AttachmentList } from './messaging/AttachmentList';
+export { ReactionBar } from './messaging/ReactionBar';
+export { PollCard } from './messaging/PollCard';
+export { MessagingScopeConfig } from './messaging/MessagingScopeConfig';
+// --- 9. Onboarding ---
 export * from './onboarding/api';
 export { selectActiveSteps } from './onboarding/stepSelection';
 export { OnboardingContext, OnboardingProvider, UNIVERSAL_STEP_DESCRIPTORS, useOnboarding, } from './onboarding/OnboardingProvider';
@@ -46,6 +65,8 @@ export { CookieConsentStep } from './onboarding/steps/CookieConsentStep';
 export { CompleteNameStep } from './onboarding/steps/CompleteNameStep';
 export { BrowserPushStep } from './onboarding/steps/BrowserPushStep';
 export { PwaInstallStep } from './onboarding/steps/PwaInstallStep';
-// --- 9. Translations ---
+// --- 10. Translations ---
 export { notificationsTranslations } from './i18n/notificationsTranslations';
 export { onboardingTranslations } from './i18n/onboardingTranslations';
+export { chartsTranslations } from './i18n/chartsTranslations';
+export { messagingTranslations } from './i18n/messagingTranslations';

package/dist/messaging/AttachmentList.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Button, Stack } from '@mui/material';
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useMessaging } from './MessagingProvider';
+function isImage(attachment) { var _a; return (_a = attachment.content_type) === null || _a === void 0 ? void 0 : _a.startsWith('image/'); }
+function nameOf(attachment) { return attachment.filename || attachment.name || attachment.id; }
+/** Download-only attachment renderer; all bytes remain behind the authenticated REST endpoints. */
+export function AttachmentList({ attachments = [] }) {
+    const { t } = useTranslation();
+    const { getAttachment, getAttachmentThumbnail } = useMessaging();
+    const [previews, setPreviews] = useState({});
+    useEffect(() => {
+        let live = true;
+        const urls = [];
+        attachments.filter(isImage).forEach(async (attachment) => {
+            try {
+                const blob = await getAttachmentThumbnail(attachment.id);
+                const url = blob instanceof Blob ? URL.createObjectURL(blob) : blob === null || blob === void 0 ? void 0 : blob.url;
+                if (url && live) {
+                    urls.push(url);
+                    setPreviews((current) => (Object.assign(Object.assign({}, current), { [attachment.id]: url })));
+                }
+            }
+            catch ( /* The image remains available through the download action. */_a) { /* The image remains available through the download action. */ }
+        });
+        return () => { live = false; urls.forEach((url) => URL.revokeObjectURL(url)); };
+    }, [attachments, getAttachmentThumbnail]);
+    if (!attachments.length)
+        return null;
+    const download = async (attachment) => {
+        const blob = await getAttachment(attachment.id);
+        if (!(blob instanceof Blob))
+            return;
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = nameOf(attachment);
+        link.click();
+        URL.revokeObjectURL(url);
+    };
+    return _jsx(Stack, { direction: "row", spacing: 1, flexWrap: "wrap", "aria-label": t('MessagingAttachments.LABEL'), children: attachments.map((attachment) => _jsxs(Button, { type: "button", size: "small", onClick: () => download(attachment), children: [previews[attachment.id] && _jsx(Box, { component: "img", src: previews[attachment.id], alt: "", width: 36, height: 36, sx: { objectFit: 'cover', mr: 0.75 } }), t('MessagingAttachments.DOWNLOAD', { name: nameOf(attachment) })] }, attachment.id)) });
+}

package/dist/messaging/Composer.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Button, Checkbox, Dialog, DialogActions, DialogContent, DialogTitle, FormControlLabel, IconButton, Stack, TextField, Typography } from '@mui/material';
+import AttachFileIcon from '@mui/icons-material/AttachFile';
+import CampaignOutlinedIcon from '@mui/icons-material/CampaignOutlined';
+import PollOutlinedIcon from '@mui/icons-material/PollOutlined';
+import { useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { extractApiErrorMessage, useMessaging } from './MessagingProvider';
+function newRequestId() { var _a, _b; return ((_b = (_a = globalThis.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === null || _b === void 0 ? void 0 : _b.call(_a)) || `message-${Date.now()}-${Math.random().toString(36).slice(2)}`; }
+/**
+ * A provider-backed, independently mountable REST composer.
+ *
+ * `allowAnnouncement` and `linkTarget`: whether announcement composing (jg's
+ * `AnnouncementDialog` — title + body + a deep-link target) is offered here at
+ * all is a host decision (the server enforces who may actually post one; the
+ * client only offers the affordance). `linkTarget`'s VALUE is inherently
+ * app-specific navigation context (jg pre-fills it from the currently open
+ * event-info section) that ucm cannot compute itself, so the host supplies it.
+ */
+export function Composer({ conversationId, replyTarget = null, onReplyTargetChange, allowAnnouncement = false, linkTarget }) {
+    var _a;
+    const { t } = useTranslation();
+    const { sendMessage, sendAttachments, createConversationPoll } = useMessaging();
+    const [body, setBody] = useState('');
+    const [files, setFiles] = useState([]);
+    const [error, setError] = useState(null);
+    const [failed, setFailed] = useState(null);
+    const [sending, setSending] = useState(false);
+    const [pollOpen, setPollOpen] = useState(false);
+    const [pollQuestion, setPollQuestion] = useState('');
+    const [pollOptions, setPollOptions] = useState(['', '']);
+    const [allowMultiple, setAllowMultiple] = useState(false);
+    const [announcementOpen, setAnnouncementOpen] = useState(false);
+    const [announcementTitle, setAnnouncementTitle] = useState('');
+    const [announcementBody, setAnnouncementBody] = useState('');
+    const inputRef = useRef(null);
+    const submit = async (requestId = newRequestId(), retry = false) => {
+        if (!body.trim() && !files.length)
+            return;
+        setSending(true);
+        setError(null);
+        const payload = { kind: 'chat', body: body.trim() || undefined, reply_to: (replyTarget === null || replyTarget === void 0 ? void 0 : replyTarget.id) || undefined, client_request_id: requestId };
+        try {
+            if (files.length) {
+                const formData = new FormData();
+                files.forEach((file) => formData.append('files[]', file));
+                if (payload.body)
+                    formData.append('body', payload.body);
+                if (payload.reply_to)
+                    formData.append('reply_to', String(payload.reply_to));
+                formData.append('client_request_id', requestId);
+                await sendAttachments(conversationId, formData, { clientRequestId: requestId, retry, optimisticMessage: { body: payload.body, reply_to: payload.reply_to, attachments: files.map((file, index) => ({ id: `local-${requestId}-${index}`, filename: file.name, content_type: file.type })) } });
+            }
+            else
+                await sendMessage(conversationId, payload, { clientRequestId: requestId, retry });
+            setBody('');
+            setFiles([]);
+            setFailed(null);
+            onReplyTargetChange === null || onReplyTargetChange === void 0 ? void 0 : onReplyTargetChange(null);
+        }
+        catch (sendError) {
+            const message = extractApiErrorMessage(sendError);
+            setError(files.length ? t('MessagingComposer.UPLOAD_ERROR', { message }) : t('MessagingComposer.SEND_ERROR', { message }));
+            setFailed({ requestId, retry: true });
+        }
+        finally {
+            setSending(false);
+        }
+    };
+    const submitPoll = async () => {
+        const options = pollOptions.map((option) => option.trim()).filter(Boolean);
+        if (!pollQuestion.trim() || options.length < 2) {
+            setError(t('MessagingPoll.CREATE_VALIDATION'));
+            return;
+        }
+        setSending(true);
+        setError(null);
+        try {
+            await createConversationPoll(conversationId, { question: pollQuestion.trim(), options, allow_multiple: allowMultiple }, { clientRequestId: newRequestId() });
+            setPollQuestion('');
+            setPollOptions(['', '']);
+            setAllowMultiple(false);
+            setPollOpen(false);
+        }
+        catch (pollError) {
+            setError(t('MessagingPoll.CREATE_ERROR', { message: extractApiErrorMessage(pollError) }));
+        }
+        finally {
+            setSending(false);
+        }
+    };
+    const submitAnnouncement = async () => {
+        if (!announcementTitle.trim()) {
+            setError(t('MessagingAnnouncement.VALIDATION'));
+            return;
+        }
+        setSending(true);
+        setError(null);
+        const requestId = newRequestId();
+        try {
+            await sendMessage(conversationId, {
+                kind: 'announcement',
+                title: announcementTitle.trim(),
+                body: announcementBody.trim() || undefined,
+                link_target: linkTarget || undefined,
+                client_request_id: requestId,
+            }, { clientRequestId: requestId });
+            setAnnouncementTitle('');
+            setAnnouncementBody('');
+            setAnnouncementOpen(false);
+        }
+        catch (announcementError) {
+            setError(t('MessagingAnnouncement.ERROR', { message: extractApiErrorMessage(announcementError) }));
+        }
+        finally {
+            setSending(false);
+        }
+    };
+    return _jsxs(Stack, { component: "form", spacing: 1, onSubmit: (event) => { event.preventDefault(); submit(); }, "aria-label": t('MessagingComposer.LABEL'), children: [replyTarget && _jsx(Alert, { severity: "info", onClose: () => onReplyTargetChange === null || onReplyTargetChange === void 0 ? void 0 : onReplyTargetChange(null), children: t('MessagingComposer.REPLYING_TO', { sender: ((_a = replyTarget.sender) === null || _a === void 0 ? void 0 : _a.display_name) || t('MessagingThread.UNKNOWN_SENDER') }) }), error && _jsx(Alert, { severity: "error", role: "alert", children: error }), files.length > 0 && _jsx(Typography, { variant: "caption", children: t('MessagingComposer.FILES_SELECTED', { count: files.length }) }), _jsxs(Stack, { direction: "row", spacing: 1, alignItems: "flex-end", children: [_jsx("input", { ref: inputRef, hidden: true, type: "file", multiple: true, onChange: (event) => setFiles(Array.from(event.target.files || [])) }), _jsx(IconButton, { type: "button", "aria-label": t('MessagingComposer.ADD_ATTACHMENT'), onClick: () => { var _a; return (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.click(); }, children: _jsx(AttachFileIcon, {}) }), _jsx(IconButton, { type: "button", "aria-label": t('MessagingPoll.CREATE'), onClick: () => setPollOpen(true), children: _jsx(PollOutlinedIcon, {}) }), allowAnnouncement && _jsx(IconButton, { type: "button", "aria-label": t('MessagingAnnouncement.CREATE'), onClick: () => setAnnouncementOpen(true), children: _jsx(CampaignOutlinedIcon, {}) }), _jsx(TextField, { fullWidth: true, multiline: true, minRows: 2, value: body, onChange: (event) => setBody(event.target.value), label: t('MessagingComposer.MESSAGE'), disabled: sending }), _jsx(Button, { type: "submit", variant: "contained", disabled: sending || (!body.trim() && !files.length), children: t('MessagingComposer.SEND') })] }), failed && _jsx(Button, { type: "button", onClick: () => submit(failed.requestId, true), disabled: sending, children: t('MessagingComposer.RETRY') }), _jsxs(Dialog, { open: pollOpen, onClose: () => !sending && setPollOpen(false), fullWidth: true, maxWidth: "sm", children: [_jsx(DialogTitle, { children: t('MessagingPoll.CREATE') }), _jsx(DialogContent, { children: _jsxs(Stack, { spacing: 1, sx: { pt: 1 }, children: [_jsx(TextField, { label: t('MessagingPoll.QUESTION'), value: pollQuestion, onChange: (event) => setPollQuestion(event.target.value), autoFocus: true }), pollOptions.map((option, index) => _jsx(TextField, { label: t('MessagingPoll.OPTION', { count: index + 1 }), value: option, onChange: (event) => setPollOptions((current) => current.map((value, optionIndex) => optionIndex === index ? event.target.value : value)) }, index)), _jsx(Button, { type: "button", onClick: () => setPollOptions((current) => [...current, '']), children: t('MessagingPoll.ADD_OPTION') }), _jsx(FormControlLabel, { control: _jsx(Checkbox, { checked: allowMultiple, onChange: (event) => setAllowMultiple(event.target.checked) }), label: t('MessagingPoll.ALLOW_MULTIPLE') })] }) }), _jsxs(DialogActions, { children: [_jsx(Button, { onClick: () => setPollOpen(false), children: t('MessagingPoll.CANCEL') }), _jsx(Button, { variant: "contained", onClick: submitPoll, disabled: sending, children: t('MessagingPoll.CREATE') })] })] }), allowAnnouncement && _jsxs(Dialog, { open: announcementOpen, onClose: () => !sending && setAnnouncementOpen(false), fullWidth: true, maxWidth: "sm", children: [_jsx(DialogTitle, { children: t('MessagingAnnouncement.CREATE') }), _jsx(DialogContent, { children: _jsxs(Stack, { spacing: 1, sx: { pt: 1 }, children: [_jsx(TextField, { label: t('MessagingAnnouncement.TITLE'), value: announcementTitle, onChange: (event) => setAnnouncementTitle(event.target.value), autoFocus: true }), _jsx(TextField, { label: t('MessagingAnnouncement.BODY'), value: announcementBody, onChange: (event) => setAnnouncementBody(event.target.value), multiline: true, minRows: 2 })] }) }), _jsxs(DialogActions, { children: [_jsx(Button, { onClick: () => setAnnouncementOpen(false), children: t('MessagingAnnouncement.CANCEL') }), _jsx(Button, { variant: "contained", onClick: submitAnnouncement, disabled: sending, children: t('MessagingAnnouncement.SEND') })] })] })] });
+}

package/dist/messaging/ConversationLaunchers.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Alert, Button, Stack } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+import { useMessaging } from './MessagingProvider';
+/**
+ * Host apps provide launchable scopes. This component owns the REST transition
+ * that turns one into a normalized conversation, but deliberately does not
+ * discover groups itself: that is app-specific scope-picker data.
+ */
+export function ConversationLaunchers({ groupLaunchers = [], broadcastLauncher, autoOpenBroadcast = false, onOpen }) {
+    const { t } = useTranslation();
+    const { openGroupConversation, openBroadcastConversation } = useMessaging();
+    const [error, setError] = useState(null);
+    const autoOpened = useRef(false);
+    const open = async (kind, payload) => {
+        setError(null);
+        try {
+            const conversation = kind === 'broadcast'
+                ? await openBroadcastConversation(payload)
+                : await openGroupConversation(payload);
+            onOpen === null || onOpen === void 0 ? void 0 : onOpen(conversation);
+        }
+        catch (_a) {
+            setError(t('MessagingLaunchers.OPEN_ERROR'));
+        }
+    };
+    useEffect(() => {
+        var _a;
+        if (!autoOpenBroadcast || !broadcastLauncher || autoOpened.current)
+            return;
+        autoOpened.current = true;
+        open('broadcast', (_a = broadcastLauncher.payload) !== null && _a !== void 0 ? _a : broadcastLauncher);
+    }, [autoOpenBroadcast, broadcastLauncher]); // one intentional auto-open per mounted launcher
+    return (_jsxs(Stack, { spacing: 1, children: [broadcastLauncher && !autoOpenBroadcast && (_jsx(Button, { variant: "outlined", onClick: () => { var _a; return open('broadcast', (_a = broadcastLauncher.payload) !== null && _a !== void 0 ? _a : broadcastLauncher); }, children: broadcastLauncher.label || t('MessagingLaunchers.OPEN_BROADCAST') })), groupLaunchers.map((launcher) => {
+                var _a;
+                return (_jsx(Button, { variant: "outlined", onClick: () => { var _a; return open('group', (_a = launcher.payload) !== null && _a !== void 0 ? _a : launcher); }, children: launcher.label || t('MessagingLaunchers.OPEN_GROUP') }, (_a = launcher.id) !== null && _a !== void 0 ? _a : launcher.label));
+            }), error && _jsx(Alert, { severity: "error", children: error })] }));
+}

package/dist/messaging/ConversationList.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { Archive, Campaign, Groups, MoreVert, NotificationsOff, Person } from '@mui/icons-material';
+import { Badge, Box, Button, CircularProgress, IconButton, List, ListItemButton, ListItemText, Menu, MenuItem, Stack, Typography } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+import { useMessaging } from './MessagingProvider';
+import { ConversationLaunchers } from './ConversationLaunchers';
+function titleOf(conversation, t) { var _a, _b; return conversation.title || ((_a = conversation.other_user) === null || _a === void 0 ? void 0 : _a.display_name) || ((_b = conversation.other_user) === null || _b === void 0 ? void 0 : _b.username) || t('MessagingList.UNTITLED'); }
+function ordered(conversations) {
+    return [...conversations].sort((left, right) => new Date(right.last_message_at || 0) - new Date(left.last_message_at || 0));
+}
+// jg's ConversationList renders a distinct icon per conversation kind so a
+// user can identify type/person at a glance (getConversationAvatar); that
+// glanceable identification is a feature, not layout, so it's reproduced
+// here rather than left as a generic archive-status glyph.
+function KindIcon({ conversation }) {
+    if (conversation.kind === 'broadcast')
+        return _jsx(Campaign, { fontSize: "small" });
+    if (conversation.kind === 'group' || conversation.kind === 'managed' || conversation.kind === 'object_thread')
+        return _jsx(Groups, { fontSize: "small" });
+    return _jsx(Person, { fontSize: "small" });
+}
+/** A standalone, provider-backed list; scope picker metadata is supplied as launcher props. */
+export function ConversationList({ onOpen, groupLaunchers, broadcastLauncher, autoOpenBroadcast = false, includeArchived = false }) {
+    const { t } = useTranslation();
+    const { cache, activeConversationId, loadMoreConversations, setConversationArchived, setConversationPreferences } = useMessaging();
+    const [menuConversation, setMenuConversation] = useState(null);
+    const [menuAnchor, setMenuAnchor] = useState(null);
+    const [loadingMore, setLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const conversations = useMemo(() => ordered(Object.values(cache.conversations).filter((item) => includeArchived || !item.archived_at && !item.archived)), [cache.conversations, includeArchived]);
+    const unreadFor = (conversation) => { var _a, _b, _c; return (_c = (_a = conversation.unread_count) !== null && _a !== void 0 ? _a : (_b = cache.unread.by_conversation) === null || _b === void 0 ? void 0 : _b[conversation.id]) !== null && _c !== void 0 ? _c : 0; };
+    // Once opened, the broadcast conversation becomes a normal, recency-sorted
+    // row with real unread/preview state — hide the static launcher so it isn't
+    // shown twice (button + list row) with the button's stale, unread-less copy.
+    const broadcastAlreadyOpened = useMemo(() => Object.values(cache.conversations).some((item) => item.kind === 'broadcast'), [cache.conversations]);
+    const loadMore = async () => {
+        setLoadingMore(true);
+        setError(null);
+        try {
+            await loadMoreConversations();
+        }
+        catch (_a) {
+            setError(t('MessagingList.LOAD_ERROR'));
+        }
+        finally {
+            setLoadingMore(false);
+        }
+    };
+    const closeMenu = () => { setMenuConversation(null); setMenuAnchor(null); };
+    const archive = async () => {
+        try {
+            await setConversationArchived(menuConversation.id, true);
+        }
+        catch (_a) {
+            setError(t('MessagingList.ARCHIVE_ERROR'));
+        }
+        closeMenu();
+    };
+    const toggleMute = async () => {
+        try {
+            await setConversationPreferences(menuConversation.id, { muted: !menuConversation.muted });
+        }
+        catch (_a) {
+            setError(t('MessagingList.PREFERENCES_ERROR'));
+        }
+        closeMenu();
+    };
+    return (_jsxs(Stack, { spacing: 1, children: [_jsx(ConversationLaunchers, { groupLaunchers: groupLaunchers, broadcastLauncher: broadcastAlreadyOpened ? null : broadcastLauncher, autoOpenBroadcast: autoOpenBroadcast && !broadcastAlreadyOpened, onOpen: onOpen }), error && _jsx(Typography, { color: "error", role: "alert", children: error }), !conversations.length ? _jsx(Box, { sx: { py: 3, textAlign: 'center' }, children: _jsx(Typography, { color: "text.secondary", children: t('MessagingList.EMPTY') }) }) : (_jsx(List, { disablePadding: true, "aria-label": t('MessagingList.LABEL'), children: conversations.map((conversation) => {
+                    var _a;
+                    const unread = unreadFor(conversation);
+                    const archived = Boolean(conversation.archived || conversation.archived_at);
+                    return _jsxs(ListItemButton, { selected: conversation.id === activeConversationId, onClick: () => onOpen === null || onOpen === void 0 ? void 0 : onOpen(conversation), sx: { minHeight: 64, opacity: archived ? 0.6 : 1 }, children: [_jsx(Badge, { color: "error", badgeContent: unread || null, max: 99, sx: { mr: 2 }, children: archived ? _jsx(Archive, { fontSize: "small", color: "disabled" }) : _jsx(KindIcon, { conversation: conversation }) }), _jsx(ListItemText, { primary: titleOf(conversation, t), secondary: ((_a = conversation.last_message) === null || _a === void 0 ? void 0 : _a.body) || t('MessagingList.NO_MESSAGES'), primaryTypographyProps: { fontWeight: unread ? 700 : 400, noWrap: true }, secondaryTypographyProps: { noWrap: true } }), _jsx(IconButton, { "aria-label": t('MessagingList.ACTIONS'), onClick: (event) => { event.stopPropagation(); setMenuAnchor(event.currentTarget); setMenuConversation(conversation); }, children: _jsx(MoreVert, {}) })] }, conversation.id);
+                }) })), cache.cursors.conversations && _jsx(Button, { onClick: loadMore, disabled: loadingMore, children: loadingMore ? _jsx(CircularProgress, { size: 18 }) : t('MessagingList.LOAD_MORE') }), _jsxs(Menu, { anchorEl: menuAnchor, open: Boolean(menuConversation), onClose: closeMenu, children: [_jsxs(MenuItem, { onClick: toggleMute, children: [_jsx(NotificationsOff, { fontSize: "small", sx: { mr: 1 } }), (menuConversation === null || menuConversation === void 0 ? void 0 : menuConversation.muted) ? t('MessagingList.UNMUTE') : t('MessagingList.MUTE')] }), _jsxs(MenuItem, { onClick: archive, children: [_jsx(Archive, { fontSize: "small", sx: { mr: 1 } }), t('MessagingList.ARCHIVE')] })] })] }));
+}

package/dist/messaging/MessageBubble.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Paper, Stack, Typography } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+import { AttachmentList } from './AttachmentList';
+import { ReactionBar } from './ReactionBar';
+import { PollCard } from './PollCard';
+function senderName(message) {
+    var _a, _b, _c;
+    return ((_a = message.sender) === null || _a === void 0 ? void 0 : _a.display_name) || ((_b = message.sender) === null || _b === void 0 ? void 0 : _b.username) || message.sender_name || ((_c = message.sender) === null || _c === void 0 ? void 0 : _c.name);
+}
+/** Provider-backed timeline collaborator; it deliberately has no mutation controls. */
+export function MessageBubble({ message, replyTo, onReply, children }) {
+    const { t } = useTranslation();
+    const deleted = Boolean(message.deleted_at);
+    const attachments = message.attachments || [];
+    return (_jsx(Paper, { component: "article", variant: "outlined", sx: { p: 1.25, maxWidth: 'min(100%, 680px)' }, "aria-label": t('MessagingThread.MESSAGE'), children: _jsxs(Stack, { spacing: 0.75, children: [replyTo && _jsx(Typography, { variant: "caption", color: "text.secondary", children: t('MessagingThread.REPLY_TO', { sender: senderName(replyTo) || t('MessagingThread.UNKNOWN_SENDER') }) }), _jsxs(Stack, { direction: "row", spacing: 1, alignItems: "baseline", children: [_jsx(Typography, { variant: "subtitle2", children: senderName(message) || t('MessagingThread.UNKNOWN_SENDER') }), message.created_at && _jsx(Typography, { variant: "caption", color: "text.secondary", children: new Date(message.created_at).toLocaleString() }), message.edited_at && !deleted && _jsx(Typography, { variant: "caption", color: "text.secondary", children: t('MessagingThread.EDITED') })] }), !deleted && message.kind === 'announcement' && message.title && _jsx(Typography, { variant: "subtitle1", fontWeight: 700, children: message.title }), _jsx(Typography, { sx: { whiteSpace: 'pre-wrap' }, children: deleted ? t('MessagingThread.DELETED') : (message.kind === 'announcement' ? message.body : (message.body || message.title)) || '' }), !deleted && _jsxs(Stack, { spacing: 0.75, children: [attachments.length > 0 && _jsx(AttachmentList, { attachments: attachments }), _jsx(ReactionBar, { message: message }), message.poll && _jsx(PollCard, { message: message })] }), !deleted && onReply && _jsx(Button, { type: "button", size: "small", onClick: () => onReply(message), children: t('MessagingThread.REPLY') }), children] }) }));
+}