@bcc-code/vue-bcc-chat-ui 7.0.1 → 7.0.2

package/dist/App.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/FixtureApp.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/auth.d.ts

@@ -0,0 +1,2 @@
+import { App } from 'vue';
+export default function setupAuth(app: App<Element>): Promise<import('@auth0/auth0-vue').Auth0Plugin>;

package/dist/chat/accessToken.d.ts

@@ -0,0 +1,11 @@
+export interface StoredCometChatToken {
+    sub: string;
+    token: string;
+}
+export declare function getAccessToken(): string | null;
+export declare function storeAccessToken(token: string | null): void;
+export declare function getAccessTokenSubject(accessToken?: string | null): any;
+export declare function getStoredCometChatToken(): StoredCometChatToken | null;
+export declare function retrieveCcToken(): StoredCometChatToken | null;
+export declare function storeCometChatToken(token: StoredCometChatToken): void;
+export declare function clearCometChatToken(): void;

package/dist/chat/avatar.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeAvatarUrl(value: unknown): string | undefined;
+export declare function proxyImage(imageUrl: string): string;
+export declare function resolveAvatarUrlString(value: unknown): string | undefined;

package/dist/chat/cacheScope.d.ts

@@ -0,0 +1,13 @@
+export declare function getChatCacheScope(): string | null;
+export declare function getChatCacheOwner(): string | null;
+/**
+ * Ensures a cache scope exists for the given owner.  Reuses the current scope
+ * when the owner has not changed; rotates it otherwise.
+ */
+export declare function ensureChatCacheScope(ownerId: string): string;
+/**
+ * Clears the in-memory mirrors so the next read re-fetches from localStorage.
+ * Only needed in tests where localStorage is cleared between runs without
+ * reloading the module.
+ */
+export declare function resetCacheScopeForTesting(): void;

package/dist/chat/client.d.ts

@@ -0,0 +1,7 @@
+import { Environment } from './environment';
+import { ChatClient } from './types';
+interface CreateChatClientOptions {
+    environment: Environment;
+}
+export declare function createChatClient({ environment, }: CreateChatClientOptions): ChatClient;
+export {};

package/dist/chat/conversationState.d.ts

@@ -0,0 +1,11 @@
+import { ChatConversationItem, MessageSendOptions } from './types';
+export declare function isConversationChannel(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function hasJoinedConversation(conversation?: Pick<ChatConversationItem, "source"> | null): any;
+export declare function getConversationScope(conversation?: Pick<ChatConversationItem, "source"> | null): string | undefined;
+export declare function isConversationReadOnly(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canUseConversationMessageActions(conversation?: Pick<ChatConversationItem, "source"> | null): any;
+export declare function canReactInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): any;
+export declare function canReplyInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): any;
+export declare function canOpenThreadInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canShowConversationAvatars(conversation?: Pick<ChatConversationItem, "source" | "type"> | null): any;
+export declare function getConversationSendOptions(conversation: Pick<ChatConversationItem, "source"> | null | undefined, senderDisplayName?: string): MessageSendOptions | undefined;

package/dist/chat/data.d.ts

@@ -0,0 +1,15 @@
+import { CachedParticipantSettings, ChatConversationItem, ParticipantInfo, PersonSettings, SearchedItems } from './types';
+export declare function getSenderDisplayName(message: any, group?: {
+    value?: any;
+}): any;
+export declare function searchChat(searchQuery: string, limit?: number, currentUserId?: string | null): SearchedItems | undefined;
+export declare function getGroupMembersInfo(groupUid: string): Promise<ParticipantInfo[]>;
+export declare function getMutedUntil(chatUid: string): Promise<string | null>;
+export declare function muteChat(chatUid: string, mutedUntil: string | null): Promise<string | null>;
+export declare function getMyChatSettings(): Promise<PersonSettings>;
+export declare function updateMyChatSettings(settings: Partial<PersonSettings>): Promise<PersonSettings>;
+export declare function setMuteAll(mute: boolean): Promise<boolean>;
+export declare function toggleMuteAll(): Promise<boolean>;
+export declare function getCachedParticipantSettings(chatUid: string): CachedParticipantSettings | null;
+export declare function cacheParticipantSettings(settings: CachedParticipantSettings): void;
+export declare function applyMuteSettingToConversations(conversations: ChatConversationItem[], chatUid: string, mutedUntil: string | null): ChatConversationItem[];

package/dist/chat/environment.d.ts

@@ -0,0 +1,8 @@
+export type Environment = "prod" | "sandbox";
+export interface ChatEnvironmentConfig {
+    region: string;
+    appId: string;
+    chatApiBaseUrl: string;
+}
+export declare function setCurrentEnvironment(environment: Environment): void;
+export declare function getCurrentEnvironment(): ChatEnvironmentConfig;

package/dist/chat/i18n/en.d.ts

@@ -0,0 +1,118 @@
+import { TranslationParams } from './types';
+export declare const englishTranslations: {
+    readonly addOption: "Add option";
+    readonly addToMessage: "Add to message";
+    readonly allowMultipleAnswers: "Allow multiple answers";
+    readonly attachAudio: "Attach audio";
+    readonly attachFile: "Attach file";
+    readonly attachImage: "Attach image";
+    readonly attachVideo: "Attach video";
+    readonly attachment: "Attachment";
+    readonly attachmentSummary: ({ name }: TranslationParams) => string;
+    readonly audio: "Audio";
+    readonly audioMessage: "Audio message";
+    readonly bold: "Bold";
+    readonly cancel: "Cancel";
+    readonly chatNotFound: "Chat not found...";
+    readonly close: "Close";
+    readonly closeMediaViewer: "Close media viewer";
+    readonly closeThread: "Close thread";
+    readonly connecting: "Connecting...";
+    readonly copyText: "Copy text";
+    readonly copied: "Copied";
+    readonly createPoll: "Create poll";
+    readonly createPollTitle: "Create poll";
+    readonly currentDraftWillBeScheduled: "Current draft will be scheduled.";
+    readonly delete: "Delete";
+    readonly delivered: "Delivered";
+    readonly deliveredNotYetRead: "Delivered, not yet read";
+    readonly deliveredToAll: "Delivered to all";
+    readonly deliveryAndReadDetails: "Delivery and read details";
+    readonly edit: "Edit";
+    readonly edited: "edited";
+    readonly editing: "Editing";
+    readonly editingInContext: ({ context }: TranslationParams) => string;
+    readonly failed: "Failed";
+    readonly file: "File";
+    readonly groupChat: "Group chat";
+    readonly hiddenHelperConversation: "Hidden helper conversation";
+    readonly image: "Image";
+    readonly info: "Info";
+    readonly italic: "Italic";
+    readonly loadMessageReceiptsError: "Unable to load message receipts.";
+    readonly loadScheduledMessagesError: "Unable to load scheduled messages.";
+    readonly loadOlderMessages: "Load older messages";
+    readonly loadingOlderMessages: "Loading older messages";
+    readonly loadingChat: "Loading chat...";
+    readonly loadingPreview: "Loading preview...";
+    readonly members: ({ count }: TranslationParams) => string;
+    readonly message: "Message";
+    readonly messageInfo: "Message info";
+    readonly messages: "Messages";
+    readonly multipleAnswersAllowed: "multiple answers allowed";
+    readonly noMatchingChatsFound: "No matching chats found.";
+    readonly noMessagesHaveBeenSentYet: "No messages have been sent yet";
+    readonly noMessagesYetInThisGroup: "No messages yet in this group.";
+    readonly noRecipientsDeliveredStageYet: "No recipients are only at the delivered stage yet.";
+    readonly noScheduledMessagesForConversation: "No scheduled messages for this conversation.";
+    readonly nobodyHasReadThisMessageYet: "Nobody has read this message yet.";
+    readonly notYet: "Not yet";
+    readonly offline: "Offline";
+    readonly offlineQueued: ({ count }: TranslationParams) => string;
+    readonly openInNewTab: "Open in new tab";
+    readonly openVideoViewer: "Open video viewer";
+    readonly option: ({ index }: TranslationParams) => string;
+    readonly options: "Options";
+    readonly photo: "Photo";
+    readonly poll: "Poll";
+    readonly pollPrefix: ({ question }: TranslationParams) => string;
+    readonly pollQuestionPlaceholder: "What should we prioritize next?";
+    readonly question: "Question";
+    readonly queued: "Queued";
+    readonly queuedForConversation: ({ title }: TranslationParams) => string;
+    readonly queuedOutgoingMessagesForThisChat: "Queued outgoing messages for this chat";
+    readonly read: "Read";
+    readonly readBy: "Read by";
+    readonly readByAll: "Read by all";
+    readonly readOnlyChannel: "This channel is read-only.";
+    readonly realtimeOn: "Realtime on";
+    readonly recentConversations: "Recent conversations";
+    readonly refreshingMessages: "Refreshing messages";
+    readonly repliesDisabledInChannels: "Replies are disabled in channels.";
+    readonly reply: "Reply";
+    readonly replying: "Replying";
+    readonly replyingInContext: ({ context }: TranslationParams) => string;
+    readonly reschedule: "Reschedule";
+    readonly save: "Save";
+    readonly saveMessage: "Save message";
+    readonly schedule: "Schedule";
+    readonly scheduled: "Scheduled";
+    readonly scheduledDateLabel: ({ date }: TranslationParams) => string;
+    readonly scheduledMessages: "Scheduled messages";
+    readonly scheduleMessage: "Schedule message";
+    readonly searchByGroupName: "Search by group name";
+    readonly selectConversationToStart: "Select a conversation to start reading and sending messages.";
+    readonly sendAt: "Send at";
+    readonly sendAttachment: "Send attachment";
+    readonly sendMessage: "Send message";
+    readonly sending: "Sending";
+    readonly sendPoll: "Send poll";
+    readonly sent: "Sent";
+    readonly sentAnAttachment: "Sent an attachment";
+    readonly signedInToSandbox: "Signed in to BCC Sandbox";
+    readonly someRecipients: "Some recipients";
+    readonly system: "System";
+    readonly thread: "Thread";
+    readonly threadReplies: ({ count }: TranslationParams) => string;
+    readonly threadWithCount: ({ count }: TranslationParams) => string;
+    readonly translate: "Translate";
+    readonly underline: "Underline";
+    readonly unsupportedMessageType: "Unsupported message type";
+    readonly unscheduled: "Unscheduled";
+    readonly video: "Video";
+    readonly voteCount: ({ count }: TranslationParams) => string;
+    readonly waitingForNetwork: "Waiting for network...";
+    readonly writeMessage: "Write a message...";
+    readonly you: "You";
+    readonly youSentAMessage: "You sent a message";
+};

package/dist/chat/i18n/nb.d.ts

@@ -0,0 +1,118 @@
+import { TranslationParams } from './types';
+export declare const norwegianTranslations: {
+    readonly addOption: "Legg til alternativ";
+    readonly addToMessage: "Legg til i melding";
+    readonly allowMultipleAnswers: "Tillat flere svar";
+    readonly attachAudio: "Legg ved lyd";
+    readonly attachFile: "Legg ved fil";
+    readonly attachImage: "Legg ved bilde";
+    readonly attachVideo: "Legg ved video";
+    readonly attachment: "Vedlegg";
+    readonly attachmentSummary: ({ name }: TranslationParams) => string;
+    readonly audio: "Lyd";
+    readonly audioMessage: "Lydmelding";
+    readonly bold: "Fet";
+    readonly cancel: "Avbryt";
+    readonly chatNotFound: "Fant ikke chatten...";
+    readonly close: "Lukk";
+    readonly closeMediaViewer: "Lukk medievisning";
+    readonly closeThread: "Lukk tråd";
+    readonly connecting: "Kobler til...";
+    readonly copyText: "Kopier tekst";
+    readonly copied: "Kopiert";
+    readonly createPoll: "Opprett avstemning";
+    readonly createPollTitle: "Opprett avstemning";
+    readonly currentDraftWillBeScheduled: "Gjeldende utkast blir planlagt.";
+    readonly delete: "Slett";
+    readonly delivered: "Levert";
+    readonly deliveredNotYetRead: "Levert, ikke lest ennå";
+    readonly deliveredToAll: "Levert til alle";
+    readonly deliveryAndReadDetails: "Leverings- og lesedetaljer";
+    readonly edit: "Rediger";
+    readonly edited: "redigert";
+    readonly editing: "Redigerer";
+    readonly editingInContext: ({ context }: TranslationParams) => string;
+    readonly failed: "Mislyktes";
+    readonly file: "Fil";
+    readonly groupChat: "Gruppechat";
+    readonly hiddenHelperConversation: "Skjult hjelpesamtale";
+    readonly image: "Bilde";
+    readonly info: "Info";
+    readonly italic: "Kursiv";
+    readonly loadMessageReceiptsError: "Kunne ikke laste meldingskvitteringer.";
+    readonly loadScheduledMessagesError: "Kunne ikke laste planlagte meldinger.";
+    readonly loadOlderMessages: "Last eldre meldinger";
+    readonly loadingOlderMessages: "Laster eldre meldinger";
+    readonly loadingChat: "Laster chat...";
+    readonly loadingPreview: "Laster forhåndsvisning...";
+    readonly members: ({ count }: TranslationParams) => string;
+    readonly message: "Melding";
+    readonly messageInfo: "Meldingsinfo";
+    readonly messages: "Meldinger";
+    readonly multipleAnswersAllowed: "flere svar tillatt";
+    readonly noMatchingChatsFound: "Fant ingen samsvarende chatter.";
+    readonly noMessagesHaveBeenSentYet: "Ingen meldinger har blitt sendt ennå";
+    readonly noMessagesYetInThisGroup: "Ingen meldinger i denne gruppen ennå.";
+    readonly noRecipientsDeliveredStageYet: "Ingen mottakere er bare på levert-stadiet ennå.";
+    readonly noScheduledMessagesForConversation: "Ingen planlagte meldinger for denne samtalen.";
+    readonly nobodyHasReadThisMessageYet: "Ingen har lest denne meldingen ennå.";
+    readonly notYet: "Ikke ennå";
+    readonly offline: "Frakoblet";
+    readonly offlineQueued: ({ count }: TranslationParams) => string;
+    readonly openInNewTab: "Åpne i ny fane";
+    readonly openVideoViewer: "Åpne videovisning";
+    readonly option: ({ index }: TranslationParams) => string;
+    readonly options: "Alternativer";
+    readonly photo: "Bilde";
+    readonly poll: "Avstemning";
+    readonly pollPrefix: ({ question }: TranslationParams) => string;
+    readonly pollQuestionPlaceholder: "Hva bør vi prioritere videre?";
+    readonly question: "Spørsmål";
+    readonly queued: "I kø";
+    readonly queuedForConversation: ({ title }: TranslationParams) => string;
+    readonly queuedOutgoingMessagesForThisChat: "Utgående meldinger i kø for denne chatten";
+    readonly read: "Lest";
+    readonly readBy: "Lest av";
+    readonly readByAll: "Lest av alle";
+    readonly readOnlyChannel: "Denne kanalen er skrivebeskyttet.";
+    readonly realtimeOn: "Sanntid på";
+    readonly recentConversations: "Nylige samtaler";
+    readonly refreshingMessages: "Oppdaterer meldinger";
+    readonly repliesDisabledInChannels: "Svar er deaktivert i kanaler.";
+    readonly reply: "Svar";
+    readonly replying: "Svarer";
+    readonly replyingInContext: ({ context }: TranslationParams) => string;
+    readonly reschedule: "Planlegg på nytt";
+    readonly save: "Lagre";
+    readonly saveMessage: "Lagre melding";
+    readonly schedule: "Planlegg";
+    readonly scheduled: "Planlagt";
+    readonly scheduledDateLabel: ({ date }: TranslationParams) => string;
+    readonly scheduledMessages: "Planlagte meldinger";
+    readonly scheduleMessage: "Planlegg melding";
+    readonly searchByGroupName: "Søk etter gruppenavn";
+    readonly selectConversationToStart: "Velg en samtale for å begynne å lese og sende meldinger.";
+    readonly sendAt: "Send kl.";
+    readonly sendAttachment: "Send vedlegg";
+    readonly sendMessage: "Send melding";
+    readonly sending: "Sender";
+    readonly sendPoll: "Send avstemning";
+    readonly sent: "Sendt";
+    readonly sentAnAttachment: "Sendte et vedlegg";
+    readonly signedInToSandbox: "Logget inn i BCC Sandbox";
+    readonly someRecipients: "Noen mottakere";
+    readonly system: "System";
+    readonly thread: "Tråd";
+    readonly threadReplies: ({ count }: TranslationParams) => string;
+    readonly threadWithCount: ({ count }: TranslationParams) => string;
+    readonly translate: "Oversett";
+    readonly underline: "Understrek";
+    readonly unsupportedMessageType: "Meldingstype støttes ikke";
+    readonly unscheduled: "Ikke planlagt";
+    readonly video: "Video";
+    readonly voteCount: ({ count }: TranslationParams) => string;
+    readonly waitingForNetwork: "Venter på nettverk...";
+    readonly writeMessage: "Skriv en melding...";
+    readonly you: "Du";
+    readonly youSentAMessage: "Du sendte en melding";
+};

package/dist/chat/i18n/types.d.ts

@@ -0,0 +1,2 @@
+export type TranslationParams = Record<string, string | number | undefined>;
+export type TranslationEntry = string | ((params: TranslationParams) => string);

package/dist/chat/index.d.ts

@@ -0,0 +1,94 @@
+import { App } from 'vue';
+import { retrieveCcToken } from './accessToken';
+import { proxyImage } from './avatar';
+import { getGroupMembersInfo as getGroupMembersInfoCompat, getMyChatSettings, getSenderDisplayName, setMuteAll, toggleMuteAll, updateMyChatSettings } from './data';
+import { getCurrentEnvironment, Environment } from './environment';
+import { getMessageTextPreview } from './messageText';
+import { toMarkdownHtml } from './richText';
+import { ChatClient, ChatInstallOptions, Language, OnlineStatus, ThemeMode, UserChatInfo } from './types';
+declare const chatClient: import('vue').ShallowRef<ChatClient | null, ChatClient | null>;
+declare function install(app: App, options: ChatInstallOptions): Promise<void>;
+declare function login(accessToken?: string): Promise<void>;
+declare function logout(): Promise<void>;
+declare function connect(connectionName?: string): Promise<void>;
+declare function disconnect(connectionName?: string): Promise<void>;
+declare function disconnectAll(): Promise<void>;
+declare function updateGetGroupMessages(groupMessageGetter: ((guid: string, query: string) => Promise<unknown>) | undefined): void;
+declare function setLanguage(language: Language): void;
+declare function setThemeMode(mode: ThemeMode): void;
+declare function setAccessToken(token: string): Promise<void>;
+declare function setEnvironment(environment: Environment): void;
+declare function getGroup(groupUid: string): Promise<import('@cometchat/chat-sdk-javascript').Group | null | undefined>;
+declare function getUserChats(): Promise<UserChatInfo[]>;
+declare function clearGroupChatCount(groupUid: string): Promise<void>;
+declare function getOnlineGroupMemberCount(groupUid: string): Promise<number>;
+declare function muteChat(chatUid: string, mutedUntil: string | null): Promise<string | null>;
+declare function getMutedUntil(chatUid: string): Promise<string | null>;
+declare function scrollToMessage(messageId: string): void;
+export { chatClient };
+declare const chat: {
+    install: typeof install;
+    updateGetGroupMessages: typeof updateGetGroupMessages;
+    initialized: import('vue').Ref<boolean, boolean>;
+    connected: import('vue').ComputedRef<boolean>;
+    connecting: import('vue').ComputedRef<boolean>;
+    loggedIn: import('vue').ComputedRef<boolean>;
+    userChats: import('vue').ComputedRef<UserChatInfo[]>;
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    disconnectAll: typeof disconnectAll;
+    setAccessToken: typeof setAccessToken;
+    login: typeof login;
+    logout: typeof logout;
+    setCurrentEnvironment: typeof setEnvironment;
+    getCurrentEnvironment: typeof getCurrentEnvironment;
+    setThemeMode: typeof setThemeMode;
+    setLanguage: typeof setLanguage;
+    getGroup: typeof getGroup;
+    getGroupMembersInfo: typeof getGroupMembersInfoCompat;
+    getUserChats: typeof getUserChats;
+    clearGroupChatCount: typeof clearGroupChatCount;
+    getOnlineGroupMemberCount: typeof getOnlineGroupMemberCount;
+    getGroupOnlineCount: typeof getOnlineGroupMemberCount;
+    searchChat: (searchQuery: string, limit?: number) => import('./types').SearchedItems | undefined;
+    getSenderDisplayName: typeof getSenderDisplayName;
+    getMessageTextPreview: typeof getMessageTextPreview;
+    proxyImage: typeof proxyImage;
+    getMutedUntil: typeof getMutedUntil;
+    muteChat: typeof muteChat;
+    getMyChatSettings: typeof getMyChatSettings;
+    updateMyChatSettings: typeof updateMyChatSettings;
+    setMuteAll: typeof setMuteAll;
+    toggleMuteAll: typeof toggleMuteAll;
+    toMarkdownHtml: typeof toMarkdownHtml;
+    retrieveCcToken: typeof retrieveCcToken;
+    getGroupMessages: import('vue').Ref<((guid: string, query: string) => Promise<unknown>) | undefined, ((guid: string, query: string) => Promise<unknown>) | undefined>;
+    loadMessageId: import('vue').Ref<string | undefined, string | undefined>;
+    scrollToMessageId: import('vue').Ref<string | undefined, string | undefined>;
+    scrollToMessage: typeof scrollToMessage;
+    connectivity: {
+        onlineMode: import('vue').WritableComputedRef<OnlineStatus, OnlineStatus>;
+        onlineStatus: import('vue').ComputedRef<OnlineStatus>;
+    };
+    onlineMode: import('vue').WritableComputedRef<OnlineStatus, OnlineStatus>;
+    onlineStatus: import('vue').ComputedRef<OnlineStatus>;
+    theme: import('vue').Ref<{
+        palette: {
+            mode: ThemeMode;
+            setMode: (mode: ThemeMode) => void;
+        };
+    }, {
+        palette: {
+            mode: ThemeMode;
+            setMode(mode: ThemeMode): void;
+        };
+    } | {
+        palette: {
+            mode: ThemeMode;
+            setMode: (mode: ThemeMode) => void;
+        };
+    }>;
+    themeMode: import('vue').Ref<ThemeMode, ThemeMode>;
+    language: import('vue').Ref<Language, Language>;
+};
+export default chat;

package/dist/chat/localization.d.ts

@@ -0,0 +1,15 @@
+import { MaybeRefOrGetter } from 'vue';
+import { englishTranslations } from './i18n/en';
+import { TranslationEntry, TranslationParams } from './i18n/types';
+import { Language } from './types';
+type TranslationDictionary = Record<keyof typeof englishTranslations, TranslationEntry>;
+export type TranslationKey = keyof TranslationDictionary;
+export declare const currentChatLanguage: import('vue').Ref<Language, Language>;
+export declare function resolveChatLocale(language?: Language | null): "nb-NO" | "en-US";
+export declare function setCurrentChatLanguage(language: Language): void;
+export declare function translateChat(key: TranslationKey, params?: TranslationParams, language?: Language | null): string;
+export declare function useChatI18n(language?: MaybeRefOrGetter<Language | undefined | null>): {
+    locale: import('vue').ComputedRef<"nb-NO" | "en-US">;
+    t: (key: TranslationKey, params?: TranslationParams) => string;
+};
+export {};

package/dist/chat/messageText.d.ts

@@ -0,0 +1,13 @@
+import { ChatAttachmentItem, ChatMessageItem, ChatReplyPreview } from './types';
+type MessageTextSource = Pick<ChatMessageItem, "text" | "kind" | "poll" | "attachments">;
+export declare function getAttachmentDisplayText(attachments: ReadonlyArray<Pick<ChatAttachmentItem, "kind" | "name">>, fallback?: string): string;
+export declare function normalizeMessageText(value: string | null | undefined): string;
+export declare function hasMessageText(value: string | null | undefined): boolean;
+export declare function getMessagePlainText(value: string | null | undefined): string;
+export declare function getMessageDisplayText(message: MessageTextSource, fallback?: string): string;
+export declare function getMessagePreviewText(message: MessageTextSource): string;
+export declare function getMessageTextPreview(message?: any, showEmoji?: boolean, showAttachmentName?: boolean): string;
+export declare function buildReplyPreview(message: Pick<ChatMessageItem, "id" | "senderName" | "text" | "kind" | "poll" | "attachments">): ChatReplyPreview;
+export declare function buildMessageActionText(message: Pick<ChatMessageItem, "text" | "attachments">): string;
+export declare function buildConversationSubtitle(message: MessageTextSource): string;
+export {};

package/dist/chat/mockClient.d.ts

@@ -0,0 +1,13 @@
+import { ChatClient, ChatUserProfile } from './types';
+export type VisualFixtureMode = "desktop" | "mobile" | "empty" | "scheduled";
+export interface MockChatScenario {
+    client: ChatClient;
+    profile: ChatUserProfile;
+    displayName: string;
+    email: string;
+    heroStatus: {
+        label: string;
+        severity: "warn" | "success" | "contrast";
+    };
+}
+export declare function createMockChatScenario(mode: VisualFixtureMode): MockChatScenario;

package/dist/chat/offlineStore.d.ts

@@ -0,0 +1,53 @@
+import { CachedLastMessage, CachedParticipantSettings, ChatAttachmentItem, ChatConversationItem, ChatMessageItem, PollComposerInput } from './types';
+interface OfflineQueueAttachment {
+    kind: ChatAttachmentItem["kind"];
+    name: string;
+    type: string;
+    size: number;
+    caption?: string;
+}
+export interface OfflineQueueItem {
+    id: string;
+    muid: string;
+    conversationId: string;
+    targetId: string;
+    receiverType: "group" | "user";
+    kind: "text" | "poll" | "attachment";
+    senderAvatar?: string;
+    text?: string;
+    poll?: PollComposerInput;
+    attachment?: OfflineQueueAttachment;
+    metadata?: Record<string, unknown>;
+    parentMessageId?: string;
+    createdAt: string;
+}
+export declare class ChatOfflineStore {
+    readonly storageKey: string;
+    private attachmentDbPromise;
+    constructor(storageKey: string);
+    getConversations(): ChatConversationItem[];
+    getSearchableConversations(): ChatConversationItem[];
+    setConversations(conversations: ChatConversationItem[]): void;
+    getMessages(conversationId: string): ChatMessageItem[];
+    getAllMessages(): ChatMessageItem[];
+    setMessages(conversationId: string, messages: ChatMessageItem[]): void;
+    getThreadMessages(parentMessageId: string): ChatMessageItem[];
+    setThreadMessages(parentMessageId: string, messages: ChatMessageItem[]): void;
+    getQueue(): OfflineQueueItem[];
+    enqueue(item: OfflineQueueItem): void;
+    dequeue(id: string): void;
+    getParticipantSettings(chatUid: string): CachedParticipantSettings | null;
+    storeParticipantSettings(settings: CachedParticipantSettings): void;
+    getLastMessage(chatUid: string): CachedLastMessage | null;
+    storeLastMessage(lastMessage: CachedLastMessage): void;
+    clear(): void;
+    storeQueuedAttachment(id: string, file: File): Promise<void>;
+    getQueuedAttachment(id: string): Promise<File | null>;
+    deleteQueuedAttachment(id: string): Promise<void>;
+    private read;
+    private write;
+    private mutate;
+    private clearQueuedAttachments;
+    private openAttachmentDb;
+}
+export {};

package/dist/chat/reactions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Emoji reaction sets used across message action menus and reaction pickers.
+ *
+ * COMMON_REACTIONS are shown first in the compact popover row.
+ * EXTENDED_REACTIONS populate the expanded grid when the user opens the full picker.
+ */
+export declare const COMMON_REACTIONS: string[];
+export declare const EXTENDED_REACTIONS: string[];

package/dist/chat/richText.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeRichTextForStorage(input: string | null | undefined): string;
+export declare function getPlainTextFromRichText(input: string | null | undefined): string;
+export declare function renderRichText(input: string | null | undefined): string;
+export declare function toMarkdownHtml(str: string, mentionedUsers?: any[]): string;
+export declare function getFirstUrlFromRichText(input: string | null | undefined): string | undefined;

package/dist/chat/theme.d.ts

@@ -0,0 +1,18 @@
+import { ThemeMode } from './types';
+export declare const theme: import('vue').Ref<{
+    palette: {
+        mode: ThemeMode;
+        setMode: (mode: ThemeMode) => void;
+    };
+}, {
+    palette: {
+        mode: ThemeMode;
+        setMode(mode: ThemeMode): void;
+    };
+} | {
+    palette: {
+        mode: ThemeMode;
+        setMode: (mode: ThemeMode) => void;
+    };
+}>;
+export declare function setThemeMode(mode: ThemeMode): void;