@bloonio/chat-angular 0.1.0

package/README.md

@@ -0,0 +1,112 @@
+# @bloonio/chat-angular
+
+Angular library for the bloonio chat PaaS. Standalone components,
+signals-based service, SSR-safe. Built on `@bloonio/chat-client-core`.
+
+Targets Angular 17+ (signals stable + `@if`/`@for` control flow + `afterNextRender`).
+
+## Install
+
+```bash
+npm install @bloonio/chat-angular @bloonio/chat-client-core
+```
+
+Then import the stylesheet once in your global stylesheet (`styles.css`):
+
+```css
+@import "@bloonio/chat-angular/styles.css";
+```
+
+## Two-minute integration
+
+```ts
+// app.config.ts
+import { ApplicationConfig } from '@angular/core';
+import { provideBloonioChat } from '@bloonio/chat-angular';
+import { inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideBloonioChat({
+      tenantId: '019e4ae7-…',
+      publicKey: 'pk_…',
+      baseUrl: 'https://chat-relay.example.com',
+      locale: 'fr',
+      // Optional — bind anonymous sessions to your authenticated users.
+      // Your backend computes HMAC-SHA256(tenant_secret, user_id) once
+      // per logged-in visitor.
+      visitorTokenProvider: () => inject(HttpClient)
+        .get<{token: string}>('/api/chat/visitor-token')
+        .pipe(map(r => r.token)),                // "userId:signature"
+    }),
+  ],
+};
+```
+
+```ts
+// any standalone component — drop the launcher anywhere
+import { BloonioChatLauncherComponent } from '@bloonio/chat-angular';
+
+@Component({
+  standalone: true,
+  imports: [BloonioChatLauncherComponent],
+  template: `<router-outlet /> <bloonio-chat-launcher />`,
+})
+export class AppComponent {}
+```
+
+## Three rendering modes
+
+| Mode | Component | When |
+|---|---|---|
+| **Floating** | `<bloonio-chat-launcher />` (+ the launcher renders the panel itself on toggle) | Tidio-style — a bubble in the corner that expands on click. |
+| **Docked panel** | `<bloonio-chat-panel mode="docked" />` | Always-on chat in a sidebar / dedicated column. No floating chrome. |
+| **Headless thread** | `<bloonio-chat-thread />` | Just messages + input, no header. Embed inside your own support pages. |
+
+All three share the same `BloonioChatService`, so a launcher and a thread on the same page stay in sync.
+
+## Programmatic access
+
+```ts
+import { Component, inject } from '@angular/core';
+import { BloonioChatService } from '@bloonio/chat-angular';
+
+@Component({...})
+export class SupportButton {
+  private readonly chat = inject(BloonioChatService);
+
+  readonly unread = this.chat.unreadCount;        // Signal<number>
+  readonly typing = this.chat.botTyping;          // Signal<boolean>
+
+  open() { this.chat.openPanel(); }
+  send(content: string) { this.chat.sendMessage(content); }
+}
+```
+
+## SSR
+
+Bootstrap (`fetchWidgetConfig`) is deferred via `afterNextRender` so the
+server-side render produces zero network calls. The components render
+their static shell during pre-render and connect when the browser hydrates.
+
+For tenants on `@angular/ssr`, no extra configuration is needed.
+
+## Build
+
+```bash
+npm install
+npm run build       # ng-packagr → dist/ (fesm2022 + .d.ts + Ivy partial)
+npm run typecheck   # tsc --noEmit -p tsconfig.lib.json
+```
+
+Every component uses inline `template:` strings, so there are no separate
+template files to ship — ng-packagr emits the Angular Package Format (APF)
+that the consumer's Ivy compiler links at build time.
+
+## Reference
+
+- `@bloonio/chat-client-core` — transport + protocol layer this library wraps
+- `@bloonio/chat-widget` — the Preact embeddable using the same core lib
+- `bloonio_chat_api/docs/12_PAAS_CONVERSION_PLAN.md` — full PaaS plan, §7.3 + §13.9

package/esm2022/bloonio-chat-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvb25pby1jaGF0LWFuZ3VsYXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmxvb25pby1jaGF0LWFuZ3VsYXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/index.mjs

@@ -0,0 +1,25 @@
+/**
+ * @bloonio/chat-angular — Angular library for the bloonio chat PaaS.
+ *
+ * Public surface:
+ *   - {@link provideBloonioChat} — environment-provider factory for app.config.ts
+ *   - {@link BloonioChatService}  — signals-based reactive state
+ *   - Three standalone components:
+ *       <bloonio-chat-launcher>   floating bubble (collapsed)
+ *       <bloonio-chat-panel>      expandable card (the full chat UX)
+ *       <bloonio-chat-thread>     headless variant for inline embedding
+ *
+ * Styles ship separately at `@bloonio/chat-angular/styles.css` — import once
+ * in your global stylesheet (see README).
+ */
+export { provideBloonioChat, BLOONIO_CHAT_CONFIG, injectBloonioChatConfig } from './lib/bloonio-chat.token';
+export { BloonioChatService } from './lib/bloonio-chat.service';
+export { BloonioChatLauncherComponent } from './lib/components/launcher.component';
+export { BloonioChatPanelComponent, } from './lib/components/panel.component';
+export { BloonioChatThreadComponent } from './lib/components/thread.component';
+export { MessageListComponent } from './lib/components/message-list.component';
+export { InputBarComponent } from './lib/components/input-bar.component';
+export { QuickRepliesComponent } from './lib/components/quick-replies.component';
+export { BloonioChatError, BloonioChatNetworkError, BloonioChatServerError, BloonioChatAuthError, } from '@bloonio/chat-client-core';
+export const VERSION = '0.1.0';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/bloonio-chat.service.mjs

@@ -0,0 +1,311 @@
+/**
+ * BloonioChatService — signals-based reactive state container.
+ *
+ * Mirrors the Preact widget's `Widget.tsx` state machine but uses Angular
+ * signals so templates auto-track the slots they read. Public surface:
+ *
+ *   readonly bootstrap = signal<WidgetBootstrapConfig | null>(null);
+ *   readonly session   = signal<CreateVisitorSessionResponse | null>(null);
+ *   readonly messages  = signal<ChatMessage[]>([]);
+ *   readonly botTyping = signal(false);
+ *   readonly open      = signal(false);
+ *   readonly connecting= signal(false);
+ *   readonly unreadCount = computed(...);
+ *
+ *   async open(): Promise<void>
+ *   close(): void
+ *   async toggle(): Promise<void>
+ *   sendMessage(text: string): void
+ *
+ * SSR-safe: every transport call (fetch, WebSocket) is gated behind a
+ * platform check via `afterNextRender()` so server pre-rendering doesn't
+ * try to open sockets.
+ */
+import { afterNextRender, computed, DestroyRef, inject, Injectable, signal, } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { PLATFORM_ID } from '@angular/core';
+import { firstValueFrom, isObservable } from 'rxjs';
+import { ChatClient, WSClient, } from '@bloonio/chat-client-core';
+import { injectBloonioChatConfig } from './bloonio-chat.token';
+import * as i0 from "@angular/core";
+export class BloonioChatService {
+    config = injectBloonioChatConfig();
+    platformId = inject(PLATFORM_ID);
+    destroyRef = inject(DestroyRef);
+    /** True when running in the browser (vs. server pre-render). */
+    isBrowser = isPlatformBrowser(this.platformId);
+    /** Bootstrap config — populated by the first `loadBootstrap()` call. */
+    bootstrap = signal(null);
+    /** Visitor session (id + JWT + expires_at) — set lazily on first open. */
+    session = signal(null);
+    /** Message log, oldest → newest. */
+    messages = signal([]);
+    /** True between bot's typing(start) and typing(stop) frames. */
+    botTyping = signal(false);
+    /** Panel visibility — drives Launcher / Panel rendering. */
+    open = signal(false);
+    /** True while `ensureSession()` is in flight (initial WS handshake). */
+    connecting = signal(false);
+    /** Set when the WS handshake fails permanently (e.g. tenant suspended). */
+    fatalError = signal(null);
+    /** Number of bot/agent messages received while the panel was closed.
+     *  Resets to 0 the moment the panel opens. */
+    _seenCount = signal(0);
+    unreadCount = computed(() => {
+        if (this.open())
+            return 0;
+        const total = this.messages().filter((m) => m.from === 'bot' || m.from === 'agent').length;
+        return Math.max(0, total - this._seenCount());
+    });
+    client = null;
+    ws = null;
+    bootstrapPromise = null;
+    sessionPromise = null;
+    constructor() {
+        // SSR safety: schedule the initial bootstrap fetch on first browser render.
+        afterNextRender(() => {
+            this.loadBootstrap();
+        });
+        this.destroyRef.onDestroy(() => {
+            this.ws?.close();
+            this.ws = null;
+        });
+    }
+    // ── Public methods ─────────────────────────────────────────────────────
+    /** Toggle panel visibility. First open also opens the WS session. */
+    async toggle() {
+        const next = !this.open();
+        this.open.set(next);
+        if (next) {
+            this._seenCount.set(this.messages().filter((m) => m.from === 'bot' || m.from === 'agent').length);
+            await this.ensureSession();
+        }
+    }
+    /** Force the panel open. */
+    async openPanel() {
+        if (this.open())
+            return;
+        await this.toggle();
+    }
+    /** Force the panel closed. Keeps the WS open so reopening is instant. */
+    closePanel() {
+        this.open.set(false);
+    }
+    /** Send a visitor message. No-op if the WS isn't connected. */
+    sendMessage(content) {
+        const trimmed = content.trim();
+        if (!trimmed || !this.ws)
+            return;
+        const clientMsgId = `c_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        this.messages.update((prev) => [
+            ...prev,
+            {
+                id: clientMsgId,
+                client_msg_id: clientMsgId,
+                from: 'visitor',
+                content: trimmed,
+                pending: true,
+            },
+        ]);
+        this.ws.send({ type: 'msg', client_msg_id: clientMsgId, content: trimmed });
+    }
+    // ── Internals ──────────────────────────────────────────────────────────
+    async loadBootstrap() {
+        if (!this.isBrowser)
+            return null;
+        if (this.bootstrap())
+            return this.bootstrap();
+        if (this.bootstrapPromise)
+            return this.bootstrapPromise;
+        this.bootstrapPromise = (async () => {
+            try {
+                const client = this.getClient();
+                const cfg = await client.fetchWidgetConfig({
+                    tenantId: this.config.tenantId,
+                    widgetPublicKey: this.config.publicKey,
+                    origin: this.resolvedOrigin(),
+                });
+                this.bootstrap.set(cfg);
+                return cfg;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : 'unknown error';
+                this.fatalError.set(`Bootstrap failed: ${msg}`);
+                return null;
+            }
+        })();
+        return this.bootstrapPromise;
+    }
+    async ensureSession() {
+        if (!this.isBrowser)
+            return null;
+        if (this.session())
+            return this.session();
+        if (this.sessionPromise)
+            return this.sessionPromise;
+        this.connecting.set(true);
+        this.sessionPromise = (async () => {
+            try {
+                // Make sure bootstrap is resolved first — the visibility/online
+                // flags it carries influence whether we connect at all.
+                await this.loadBootstrap();
+                const client = this.getClient();
+                const session = await client.createVisitorSession({
+                    tenantId: this.config.tenantId,
+                    widgetPublicKey: this.config.publicKey,
+                    origin: this.resolvedOrigin(),
+                    locale: this.config.locale ?? 'fr',
+                    metadata: this.config.metadata ?? {},
+                });
+                this.session.set(session);
+                this.openWebSocket(session);
+                // Optional: identify the visitor server-side if the consumer wired
+                // a token provider.
+                this.tryIdentify(session).catch(() => undefined);
+                return session;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : 'unknown error';
+                this.fatalError.set(`Session failed: ${msg}`);
+                return null;
+            }
+            finally {
+                this.connecting.set(false);
+            }
+        })();
+        return this.sessionPromise;
+    }
+    openWebSocket(session) {
+        if (this.ws)
+            return;
+        const ws = new WSClient({
+            baseUrl: this.config.baseUrl,
+            visitorToken: session.visitor_token,
+            heartbeatIntervalMs: 30_000,
+        }, {
+            onWelcome: () => undefined,
+            onMessage: (frame) => {
+                this.messages.update((prev) => [
+                    ...prev,
+                    { id: frame.id, from: frame.from, content: frame.content },
+                ]);
+            },
+            onAck: (frame) => {
+                this.messages.update((prev) => prev.map((m) => m.client_msg_id === frame.client_msg_id
+                    ? { ...m, id: frame.server_msg_id, pending: false }
+                    : m));
+            },
+            onTyping: (frame) => {
+                if (frame.from === 'bot' || frame.from === 'agent') {
+                    this.botTyping.set(frame.state === 'start');
+                }
+            },
+            onError: (frame) => {
+                this.messages.update((prev) => [
+                    ...prev,
+                    { id: `err_${Date.now()}`, from: 'system', content: `Error: ${frame.message}` },
+                ]);
+            },
+            // Phase 10c — agent takeover visibility. Renders a system message
+            // and clears any stale bot-typing indicator (the bot's mid-stream
+            // turn may have been pre-empted by the operator claim).
+            onAgentJoined: (frame) => {
+                this.messages.update((prev) => [
+                    ...prev,
+                    {
+                        id: `sys_join_${Date.now()}`,
+                        from: 'system',
+                        content: `${frame.agent_display_name} has joined the chat.`,
+                    },
+                ]);
+                this.botTyping.set(false);
+            },
+            onAgentLeft: () => {
+                this.messages.update((prev) => [
+                    ...prev,
+                    {
+                        id: `sys_left_${Date.now()}`,
+                        from: 'system',
+                        content: 'The agent has left the chat.',
+                    },
+                ]);
+                this.botTyping.set(false);
+            },
+            // Phase 10f — chat_api opened a support ticket.
+            onTicketCreated: (frame) => {
+                const sla = frame.sla_hours === 1
+                    ? 'within 1h'
+                    : frame.sla_hours <= 24
+                        ? `within ${frame.sla_hours}h`
+                        : `within ${Math.round(frame.sla_hours / 24)}d`;
+                this.messages.update((prev) => [
+                    ...prev,
+                    {
+                        id: `sys_ticket_${frame.ticket_id}`,
+                        from: 'system',
+                        content: `🎫 Support ticket #${frame.ticket_number} created — ` +
+                            `${frame.category} · ${frame.priority}. ` +
+                            `We'll follow up ${sla}.`,
+                    },
+                ]);
+            },
+        });
+        this.ws = ws;
+        ws.connect();
+    }
+    async tryIdentify(session) {
+        const provider = this.config.visitorTokenProvider;
+        if (!provider)
+            return;
+        let raw;
+        const result = provider();
+        if (typeof result === 'string') {
+            raw = result;
+        }
+        else if (isObservable(result)) {
+            raw = await firstValueFrom(result);
+        }
+        else {
+            raw = await result;
+        }
+        if (!raw)
+            return;
+        // Caller's token is `userId:signature` (colon-delimited). Falling back
+        // to plain user_id when no colon is present is too easy to misuse —
+        // require explicit signature to avoid identity forgery footguns.
+        const sep = raw.indexOf(':');
+        if (sep < 0) {
+            this.fatalError.set('visitorTokenProvider returned a value without "userId:signature" — refusing to identify.');
+            return;
+        }
+        const userId = raw.slice(0, sep);
+        const userSignature = raw.slice(sep + 1);
+        await this.getClient().identifyVisitor({
+            visitorToken: session.visitor_token,
+            userId,
+            userSignature,
+        });
+    }
+    getClient() {
+        if (!this.client) {
+            this.client = new ChatClient({ baseUrl: this.config.baseUrl });
+        }
+        return this.client;
+    }
+    resolvedOrigin() {
+        if (this.config.origin)
+            return this.config.origin;
+        if (this.isBrowser && typeof window !== 'undefined') {
+            return window.location.origin;
+        }
+        // SSR-safe fallback; the relay validates origins server-side anyway.
+        return '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BloonioChatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BloonioChatService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BloonioChatService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bloonio-chat.service.js","sourceRoot":"","sources":["../../../src/lib/bloonio-chat.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * BloonioChatService — signals-based reactive state container.\n *\n * Mirrors the Preact widget's `Widget.tsx` state machine but uses Angular\n * signals so templates auto-track the slots they read. Public surface:\n *\n *   readonly bootstrap = signal<WidgetBootstrapConfig | null>(null);\n *   readonly session   = signal<CreateVisitorSessionResponse | null>(null);\n *   readonly messages  = signal<ChatMessage[]>([]);\n *   readonly botTyping = signal(false);\n *   readonly open      = signal(false);\n *   readonly connecting= signal(false);\n *   readonly unreadCount = computed(...);\n *\n *   async open(): Promise<void>\n *   close(): void\n *   async toggle(): Promise<void>\n *   sendMessage(text: string): void\n *\n * SSR-safe: every transport call (fetch, WebSocket) is gated behind a\n * platform check via `afterNextRender()` so server pre-rendering doesn't\n * try to open sockets.\n */\n\nimport {\n  afterNextRender,\n  computed,\n  DestroyRef,\n  inject,\n  Injectable,\n  signal,\n  type Signal,\n} from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { PLATFORM_ID } from '@angular/core';\nimport { firstValueFrom, isObservable } from 'rxjs';\n\nimport {\n  ChatClient,\n  WSClient,\n  type CreateVisitorSessionResponse,\n  type ServerMsgFrame,\n  type WidgetBootstrapConfig,\n} from '@bloonio/chat-client-core';\n\nimport { injectBloonioChatConfig } from './bloonio-chat.token';\n\nexport interface ChatMessage {\n  id: string;\n  from: 'visitor' | 'bot' | 'agent' | 'system';\n  content: string;\n  pending?: boolean;\n  client_msg_id?: string;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class BloonioChatService {\n  private readonly config = injectBloonioChatConfig();\n  private readonly platformId = inject(PLATFORM_ID);\n  private readonly destroyRef = inject(DestroyRef);\n\n  /** True when running in the browser (vs. server pre-render). */\n  private readonly isBrowser = isPlatformBrowser(this.platformId);\n\n  /** Bootstrap config — populated by the first `loadBootstrap()` call. */\n  readonly bootstrap = signal<WidgetBootstrapConfig | null>(null);\n  /** Visitor session (id + JWT + expires_at) — set lazily on first open. */\n  readonly session = signal<CreateVisitorSessionResponse | null>(null);\n  /** Message log, oldest → newest. */\n  readonly messages = signal<ChatMessage[]>([]);\n  /** True between bot's typing(start) and typing(stop) frames. */\n  readonly botTyping = signal(false);\n  /** Panel visibility — drives Launcher / Panel rendering. */\n  readonly open = signal(false);\n  /** True while `ensureSession()` is in flight (initial WS handshake). */\n  readonly connecting = signal(false);\n  /** Set when the WS handshake fails permanently (e.g. tenant suspended). */\n  readonly fatalError = signal<string | null>(null);\n\n  /** Number of bot/agent messages received while the panel was closed.\n   *  Resets to 0 the moment the panel opens. */\n  private readonly _seenCount = signal(0);\n  readonly unreadCount: Signal<number> = computed(() => {\n    if (this.open()) return 0;\n    const total = this.messages().filter(\n      (m) => m.from === 'bot' || m.from === 'agent',\n    ).length;\n    return Math.max(0, total - this._seenCount());\n  });\n\n  private client: ChatClient | null = null;\n  private ws: WSClient | null = null;\n  private bootstrapPromise: Promise<WidgetBootstrapConfig | null> | null = null;\n  private sessionPromise: Promise<CreateVisitorSessionResponse | null> | null = null;\n\n  constructor() {\n    // SSR safety: schedule the initial bootstrap fetch on first browser render.\n    afterNextRender(() => {\n      this.loadBootstrap();\n    });\n\n    this.destroyRef.onDestroy(() => {\n      this.ws?.close();\n      this.ws = null;\n    });\n  }\n\n  // ── Public methods ─────────────────────────────────────────────────────\n\n  /** Toggle panel visibility. First open also opens the WS session. */\n  async toggle(): Promise<void> {\n    const next = !this.open();\n    this.open.set(next);\n    if (next) {\n      this._seenCount.set(\n        this.messages().filter((m) => m.from === 'bot' || m.from === 'agent').length,\n      );\n      await this.ensureSession();\n    }\n  }\n\n  /** Force the panel open. */\n  async openPanel(): Promise<void> {\n    if (this.open()) return;\n    await this.toggle();\n  }\n\n  /** Force the panel closed. Keeps the WS open so reopening is instant. */\n  closePanel(): void {\n    this.open.set(false);\n  }\n\n  /** Send a visitor message. No-op if the WS isn't connected. */\n  sendMessage(content: string): void {\n    const trimmed = content.trim();\n    if (!trimmed || !this.ws) return;\n    const clientMsgId = `c_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;\n    this.messages.update((prev) => [\n      ...prev,\n      {\n        id: clientMsgId,\n        client_msg_id: clientMsgId,\n        from: 'visitor',\n        content: trimmed,\n        pending: true,\n      },\n    ]);\n    this.ws.send({ type: 'msg', client_msg_id: clientMsgId, content: trimmed });\n  }\n\n  // ── Internals ──────────────────────────────────────────────────────────\n\n  private async loadBootstrap(): Promise<WidgetBootstrapConfig | null> {\n    if (!this.isBrowser) return null;\n    if (this.bootstrap()) return this.bootstrap();\n    if (this.bootstrapPromise) return this.bootstrapPromise;\n\n    this.bootstrapPromise = (async () => {\n      try {\n        const client = this.getClient();\n        const cfg = await client.fetchWidgetConfig({\n          tenantId: this.config.tenantId,\n          widgetPublicKey: this.config.publicKey,\n          origin: this.resolvedOrigin(),\n        });\n        this.bootstrap.set(cfg);\n        return cfg;\n      } catch (err) {\n        const msg = err instanceof Error ? err.message : 'unknown error';\n        this.fatalError.set(`Bootstrap failed: ${msg}`);\n        return null;\n      }\n    })();\n    return this.bootstrapPromise;\n  }\n\n  private async ensureSession(): Promise<CreateVisitorSessionResponse | null> {\n    if (!this.isBrowser) return null;\n    if (this.session()) return this.session();\n    if (this.sessionPromise) return this.sessionPromise;\n\n    this.connecting.set(true);\n    this.sessionPromise = (async () => {\n      try {\n        // Make sure bootstrap is resolved first — the visibility/online\n        // flags it carries influence whether we connect at all.\n        await this.loadBootstrap();\n\n        const client = this.getClient();\n        const session = await client.createVisitorSession({\n          tenantId: this.config.tenantId,\n          widgetPublicKey: this.config.publicKey,\n          origin: this.resolvedOrigin(),\n          locale: this.config.locale ?? 'fr',\n          metadata: this.config.metadata ?? {},\n        });\n        this.session.set(session);\n        this.openWebSocket(session);\n        // Optional: identify the visitor server-side if the consumer wired\n        // a token provider.\n        this.tryIdentify(session).catch(() => undefined);\n        return session;\n      } catch (err) {\n        const msg = err instanceof Error ? err.message : 'unknown error';\n        this.fatalError.set(`Session failed: ${msg}`);\n        return null;\n      } finally {\n        this.connecting.set(false);\n      }\n    })();\n    return this.sessionPromise;\n  }\n\n  private openWebSocket(session: CreateVisitorSessionResponse): void {\n    if (this.ws) return;\n    const ws = new WSClient(\n      {\n        baseUrl: this.config.baseUrl,\n        visitorToken: session.visitor_token,\n        heartbeatIntervalMs: 30_000,\n      },\n      {\n        onWelcome: () => undefined,\n        onMessage: (frame: ServerMsgFrame) => {\n          this.messages.update((prev) => [\n            ...prev,\n            { id: frame.id, from: frame.from, content: frame.content },\n          ]);\n        },\n        onAck: (frame) => {\n          this.messages.update((prev) =>\n            prev.map((m) =>\n              m.client_msg_id === frame.client_msg_id\n                ? { ...m, id: frame.server_msg_id, pending: false }\n                : m,\n            ),\n          );\n        },\n        onTyping: (frame) => {\n          if (frame.from === 'bot' || frame.from === 'agent') {\n            this.botTyping.set(frame.state === 'start');\n          }\n        },\n        onError: (frame) => {\n          this.messages.update((prev) => [\n            ...prev,\n            { id: `err_${Date.now()}`, from: 'system', content: `Error: ${frame.message}` },\n          ]);\n        },\n        // Phase 10c — agent takeover visibility. Renders a system message\n        // and clears any stale bot-typing indicator (the bot's mid-stream\n        // turn may have been pre-empted by the operator claim).\n        onAgentJoined: (frame) => {\n          this.messages.update((prev) => [\n            ...prev,\n            {\n              id: `sys_join_${Date.now()}`,\n              from: 'system',\n              content: `${frame.agent_display_name} has joined the chat.`,\n            },\n          ]);\n          this.botTyping.set(false);\n        },\n        onAgentLeft: () => {\n          this.messages.update((prev) => [\n            ...prev,\n            {\n              id: `sys_left_${Date.now()}`,\n              from: 'system',\n              content: 'The agent has left the chat.',\n            },\n          ]);\n          this.botTyping.set(false);\n        },\n        // Phase 10f — chat_api opened a support ticket.\n        onTicketCreated: (frame) => {\n          const sla =\n            frame.sla_hours === 1\n              ? 'within 1h'\n              : frame.sla_hours <= 24\n                ? `within ${frame.sla_hours}h`\n                : `within ${Math.round(frame.sla_hours / 24)}d`;\n          this.messages.update((prev) => [\n            ...prev,\n            {\n              id: `sys_ticket_${frame.ticket_id}`,\n              from: 'system',\n              content:\n                `🎫 Support ticket #${frame.ticket_number} created — ` +\n                `${frame.category} · ${frame.priority}. ` +\n                `We'll follow up ${sla}.`,\n            },\n          ]);\n        },\n      },\n    );\n    this.ws = ws;\n    ws.connect();\n  }\n\n  private async tryIdentify(\n    session: CreateVisitorSessionResponse,\n  ): Promise<void> {\n    const provider = this.config.visitorTokenProvider;\n    if (!provider) return;\n\n    let raw: string | null | undefined;\n    const result = provider();\n    if (typeof result === 'string') {\n      raw = result;\n    } else if (isObservable(result)) {\n      raw = await firstValueFrom(result);\n    } else {\n      raw = await result;\n    }\n    if (!raw) return;\n\n    // Caller's token is `userId:signature` (colon-delimited). Falling back\n    // to plain user_id when no colon is present is too easy to misuse —\n    // require explicit signature to avoid identity forgery footguns.\n    const sep = raw.indexOf(':');\n    if (sep < 0) {\n      this.fatalError.set(\n        'visitorTokenProvider returned a value without \"userId:signature\" — refusing to identify.',\n      );\n      return;\n    }\n    const userId = raw.slice(0, sep);\n    const userSignature = raw.slice(sep + 1);\n    await this.getClient().identifyVisitor({\n      visitorToken: session.visitor_token,\n      userId,\n      userSignature,\n    });\n  }\n\n  private getClient(): ChatClient {\n    if (!this.client) {\n      this.client = new ChatClient({ baseUrl: this.config.baseUrl });\n    }\n    return this.client;\n  }\n\n  private resolvedOrigin(): string {\n    if (this.config.origin) return this.config.origin;\n    if (this.isBrowser && typeof window !== 'undefined') {\n      return window.location.origin;\n    }\n    // SSR-safe fallback; the relay validates origins server-side anyway.\n    return '';\n  }\n}\n"]}

package/esm2022/lib/bloonio-chat.token.mjs

@@ -0,0 +1,46 @@
+/**
+ * Dependency-injection plumbing for the Angular chat SDK.
+ *
+ * Consumers wire the SDK into their app via the standard Angular pattern
+ * documented in docs/12 §7.3:
+ *
+ *   // app.config.ts
+ *   export const appConfig: ApplicationConfig = {
+ *     providers: [
+ *       provideBloonioChat({
+ *         tenantId: env.CHAT_TENANT_ID,
+ *         publicKey: env.CHAT_PUBLIC_KEY,
+ *         baseUrl: 'https://chat-relay.bloonio.com',
+ *         visitorTokenProvider: () => inject(HttpClient).get<{token: string}>(
+ *           '/api/chat/visitor-token'
+ *         ).pipe(map(r => r.token)),
+ *         locale: 'fr',
+ *       }),
+ *     ],
+ *   };
+ */
+import { inject, InjectionToken, makeEnvironmentProviders, } from '@angular/core';
+export const BLOONIO_CHAT_CONFIG = new InjectionToken('BLOONIO_CHAT_CONFIG');
+/** Standalone-provider factory.
+ *
+ * Returns ``EnvironmentProviders`` so consumers can spread it into
+ * ``app.config.ts``'s providers array. The service itself is
+ * ``providedIn: 'root'`` so we don't need an explicit provider entry — we
+ * only need the config token to be registered.
+ */
+export function provideBloonioChat(config) {
+    return makeEnvironmentProviders([
+        { provide: BLOONIO_CHAT_CONFIG, useValue: config },
+    ]);
+}
+/** Internal accessor used by the components to fail loud when the
+ *  consumer forgot ``provideBloonioChat()``. */
+export function injectBloonioChatConfig() {
+    const cfg = inject(BLOONIO_CHAT_CONFIG, { optional: true });
+    if (!cfg) {
+        throw new Error('[bloonio-chat-angular] provideBloonioChat() was not called in your app.config.ts. ' +
+            'Add it to providers: [...] alongside provideRouter/provideHttpClient.');
+    }
+    return cfg;
+}
+//# sourceMappingURL=data:application/json;base64,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