@lilaquadrat/chat 0.1.0

package/dist/studio-chat-module.js

@@ -0,0 +1 @@
+

package/dist/studio-chat-module.umd.cjs

@@ -0,0 +1 @@
+!function(n){"function"==typeof define&&define.amd?define(n):n()}(function(){});

package/dist/types/src/bot/botClient.d.ts

@@ -0,0 +1,40 @@
+/** prefix on bot-sent replies so auto-reply bots don't ping-pong off each other */
+export declare const BOT_PREFIX = "\uD83E\uDD16";
+export type BotConnectionStatus = 'connecting' | 'connected' | 'disconnected';
+export interface BotClientOptions {
+    userId: number;
+    url?: string;
+    apiUrl?: string;
+    getAutoReply?: () => boolean;
+    onStatus?: (_status: BotConnectionStatus) => void;
+}
+/**
+ * One independent websocket connection acting as a single user. Authenticates as its
+ * userId, learns the conversations it belongs to, auto-replies to others' messages, and
+ * proactively sends random messages on an interval — so it behaves like a live user for
+ * debugging multi-user flows.
+ */
+export declare class BotClient {
+    private socket;
+    private readonly userId;
+    private readonly url;
+    private readonly apiUrl;
+    private readonly getAutoReply;
+    private readonly onStatus?;
+    private conversations;
+    private chatterTimer;
+    private readonly replyTimers;
+    private readonly pace;
+    constructor(options: BotClientOptions);
+    connect(): void;
+    disconnect(): void;
+    sendMessage(conversation: string, message: string): void;
+    private handleClose;
+    /** fetch the conversations this bot is a participant of (raw fetch — SDK GET cache is shared across users) */
+    private loadConversations;
+    private scheduleChatter;
+    private clearTimers;
+    private sendRandom;
+    private send;
+    private handle;
+}

package/dist/types/src/bot/botManager.d.ts

@@ -0,0 +1,3 @@
+import { type Bot } from '@/stores/bots.store';
+export declare function connectBot(bot: Bot): void;
+export declare function disconnectBot(botId: string): void;

package/dist/types/src/composables/useWebSocket.d.ts

@@ -0,0 +1,11 @@
+import { type UseWebSocketOptions } from '@/libs/websocketManager';
+export declare function useWebSocket(): {
+    connect: (options: UseWebSocketOptions) => void;
+    disconnect: () => void;
+    reconnect: () => void;
+    conversationStart: (message: string, participants: string[], name: string | undefined, id: string, operationMode?: "chat" | "support") => boolean;
+    conversationLastRead: (conversation: string, lastReadId: number) => boolean;
+    messageAdd: (message: string, conversation: string) => boolean;
+    authenticate: (token: string) => boolean;
+    conversationTyping: (conversation: string, typing: boolean) => boolean;
+};

package/dist/types/src/config/auth.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pluggable auth-token source.
+ *
+ * The chat module never owns the auth session. The host application provides a
+ * function that, whenever called, returns a currently-valid token (Auth0 JWT).
+ * Registered once via `createChatModule({ getToken })` (see main.ts) or
+ * `setGetToken()` directly. The module derives identity from the token's `sub`
+ * and sends it as the WS `authenticate` token + HTTP Bearer.
+ *
+ * The function is called on every (re)connect and may be async, so the host can
+ * refresh/rotate the token transparently — it must always resolve a proper token.
+ */
+export type GetTokenFn = () => string | Promise<string>;
+/** register the host implementation. last call wins. */
+export declare function setGetToken(fn: GetTokenFn): void;
+export declare function hasGetToken(): boolean;
+/** resolve a fresh token through the registered implementation. returns undefined if none was set. */
+export declare function resolveToken(): Promise<string | undefined>;

package/dist/types/src/config/bootstrap.d.ts

@@ -0,0 +1,55 @@
+import type { App } from 'vue';
+import type { Pinia } from 'pinia';
+import { type Feature } from '@/stores/main.store';
+import { type GetUsersFn } from '@/config/users';
+import { type GetTokenFn } from '@/config/auth';
+import type { ParticipantUser } from '@/helpers/participants';
+export interface ChatModuleConfig {
+    /** how the host resolves users. Required for default mode; unused in support mode. */
+    getUsers?: GetUsersFn;
+    /**
+     * enabled features. Defaults to ['chat']. The two are orthogonal:
+     *   ['chat']            = normal user↔user chats only
+     *   ['support']         = support-only widget
+     *   ['chat','support']  = normal chats + an on-demand support chat alongside them
+     */
+    features?: Feature[];
+    /**
+     * @deprecated legacy single-axis mode; use `features` instead.
+     * 'chat'|'default' → ['chat'], 'support' → ['support'], 'both' → ['chat','support'].
+     */
+    mode?: 'chat' | 'support' | 'both' | 'default';
+    /** the current user id. Falls back to the ?user= query param (dev) when omitted. */
+    userId?: string;
+    /**
+     * the current user's own profile (prename/lastname/...). The backend enriches *other*
+     * participants but not the requesting user, so the host passes its own data here to
+     * resolve the current user's name. `id` defaults to `userId` when omitted.
+     */
+    user?: ParticipantUser;
+    /** support mode: the support recipient(s) the customer talks to. */
+    support?: {
+        participants: string[];
+    };
+    /** websocket endpoint. Defaults to ws://localhost:3001 (dev). */
+    wsUrl?: string;
+    /** API endpoint. Defaults to http://localhost:3000 (dev). */
+    apiUrl?: string;
+    /** media endpoint. Defaults to http://localhost:3000 (dev). */
+    mediaUrl?: string;
+    /** the host's auth token (Auth0 JWT). Identity is derived from its `sub`; sent as Bearer + WS auth. */
+    token?: string;
+    /**
+     * host-provided token resolver. Called on every (re)connect; may be async and must always
+     * return a currently-valid token. Preferred over the static `token` — identity comes from its `sub`.
+     */
+    getToken?: GetTokenFn;
+}
+/**
+ * Apply host configuration to the stores / providers. Shared by both bootstrap paths
+ * (createChatModule and the <lilaquadrat-studio-chat> custom element).
+ * Pass the pinia instance when calling outside an active-pinia context.
+ */
+export declare function applyConfig(config: ChatModuleConfig, pinia?: Pinia): void;
+/** register the module's global components on a Vue app (or custom-element app). */
+export declare function registerComponents(app: App): void;

package/dist/types/src/config/users.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pluggable user source.
+ *
+ * The chat module never hardcodes its users. The host application provides the
+ * implementation once, via `createChatModule({ getUsers })` (see main.ts) or by
+ * calling `setGetUsers()` directly before the contacts UI is used. This lets every
+ * host plug in its own backend (REST, Auth0, in-memory, ...).
+ */
+export interface ChatUser {
+    id: string;
+    prename?: string;
+    lastname?: string;
+    name?: string;
+    status?: string;
+}
+export interface GetUsersOptions {
+    /** restrict to specific user ids (e.g. to resolve participant names) */
+    ids?: string[];
+    /** free-text search/filter */
+    query?: string;
+}
+export type GetUsersFn = (_options?: GetUsersOptions) => Promise<ChatUser[]> | ChatUser[];
+/** register the host implementation. last call wins. */
+export declare function setGetUsers(fn: GetUsersFn): void;
+export declare function hasGetUsers(): boolean;
+/** resolve users through the registered implementation. returns [] (with a warning) if none was set. */
+export declare function getUsers(options?: GetUsersOptions): Promise<ChatUser[]>;

package/dist/types/src/helpers/date.d.ts

@@ -0,0 +1,7 @@
+import dayjs from 'dayjs';
+import 'dayjs/locale/de';
+import 'dayjs/locale/en';
+declare function date(date: string | Date | dayjs.Dayjs, format?: string): string;
+declare function time(date: string | Date | dayjs.Dayjs, format?: string): string;
+declare function dateRelative(date: string | Date | dayjs.Dayjs): string;
+export { date, time, dateRelative, dayjs };

package/dist/types/src/helpers/handleMessages.d.ts

@@ -0,0 +1 @@
+export default function handleMessages(message: Record<string, any>): void;

package/dist/types/src/helpers/loadComponents.d.ts

@@ -0,0 +1,10 @@
+import { type App, type Component, type AsyncComponentLoader } from 'vue';
+declare function loadViaDeclaration(components: {
+    name: string;
+    component: AsyncComponentLoader<Component>;
+}[], namespace: string | undefined, type: 'module' | 'partial', app: App<Element>): void;
+declare function loadViaDeclarationSync(components: {
+    name: string;
+    component: Component;
+}[], namespace: string | undefined, type: 'module' | 'partial', app: App<Element>): void;
+export { loadViaDeclaration, loadViaDeclarationSync, };

package/dist/types/src/helpers/participants.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Participants arrive in two shapes: backend-enriched objects ({ id, prename, ... })
+ * on real conversations, and bare id strings on local drafts (and on the write path
+ * we send back to the server). These helpers normalize both so comparisons, keys and
+ * display work regardless of shape.
+ */
+export interface ParticipantUser {
+    id: string;
+    prename?: string;
+    lastname?: string;
+    email?: string;
+    /** host-provided contact name (see @/config/users ChatUser) */
+    name?: string;
+}
+export type Participant = string | ParticipantUser;
+/** the user id of a participant, whether it's a bare id or an object */
+export declare function participantId(participant: Participant): string;
+/** map a participant list to its ids (e.g. before sending to the backend) */
+export declare function participantIds(participants?: Participant[]): string[];
+/** human-readable name: prename+lastname, else host name, else the raw id */
+export declare function participantName(participant: Participant): string;

package/dist/types/src/libs/StudioSDK.d.ts

@@ -0,0 +1,108 @@
+import { type AxiosResponse, type AxiosRequestConfig } from 'axios';
+type HttpStatusCode = number;
+export type SDKResponse<T> = {
+    data: T;
+    status: HttpStatusCode;
+    cacheLifetime?: number;
+    cacheTime?: number;
+    isCache?: boolean;
+};
+export type SDKCache = {
+    group?: string;
+    action?: string;
+    id?: string;
+    cacheLifetime?: number;
+    cacheTime?: number;
+};
+export type SDKCallOptions = {
+    /**
+     * ignore the cache and always execute the call
+     */
+    bypassCache?: boolean;
+    group?: string;
+    action?: string;
+    /**
+     * if a id is given, use it as key for atomic cache flushing
+     *
+     * e.g. ``flushId(id)``
+     *
+     * instead of the whole action category
+     *
+     * e.g. ``flushCache(group, action)``
+     *
+     */
+    id?: string;
+    /**
+     * in milliseconds
+     */
+    cacheLifetime?: number;
+};
+export default class StudioSDK {
+    readonly endpoints: {
+        live: {
+            api: string;
+            media: string;
+        };
+        next: {
+            api: string;
+            media: string;
+        };
+    };
+    customEndpoints: {
+        api: string;
+        media: string;
+    };
+    authToken: string;
+    mode: 'live' | 'next' | 'custom';
+    company: string;
+    project: string;
+    app: string;
+    universalModel: string;
+    options: {
+        company?: string;
+        project?: string;
+        authToken?: string;
+        mode?: StudioSDK['mode'];
+        customEndpoints?: {
+            api: string;
+            media: string;
+        };
+        universalModel?: string;
+    };
+    constructor(app: string, options: StudioSDK['options']);
+    private getUrl;
+    private getHeaders;
+    static getCacheKeyMock(url: string): string;
+    static getCacheKey(url: string): string;
+    static getCache(): Record<string, SDKResponse<any> & SDKCache>;
+    static handleCall<T, D = any>(call: AxiosRequestConfig<D>, options?: SDKCallOptions): Promise<SDKResponse<T>>;
+    static cache<T>(url: string, response?: AxiosResponse<T>, options?: SDKCallOptions): SDKResponse<any> & SDKCache;
+    static flushCache(group?: string, action?: string): void;
+    static flushId(id: string): void;
+    conversations: {
+        list: () => Promise<SDKResponse<any>>;
+        activate: () => Promise<SDKResponse<any>>;
+        create: (data: {
+            participants: string[];
+        }) => Promise<SDKResponse<any>>;
+        rename: (conversationId: string, name: string) => Promise<SDKResponse<any>>;
+        participants: (conversationId: string, add: string[], remove: string[]) => Promise<SDKResponse<any>>;
+        leave: (conversationId: string) => Promise<SDKResponse<any>>;
+        listParticipants: (conversationId: string) => Promise<SDKResponse<any>>;
+        rights: (conversationId: string, user: string, rights: string[]) => Promise<SDKResponse<any>>;
+        block: (conversationId: string, user: string, block: boolean) => Promise<SDKResponse<any>>;
+    };
+    contacts: {
+        list: (search?: string) => Promise<SDKResponse<any>>;
+        single: (contactId: string) => Promise<SDKResponse<any>>;
+        block: (contactId: string) => Promise<SDKResponse<any>>;
+        unblock: (contactId: string) => Promise<SDKResponse<any>>;
+    };
+    messages: {
+        list: (conversation: string, beforeId?: number) => Promise<SDKResponse<any>>;
+    };
+    health: {
+        health: () => Promise<SDKResponse<void>>;
+    };
+}
+export {};

package/dist/types/src/libs/resize.d.ts

@@ -0,0 +1,52 @@
+declare class Resize {
+    timeout: ReturnType<typeof setTimeout> | undefined;
+    debounceTime: number;
+    resizedEvent: Event;
+    mediaEvent: Event;
+    media: import("vue").Ref<string, string>;
+    resized: import("vue").Ref<number, number>;
+    /** timestamp bumped only when the tracked width actually changed */
+    widthChanged: import("vue").Ref<number, number>;
+    realHeight: import("vue").Ref<number, number>;
+    realWidth: import("vue").Ref<number, number>;
+    /**
+     * if true we fire an inital resized event to indicate that resizing has started without waiting for the debounce
+     */
+    triggerStart: import("vue").Ref<boolean, boolean>;
+    private installed;
+    private mediaQueries;
+    /** element realWidth is measured against; null = fall back to window.innerWidth */
+    private widthTarget;
+    private resizeObserver;
+    /** bound handler kept so removeEventListener can detach it */
+    private onResize;
+    private get safeWindow();
+    /**
+     * attach listeners and run initial detection. idempotent.
+     * @param selector optional CSS selector; when given realWidth tracks that element's width instead of window.innerWidth
+     */
+    init(selector?: string): void;
+    /** detach listeners. call on teardown/HMR dispose to avoid leaks. */
+    destroy(): void;
+    private measureWidth;
+    private now;
+    trigger(isStart?: boolean): void;
+    getMediaQuery(): void;
+    debounce(): void;
+}
+declare const resize: Resize;
+declare const plugin: {
+    install: (_app: unknown, options?: {
+        selector?: string;
+    }) => void;
+};
+declare function useResize(): {
+    realHeight: import("vue").Ref<number, number>;
+    realWidth: import("vue").Ref<number, number>;
+    media: import("vue").Ref<string, string>;
+    resized: import("vue").Ref<number, number>;
+    widthChanged: import("vue").Ref<number, number>;
+    plugin: Resize;
+};
+export default plugin;
+export { useResize, resize };

package/dist/types/src/libs/websocketManager.d.ts

@@ -0,0 +1,41 @@
+export interface UseWebSocketOptions {
+    url: string;
+    maxRetries: number;
+    maxRetryDelay: number;
+    onMessage?: (_data: string) => void;
+    onOpen?: () => void;
+    onClose?: (ev?: CloseEvent) => void;
+    onError?: (_error: Event) => void;
+    heartbeatIntervalMs?: number;
+    inactivityTimeoutMs?: number;
+    buildPingMessage?: () => object;
+}
+export declare class WebSocketManager {
+    private static instance;
+    private socket;
+    private currentOptions;
+    private retryCount;
+    private retryDelay;
+    private retryTimeoutId;
+    private refCount;
+    onConnectionChange?: (_isConnected: boolean) => void;
+    private heartbeatIntervalId;
+    private lastActivity;
+    private constructor();
+    static getInstance(): WebSocketManager;
+    get isConnected(): boolean;
+    get options(): UseWebSocketOptions;
+    /** Acquire a reference. Must be paired with release(). */
+    acquire(): void;
+    /** Release a reference; only close when nobody is using the socket. */
+    release(): void;
+    connect(options: UseWebSocketOptions): void;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private attemptReconnect;
+    private calculateRetryDelay;
+    reconnect(): void;
+    disconnect(): void;
+    private _teardownSocket;
+    send(message: object): boolean;
+}

package/dist/types/src/locales/de.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+    status: {
+        connected: string;
+        disconnected: string;
+    };
+    actions: {
+        retry: string;
+    };
+    'new chat': string;
+    conversations: string;
+    'contact support': string;
+    support: string;
+    options: string;
+    mute: string;
+    delete: string;
+    leave: string;
+    'leave now': string;
+    'select contacts': string;
+    'conversation options': string;
+    system: {
+        renamed: string;
+        created: string;
+        left: string;
+        participants: {
+            addedAndRemoved: string;
+            added: string;
+            removed: string;
+        };
+    };
+};
+export default _default;

package/dist/types/src/locales/en.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+    status: {
+        connected: string;
+        disconnected: string;
+    };
+    actions: {
+        retry: string;
+    };
+    'new chat': string;
+    conversations: string;
+    'contact support': string;
+    support: string;
+    options: string;
+    mute: string;
+    delete: string;
+    leave: string;
+    'leave now': string;
+    'select contacts': string;
+    'conversation options': string;
+    system: {
+        renamed: string;
+        created: string;
+        left: string;
+        participants: {
+            addedAndRemoved: string;
+            added: string;
+            removed: string;
+        };
+    };
+};
+export default _default;

package/dist/types/src/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/mixins/groupMessages.d.ts

@@ -0,0 +1 @@
+export default function groupMessages(messages: any, user: string): unknown[];

package/dist/types/src/mixins/hardCopy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: <T>(obj: T) => T;
+export default _default;

package/dist/types/src/mixins/logger.d.ts

@@ -0,0 +1,8 @@
+interface LoggerFunction {
+    (_message: string, _color?: string): void;
+}
+interface Logger {
+    [key: string]: LoggerFunction;
+}
+declare const logger: Logger;
+export default logger;

package/dist/types/src/mixins/traceable.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+declare const plugin: {
+    install: () => void;
+};
+declare const useTraceable: () => {
+    traceable: <T>(promise: Promise<T>, traceId?: Ref<string | undefined>, options?: {
+        time: number;
+    }) => Promise<T>;
+};
+export default plugin;
+export { useTraceable };

package/dist/types/src/plugins/i18n.d.ts

@@ -0,0 +1,40 @@
+export declare const DEFAULT_LOCALE = "en";
+export declare const SUPPORTED_LOCALES: readonly ["en", "de"];
+export type AppLocale = typeof SUPPORTED_LOCALES[number];
+declare const i18n: import("vue-i18n").I18n<{
+    en: {
+        status: {
+            connected: string;
+            disconnected: string;
+        };
+        actions: {
+            retry: string;
+        };
+        'new chat': string;
+        conversations: string;
+        'contact support': string;
+        support: string;
+        options: string;
+        mute: string;
+        delete: string;
+        leave: string;
+        'leave now': string;
+        'select contacts': string;
+        'conversation options': string;
+        system: {
+            renamed: string;
+            created: string;
+            left: string;
+            participants: {
+                addedAndRemoved: string;
+                added: string;
+                removed: string;
+            };
+        };
+    };
+}, {}, {}, "en" | "de", false>;
+/**
+ * Lazy load locale messages and switch locale.
+ */
+export declare function loadLocale(locale: AppLocale): Promise<AppLocale>;
+export default i18n;

package/dist/types/src/stores/bots.store.d.ts

@@ -0,0 +1,69 @@
+import { type ChatUser } from '@/config/users';
+export type BotStatus = 'idle' | 'connecting' | 'connected' | 'disconnected';
+export interface Bot {
+    id: string;
+    userId: number;
+    name: string;
+    status: BotStatus;
+    autoReply: boolean;
+}
+/** the persisted bots exposed as chat users, so they can be picked as conversation participants */
+export declare function botUsers(): ChatUser[];
+/**
+ * Debugging bots — each behaves like a separate user of the chat. The roster is
+ * persisted to localStorage so it survives reloads; wiring a bot to actually
+ * connect/send comes later.
+ */
+export declare const useBotsStore: import("pinia").StoreDefinition<"bots", Pick<{
+    bots: import("vue").Ref<{
+        id: string;
+        userId: number;
+        name: string;
+        status: BotStatus;
+        autoReply: boolean;
+    }[], Bot[] | {
+        id: string;
+        userId: number;
+        name: string;
+        status: BotStatus;
+        autoReply: boolean;
+    }[]>;
+    addBot: () => string;
+    removeBot: (id: string) => void;
+    setStatus: (id: string, status: BotStatus) => void;
+}, "bots">, Pick<{
+    bots: import("vue").Ref<{
+        id: string;
+        userId: number;
+        name: string;
+        status: BotStatus;
+        autoReply: boolean;
+    }[], Bot[] | {
+        id: string;
+        userId: number;
+        name: string;
+        status: BotStatus;
+        autoReply: boolean;
+    }[]>;
+    addBot: () => string;
+    removeBot: (id: string) => void;
+    setStatus: (id: string, status: BotStatus) => void;
+}, never>, Pick<{
+    bots: import("vue").Ref<{
+        id: string;
+        userId: number;
+        name: string;
+        status: BotStatus;
+        autoReply: boolean;
+    }[], Bot[] | {
+        id: string;
+        userId: number;
+        name: string;
+        status: BotStatus;
+        autoReply: boolean;
+    }[]>;
+    addBot: () => string;
+    removeBot: (id: string) => void;
+    setStatus: (id: string, status: BotStatus) => void;
+}, "addBot" | "removeBot" | "setStatus">>;
+export default useBotsStore;

package/dist/types/src/stores/calls.store.d.ts

@@ -0,0 +1,14 @@
+export declare const useCallStore: import("pinia").StoreDefinition<"calls", Pick<{
+    calls: import("vue").Ref<Record<string, "rejected" | "pending" | "resolved">, Record<string, "rejected" | "pending" | "resolved">>;
+    addCall: () => string;
+    updateCall: (id: string, state: "pending" | "resolved" | "rejected") => void;
+}, "calls">, Pick<{
+    calls: import("vue").Ref<Record<string, "rejected" | "pending" | "resolved">, Record<string, "rejected" | "pending" | "resolved">>;
+    addCall: () => string;
+    updateCall: (id: string, state: "pending" | "resolved" | "rejected") => void;
+}, never>, Pick<{
+    calls: import("vue").Ref<Record<string, "rejected" | "pending" | "resolved">, Record<string, "rejected" | "pending" | "resolved">>;
+    addCall: () => string;
+    updateCall: (id: string, state: "pending" | "resolved" | "rejected") => void;
+}, "addCall" | "updateCall">>;
+export default useCallStore;