@jokkoo/sdk-web 0.1.0

package/dist/index.js

@@ -0,0 +1,1291 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+
+// src/core/debug.ts
+var LOG_PREFIX = "[Jokkoo]";
+function noop() {
+}
+function createNoopLogger() {
+  return {
+    log: noop,
+    warn: noop,
+    error: noop,
+    request: noop,
+    response: noop,
+    requestError: noop
+  };
+}
+function createDebugLogger(enabled) {
+  if (!enabled) {
+    return createNoopLogger();
+  }
+  return {
+    log(message, ...details) {
+      if (details.length > 0) {
+        console.log(`${LOG_PREFIX} ${message}`, ...details);
+        return;
+      }
+      console.log(`${LOG_PREFIX} ${message}`);
+    },
+    warn(message, ...details) {
+      if (details.length > 0) {
+        console.warn(`${LOG_PREFIX} ${message}`, ...details);
+        return;
+      }
+      console.warn(`${LOG_PREFIX} ${message}`);
+    },
+    error(message, ...details) {
+      if (details.length > 0) {
+        console.error(`${LOG_PREFIX} ${message}`, ...details);
+        return;
+      }
+      console.error(`${LOG_PREFIX} ${message}`);
+    },
+    request(method, url, details) {
+      if (details) {
+        console.log(`${LOG_PREFIX} \u2192 ${method} ${url}`, details);
+        return;
+      }
+      console.log(`${LOG_PREFIX} \u2192 ${method} ${url}`);
+    },
+    response(method, url, status, durationMs, details) {
+      const summary = `${LOG_PREFIX} \u2190 ${method} ${url} ${status} (${durationMs}ms)`;
+      if (details) {
+        console.log(summary, details);
+        return;
+      }
+      console.log(summary);
+    },
+    requestError(method, url, durationMs, error) {
+      console.error(`${LOG_PREFIX} \u2715 ${method} ${url} (${durationMs}ms)`, error);
+    }
+  };
+}
+function redactToken(token) {
+  if (token.length < 9) {
+    return "***";
+  }
+  return `${token.slice(0, 4)}\u2026${token.slice(-4)}`;
+}
+
+// src/api/client.ts
+var CLIENT_TOKEN_HEADER = "x-client-token";
+var USER_TOKEN_HEADER = "x-user-token";
+var JokkooApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "JokkooApiError";
+  }
+};
+var JokkooApiClient = class {
+  constructor(config, tokenManager) {
+    this.config = config;
+    this.tokenManager = tokenManager;
+    this.debug = createDebugLogger(config.debug);
+  }
+  resolveUrl(path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    return `${this.config.baseUrl}${path}`;
+  }
+  async getConversations(limit, offset) {
+    return this.request(
+      "GET",
+      `/api/conversations?limit=${limit}&offset=${offset}`
+    );
+  }
+  async getUnreadCount() {
+    return this.request("GET", "/api/conversations/unread-count");
+  }
+  async markAsRead(conversationId) {
+    await this.request("POST", `/api/conversations/${conversationId}/read`);
+  }
+  async getMessages(conversationId, limit, offset) {
+    return this.request(
+      "GET",
+      `/api/conversations/${conversationId}/messages?limit=${limit}&offset=${offset}`
+    );
+  }
+  async sendMessage(payload) {
+    return this.request("POST", "/api/conversations/messages", {
+      body: JSON.stringify(payload)
+    });
+  }
+  async requestUploadUrl(fileName, mimeType, provider = "s3") {
+    return this.request(
+      "POST",
+      "/api/storage/sdk/upload-url",
+      {
+        body: JSON.stringify({ provider, fileName, mimeType })
+      }
+    );
+  }
+  async confirmUpload(fileId) {
+    return this.request(
+      "POST",
+      `/api/storage/sdk/confirm/${fileId}`
+    );
+  }
+  async getDownloadUrl(fileId) {
+    return this.request(
+      "GET",
+      `/api/storage/sdk/download-url/${fileId}`
+    );
+  }
+  async getConversationPolicies() {
+    return this.request("GET", "/api/conversations/policies");
+  }
+  async recordSatisfaction(conversationId, score) {
+    await this.request("POST", `/api/conversations/${conversationId}/satisfaction`, {
+      body: JSON.stringify({ score })
+    });
+  }
+  async request(method, path, init, isRetry = false) {
+    const userToken = await this.tokenManager.getToken();
+    const url = `${this.config.baseUrl}${path}`;
+    const httpMethod = init?.method ?? method;
+    const startedAt = Date.now();
+    let requestBody;
+    if (init?.body && typeof init.body === "string") {
+      try {
+        requestBody = JSON.parse(init.body);
+      } catch {
+        requestBody = init.body;
+      }
+    }
+    this.debug.request(httpMethod, url, {
+      clientToken: redactToken(this.config.clientToken),
+      userToken: redactToken(userToken),
+      body: requestBody
+    });
+    try {
+      const response = await fetch(url, {
+        ...init,
+        method: httpMethod,
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          [CLIENT_TOKEN_HEADER]: this.config.clientToken,
+          [USER_TOKEN_HEADER]: userToken,
+          ...init?.headers
+        }
+      });
+      const durationMs = Date.now() - startedAt;
+      if (!response.ok) {
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          body = void 0;
+        }
+        const message = typeof body === "object" && body !== null && "message" in body && typeof body.message === "string" ? body.message : `Request failed with status ${response.status}`;
+        if (response.status === 401 && !isRetry) {
+          this.debug.log("Received 401. Invalidating token and retrying once.");
+          this.tokenManager.invalidateCachedToken();
+          await this.tokenManager.refreshToken();
+          return this.request(method, path, init, true);
+        }
+        const error = new JokkooApiError(message, response.status, body);
+        this.debug.requestError(httpMethod, url, durationMs, {
+          status: response.status,
+          message,
+          body
+        });
+        throw error;
+      }
+      if (response.status === 204) {
+        this.debug.response(httpMethod, url, response.status, durationMs);
+        return void 0;
+      }
+      const responseText = await response.text();
+      if (!responseText.trim()) {
+        this.debug.response(httpMethod, url, response.status, durationMs);
+        return void 0;
+      }
+      const data = JSON.parse(responseText);
+      this.debug.response(httpMethod, url, response.status, durationMs, summarizeResponse(data));
+      return data;
+    } catch (error) {
+      if (!(error instanceof JokkooApiError)) {
+        const durationMs = Date.now() - startedAt;
+        this.debug.requestError(httpMethod, url, durationMs, error);
+      }
+      throw error;
+    }
+  }
+};
+function summarizeResponse(data) {
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  if ("data" in data && Array.isArray(data.data)) {
+    const paginated = data;
+    return {
+      itemCount: paginated.data.length,
+      total: paginated.total,
+      limit: paginated.limit,
+      offset: paginated.offset
+    };
+  }
+  if ("id" in data) {
+    const entity = data;
+    return {
+      id: entity.id,
+      conversationId: entity.conversationId
+    };
+  }
+  return void 0;
+}
+
+// src/api/types.ts
+var NEW_CONVERSATION_ID = 0;
+
+// src/realtime/realtime-events.ts
+var REALTIME_EVENTS = {
+  ping: "ping",
+  pong: "pong",
+  messageCreated: "message.created",
+  conversationCreated: "conversation.created",
+  conversationUpdated: "conversation.updated"
+};
+var REALTIME_NAMESPACE = "/sdk";
+
+// src/realtime/realtime-client.ts
+var JokkooRealtimeClient = class {
+  constructor(config, tokenManager) {
+    this.config = config;
+    this.tokenManager = tokenManager;
+    this.socket = null;
+    this.status = "disconnected";
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  async connect() {
+    if (this.socket?.connected) {
+      return;
+    }
+    this.disconnect();
+    const userToken = await this.tokenManager.getToken();
+    this.socket = socket_ioClient.io(`${this.config.baseUrl}${REALTIME_NAMESPACE}`, {
+      auth: {
+        clientToken: this.config.clientToken,
+        userToken
+      },
+      autoConnect: true,
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 3e4,
+      transports: ["websocket"]
+    });
+    this.socket.on("connect", () => {
+      this.setStatus("connected");
+    });
+    this.socket.on("disconnect", () => {
+      this.setStatus("disconnected");
+    });
+    this.socket.on("connect_error", () => {
+      this.setStatus("error");
+    });
+    this.socket.io.on("reconnect_attempt", () => {
+      void this.refreshAuth();
+      this.setStatus("connecting");
+    });
+    this.setStatus("connecting");
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.io.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.setStatus("disconnected");
+  }
+  getStatus() {
+    return this.status;
+  }
+  onStatusChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** @internal For future event subscription by feature modules */
+  getSocket() {
+    return this.socket;
+  }
+  async refreshAuth() {
+    if (!this.socket) {
+      return;
+    }
+    try {
+      const freshToken = await this.tokenManager.getToken();
+      this.socket.auth = {
+        clientToken: this.config.clientToken,
+        userToken: freshToken
+      };
+    } catch {
+    }
+  }
+  setStatus(status) {
+    this.status = status;
+    for (const listener of this.listeners) {
+      listener(status);
+    }
+  }
+};
+
+// src/core/config.ts
+var DEFAULT_BASE_URL = "https://api.jokkoo.ai";
+var DEFAULT_TOKEN_REFRESH_BUFFER_SECONDS = 60;
+var DEFAULT_LOCALE = "fr";
+function normalizeBaseUrl(baseUrl) {
+  let url = baseUrl.trim().replace(/\/+$/, "");
+  if (url.endsWith("/v1")) {
+    url = url.slice(0, -3);
+  }
+  if (url.endsWith("/api")) {
+    url = url.slice(0, -4);
+  }
+  return url;
+}
+var JokkooConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JokkooConfigError";
+  }
+};
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new JokkooConfigError("Jokkoo.init() requires a configuration object.");
+  }
+  if (!config.clientToken || typeof config.clientToken !== "string") {
+    throw new JokkooConfigError("clientToken is required and must be a non-empty string.");
+  }
+  if (typeof config.userTokenProvider !== "function") {
+    throw new JokkooConfigError("userTokenProvider is required and must be a function.");
+  }
+  if (config.baseUrl !== void 0 && typeof config.baseUrl !== "string") {
+    throw new JokkooConfigError("baseUrl must be a string when provided.");
+  }
+  if (config.locale !== void 0 && typeof config.locale !== "string") {
+    throw new JokkooConfigError("locale must be a string when provided.");
+  }
+  if (config.debug !== void 0 && typeof config.debug !== "boolean") {
+    throw new JokkooConfigError("debug must be a boolean when provided.");
+  }
+  if (config.tokenRefreshBufferSeconds !== void 0 && (typeof config.tokenRefreshBufferSeconds !== "number" || config.tokenRefreshBufferSeconds < 0)) {
+    throw new JokkooConfigError(
+      "tokenRefreshBufferSeconds must be a non-negative number when provided."
+    );
+  }
+  return {
+    clientToken: config.clientToken.trim(),
+    userTokenProvider: config.userTokenProvider,
+    baseUrl: normalizeBaseUrl(config.baseUrl ?? DEFAULT_BASE_URL),
+    locale: config.locale ?? DEFAULT_LOCALE,
+    debug: config.debug ?? false,
+    tokenRefreshBufferSeconds: config.tokenRefreshBufferSeconds ?? DEFAULT_TOKEN_REFRESH_BUFFER_SECONDS
+  };
+}
+
+// src/core/jwt.ts
+function base64UrlDecode(input) {
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  if (typeof globalThis.atob === "function") {
+    return globalThis.atob(padded);
+  }
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let output = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const char of padded) {
+    if (char === "=") {
+      break;
+    }
+    const value = chars.indexOf(char);
+    if (value === -1) {
+      throw new Error("Invalid base64 character in JWT payload.");
+    }
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      output += String.fromCharCode(buffer >> bits & 255);
+    }
+  }
+  return output;
+}
+function decodeJwtExp(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(base64UrlDecode(parts[1]));
+    return typeof payload.exp === "number" ? payload.exp : null;
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token, refreshBufferSeconds, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const exp = decodeJwtExp(token);
+  if (exp === null) {
+    return true;
+  }
+  return exp - refreshBufferSeconds <= nowSeconds;
+}
+
+// src/core/token-manager.ts
+var TokenManager = class {
+  constructor(config) {
+    this.config = config;
+    this.cachedToken = null;
+    this.refreshTimer = null;
+    this.inflightRefresh = null;
+    this.state = "idle";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.debug = createDebugLogger(config.debug);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  async getToken() {
+    if (this.cachedToken && !isTokenExpired(this.cachedToken, this.config.tokenRefreshBufferSeconds)) {
+      this.debug.log("Using cached user token.", { token: redactToken(this.cachedToken) });
+      return this.cachedToken;
+    }
+    this.debug.log("Cached user token missing or expired. Refreshing.");
+    return this.refreshToken();
+  }
+  invalidateCachedToken() {
+    this.cachedToken = null;
+    this.debug.log("Cached token invalidated.");
+  }
+  async refreshToken() {
+    if (this.inflightRefresh) {
+      return this.inflightRefresh;
+    }
+    this.setState("loading");
+    this.debug.log("Fetching user token from userTokenProvider.");
+    this.inflightRefresh = this.config.userTokenProvider().then((token) => {
+      if (!token || typeof token !== "string") {
+        throw new Error("userTokenProvider must return a non-empty string.");
+      }
+      this.cachedToken = token;
+      this.scheduleRefresh(token);
+      this.setState("ready");
+      this.debug.log("User token refreshed.", { token: redactToken(token) });
+      return token;
+    }).catch((error) => {
+      const normalized = error instanceof Error ? error : new Error("Failed to obtain user token.");
+      this.setState("error", normalized);
+      this.debug.error("Failed to refresh user token.", normalized);
+      throw normalized;
+    }).finally(() => {
+      this.inflightRefresh = null;
+    });
+    return this.inflightRefresh;
+  }
+  destroy() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    this.cachedToken = null;
+    this.inflightRefresh = null;
+    this.listeners.clear();
+    this.setState("idle");
+  }
+  scheduleRefresh(token) {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    const exp = decodeJwtExp(token);
+    if (exp === null) {
+      return;
+    }
+    const nowSeconds = Math.floor(Date.now() / 1e3);
+    const refreshAtSeconds = exp - this.config.tokenRefreshBufferSeconds;
+    const delayMs = Math.max((refreshAtSeconds - nowSeconds) * 1e3, 0);
+    this.debug.log("Scheduled proactive token refresh.", { delayMs });
+    this.refreshTimer = setTimeout(() => {
+      this.debug.log("Running proactive token refresh.");
+      void this.refreshToken().catch((error) => {
+        this.debug.warn("Proactive token refresh failed.", error);
+      });
+    }, delayMs);
+  }
+  setState(state, error) {
+    this.state = state;
+    for (const listener of this.listeners) {
+      listener(state, error);
+    }
+  }
+};
+
+// src/core/jokkoo.ts
+var JokkooSDK = class {
+  constructor() {
+    this.config = null;
+    this.tokenManager = null;
+    this.realtimeClient = null;
+    this.initialized = false;
+  }
+  init(config) {
+    const debug = createDebugLogger(config.debug ?? this.config?.debug ?? false);
+    if (this.initialized) {
+      debug.warn("init() called more than once. Reinitializing SDK.");
+      this.destroy();
+    }
+    this.config = validateConfig(config);
+    this.tokenManager = new TokenManager(this.config);
+    this.realtimeClient = new JokkooRealtimeClient(this.config, this.tokenManager);
+    this.initialized = true;
+    const sdkDebug = createDebugLogger(this.config.debug);
+    sdkDebug.log("SDK initialized.", {
+      baseUrl: this.config.baseUrl,
+      locale: this.config.locale,
+      tokenRefreshBufferSeconds: this.config.tokenRefreshBufferSeconds
+    });
+  }
+  destroy() {
+    const debug = createDebugLogger(this.config?.debug ?? false);
+    this.realtimeClient?.disconnect();
+    this.realtimeClient = null;
+    this.tokenManager?.destroy();
+    this.tokenManager = null;
+    this.config = null;
+    this.initialized = false;
+    debug.log("SDK destroyed.");
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getState() {
+    return {
+      initialized: this.initialized,
+      clientToken: this.config?.clientToken,
+      baseUrl: this.config?.baseUrl,
+      locale: this.config?.locale
+    };
+  }
+  /** @internal Used by UI and future messaging modules */
+  getTokenManager() {
+    this.assertInitialized();
+    return this.tokenManager;
+  }
+  /** @internal Used by UI and future messaging modules */
+  getRealtimeClient() {
+    this.assertInitialized();
+    return this.realtimeClient;
+  }
+  /** @internal Used by UI and future messaging modules */
+  getConfig() {
+    this.assertInitialized();
+    return this.config;
+  }
+  assertInitialized() {
+    if (!this.initialized || !this.config || !this.tokenManager) {
+      throw new Error("Jokkoo SDK is not initialized. Call Jokkoo.init() first.");
+    }
+  }
+};
+var Jokkoo = new JokkooSDK();
+
+// src/types/chat-message.ts
+function mapApiAttachmentToChatAttachment(attachment) {
+  return {
+    fileId: attachment.fileId,
+    fileName: attachment.fileName,
+    mimeType: attachment.mimeType,
+    size: attachment.size
+  };
+}
+
+// src/i18n/en.ts
+var en = {
+  supportCenter: "Support Center",
+  activeConversation: (count) => `${count} active ticket${count === 1 ? "" : "s"}`,
+  myRequests: "My Requests",
+  newSupportRequest: "New Support Request",
+  noConversationsYet: "No conversations yet.",
+  unableToLoadConversations: "Unable to load conversations.",
+  retry: "Retry",
+  newRequest: "New request",
+  support: "Support",
+  noMessagesYet: "No messages yet",
+  newSupportRequestHeader: "New support request",
+  request: "Request",
+  typeYourMessage: "Type your message...",
+  sendMessage: "Send message",
+  recordVoiceMessage: "Record voice message",
+  unableToLoadMessages: "Unable to load messages.",
+  discussionEnded: "This discussion has been ended",
+  discussionClosedCanReply: "This discussion is closed. You can reply to reopen it.",
+  rateConversation: "Rate your conversation",
+  rateConversationDescription: "How satisfied are you with our support?",
+  thankYouForRating: "Thank you for your feedback!",
+  ratingVeryUnsatisfied: "Very unsatisfied",
+  ratingUnsatisfied: "Unsatisfied",
+  ratingNeutral: "Neutral",
+  ratingSatisfied: "Satisfied",
+  ratingVerySatisfied: "Very satisfied",
+  sendMessageError: "Unable to send your message. Please try again.",
+  statusNew: "New",
+  statusInProgress: "In Progress",
+  statusResolved: "Resolved",
+  statusEnded: "Ended",
+  ticketResolved: "This ticket has been resolved",
+  supportAgent: "Support Agent",
+  welcomeMessage: "Hello, How can we help you ?",
+  now: "now",
+  newMessageIndicator: (count) => count === 1 ? "1 new message" : `${count} new messages`,
+  attachFile: "Attach file",
+  pickPhotoLibrary: "Photo library",
+  pickCamera: "Camera",
+  pickDocument: "Document",
+  cancel: "Cancel",
+  uploadFailed: "Upload failed",
+  maxAttachmentsReached: "You can attach up to 5 files per message",
+  sharedFiles: "Shared files",
+  uploadingAttachment: "Uploading",
+  attachmentReady: "Ready to send",
+  retryUpload: "Retry",
+  openExternally: "Open externally",
+  downloadAttachment: "Download",
+  previewUnavailableInApp: "This file cannot be previewed in the app. Use the options below to open or download it.",
+  previewLoadFailed: "Unable to load this attachment.",
+  previewImageFile: "Image",
+  previewVideoFile: "Video",
+  previewDocumentFile: "Document",
+  voiceMessage: "Voice message",
+  recording: "Recording...",
+  tapToRecord: "Tap to record",
+  cancelRecording: "Cancel",
+  sendRecording: "Send recording",
+  microphonePermissionDenied: "Microphone access is required to record voice messages.",
+  voiceMessageTooShort: "Hold to record a longer voice message."
+};
+
+// src/i18n/fr.ts
+var fr = {
+  supportCenter: "Centre d'assistance",
+  activeConversation: (count) => `${count} ticket${count > 1 ? "s" : ""} actif${count > 1 ? "s" : ""}`,
+  myRequests: "Mes demandes",
+  newSupportRequest: "Nouvelle demande",
+  noConversationsYet: "Aucune conversation pour le moment.",
+  unableToLoadConversations: "Impossible de charger les conversations.",
+  retry: "R\xE9essayer",
+  newRequest: "Nouvelle demande",
+  support: "Support",
+  noMessagesYet: "Aucun message pour le moment",
+  newSupportRequestHeader: "Nouvelle demande",
+  request: "Demande",
+  typeYourMessage: "Tapez votre message...",
+  sendMessage: "Envoyer le message",
+  recordVoiceMessage: "Enregistrer un message vocal",
+  unableToLoadMessages: "Impossible de charger les messages.",
+  discussionEnded: "Cette discussion est termin\xE9e",
+  discussionClosedCanReply: "Cette discussion est cl\xF4tur\xE9e. Vous pouvez r\xE9pondre pour la rouvrir.",
+  rateConversation: "Notez votre conversation",
+  rateConversationDescription: "Quelle est votre satisfaction concernant notre support ?",
+  thankYouForRating: "Merci pour votre retour !",
+  ratingVeryUnsatisfied: "Tr\xE8s insatisfait",
+  ratingUnsatisfied: "Insatisfait",
+  ratingNeutral: "Neutre",
+  ratingSatisfied: "Satisfait",
+  ratingVerySatisfied: "Tr\xE8s satisfait",
+  sendMessageError: "Impossible d'envoyer votre message. Veuillez r\xE9essayer.",
+  statusNew: "Nouveau",
+  statusInProgress: "En cours",
+  statusResolved: "R\xE9solu",
+  statusEnded: "Termin\xE9",
+  ticketResolved: "Ce ticket a \xE9t\xE9 r\xE9solu",
+  supportAgent: "Agent de support",
+  welcomeMessage: "Bonjour, comment pouvons-nous vous aider ?",
+  now: "maintenant",
+  newMessageIndicator: (count) => count === 1 ? "1 nouveau message" : `${count} nouveaux messages`,
+  attachFile: "Joindre un fichier",
+  pickPhotoLibrary: "Phototh\xE8que",
+  pickCamera: "Appareil photo",
+  pickDocument: "Document",
+  cancel: "Annuler",
+  uploadFailed: "\xC9chec du t\xE9l\xE9versement",
+  maxAttachmentsReached: "Vous pouvez joindre jusqu'\xE0 5 fichiers par message",
+  sharedFiles: "Fichiers partag\xE9s",
+  uploadingAttachment: "T\xE9l\xE9versement",
+  attachmentReady: "Pr\xEAt \xE0 envoyer",
+  retryUpload: "R\xE9essayer",
+  openExternally: "Ouvrir en externe",
+  downloadAttachment: "T\xE9l\xE9charger",
+  previewUnavailableInApp: "Ce fichier ne peut pas \xEAtre pr\xE9visualis\xE9 dans l'application. Utilisez les options ci-dessous pour l'ouvrir ou le t\xE9l\xE9charger.",
+  previewLoadFailed: "Impossible de charger cette pi\xE8ce jointe.",
+  previewImageFile: "Image",
+  previewVideoFile: "Vid\xE9o",
+  previewDocumentFile: "Document",
+  voiceMessage: "Message vocal",
+  recording: "Enregistrement...",
+  tapToRecord: "Appuyez pour enregistrer",
+  cancelRecording: "Annuler",
+  sendRecording: "Envoyer l'enregistrement",
+  microphonePermissionDenied: "L'acc\xE8s au microphone est requis pour enregistrer des messages vocaux.",
+  voiceMessageTooShort: "Maintenez plus longtemps pour enregistrer un message vocal."
+};
+
+// src/i18n/index.ts
+function getTranslations(locale) {
+  if (locale === "en") {
+    return en;
+  }
+  return fr;
+}
+
+// src/lib/satisfaction.ts
+function isSatisfactionRequestMessage(message) {
+  return message.messageType === "activity" && message.metadata?.activityType === "satisfaction_request";
+}
+function getSatisfactionSurveyMessage(messages) {
+  const surveyMessage = [...messages].reverse().find(isSatisfactionRequestMessage);
+  const content = surveyMessage?.content?.trim();
+  return content && content.length > 0 ? content : void 0;
+}
+function conversationNeedsRating(status, messages) {
+  if (status === "closed") {
+    return false;
+  }
+  if (status === "pending_closure") {
+    return true;
+  }
+  return messages.some(isSatisfactionRequestMessage);
+}
+
+// src/lib/activity.ts
+var TICKET_ACTIVITY_TYPES = /* @__PURE__ */ new Set(["ticket_created", "ticket_status_changed"]);
+function isTicketActivityMessage(message) {
+  const activityType = message.metadata?.activityType;
+  return message.messageType === "activity" && typeof activityType === "string" && TICKET_ACTIVITY_TYPES.has(activityType);
+}
+function isPassiveActivityMessage(message) {
+  if (isSatisfactionRequestMessage(message)) {
+    return false;
+  }
+  return isTicketActivityMessage(message) || message.senderType === "system";
+}
+function shouldCountMessageAsUnread(message) {
+  return message.senderType === "agent" || message.senderType === "system";
+}
+
+// src/lib/attachment-media.ts
+function isImageMimeType(mimeType) {
+  return mimeType.startsWith("image/");
+}
+function isVideoMimeType(mimeType) {
+  return mimeType.startsWith("video/");
+}
+function isAudioMimeType(mimeType) {
+  return mimeType.startsWith("audio/");
+}
+function isDocumentMimeType(mimeType) {
+  return !isImageMimeType(mimeType) && !isVideoMimeType(mimeType) && !isAudioMimeType(mimeType);
+}
+function canPreviewInApp(mimeType) {
+  return isImageMimeType(mimeType);
+}
+function formatAttachmentSize(size) {
+  if (!size || size <= 0) {
+    return "";
+  }
+  if (size < 1024) {
+    return `${size} B`;
+  }
+  if (size < 1024 * 1024) {
+    return `${(size / 1024).toFixed(1)} KB`;
+  }
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatAudioDuration(durationMs) {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+}
+function isVoiceMessageMetadata(metadata) {
+  return metadata?.isVoiceMessage === true;
+}
+
+// src/lib/closed-conversation-policy.ts
+function isWithinReopenGracePeriod(conversation, policy) {
+  if (!conversation.closedAt || policy.reopenGracePeriodDays <= 0) {
+    return false;
+  }
+  const graceEnd = new Date(conversation.closedAt);
+  graceEnd.setDate(graceEnd.getDate() + policy.reopenGracePeriodDays);
+  return /* @__PURE__ */ new Date() <= graceEnd;
+}
+function canReplyToClosedConversation(conversation, policy) {
+  if (conversation.status !== "closed" || !policy) {
+    return false;
+  }
+  if (policy.endUserReplyBehavior !== "reopen") {
+    return false;
+  }
+  return isWithinReopenGracePeriod(conversation, policy);
+}
+
+// src/lib/constants.ts
+var MESSAGE_CONTENT_MIN_LENGTH = 2;
+var MESSAGE_CONTENT_MAX_LENGTH = 2e3;
+var MAX_IMAGE_SIZE_BYTES = 5 * 1024 * 1024;
+var MAX_VIDEO_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_DOCUMENT_SIZE_BYTES = 10 * 1024 * 1024;
+var MAX_AUDIO_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_ATTACHMENTS_PER_MESSAGE = 5;
+var ALLOWED_IMAGE_MIME_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+];
+var ALLOWED_VIDEO_MIME_TYPES = ["video/mp4", "video/quicktime", "video/webm"];
+var ALLOWED_DOCUMENT_MIME_TYPES = [
+  "application/pdf",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+];
+var ALLOWED_AUDIO_MIME_TYPES = [
+  "audio/aac",
+  "audio/mp4",
+  "audio/mpeg",
+  "audio/webm"
+];
+var ALLOWED_ATTACHMENT_MIME_TYPES = [
+  ...ALLOWED_IMAGE_MIME_TYPES,
+  ...ALLOWED_VIDEO_MIME_TYPES,
+  ...ALLOWED_DOCUMENT_MIME_TYPES,
+  ...ALLOWED_AUDIO_MIME_TYPES
+];
+var VOICE_MESSAGE_MIME_TYPE = "audio/mp4";
+var VOICE_MESSAGE_STORAGE_PROVIDER = "s3";
+
+// src/lib/conversation-display.ts
+function getInitialsFromName(name) {
+  const parts = name.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) {
+    return "?";
+  }
+  if (parts.length === 1) {
+    return parts[0].slice(0, 2).toUpperCase();
+  }
+  return `${parts[0][0] ?? ""}${parts[parts.length - 1][0] ?? ""}`.toUpperCase();
+}
+function getConversationDisplayName(conversation, t) {
+  if (conversation.status === "pending") {
+    return t.newRequest;
+  }
+  if (conversation.assignedAgentName) {
+    return conversation.assignedAgentName;
+  }
+  return t.support;
+}
+function getAgentInitials(assignedAgentName, fallback) {
+  if (!assignedAgentName) {
+    return fallback;
+  }
+  return getInitialsFromName(assignedAgentName);
+}
+function getAgentDisplayName(assignedAgentName, t) {
+  return assignedAgentName ?? t.supportAgent;
+}
+
+// src/lib/file-upload.ts
+function getMaxSizeForMimeType(mimeType) {
+  if (mimeType.startsWith("image/")) {
+    return MAX_IMAGE_SIZE_BYTES;
+  }
+  if (mimeType.startsWith("video/")) {
+    return MAX_VIDEO_SIZE_BYTES;
+  }
+  if (mimeType.startsWith("audio/")) {
+    return MAX_AUDIO_SIZE_BYTES;
+  }
+  return MAX_DOCUMENT_SIZE_BYTES;
+}
+function validateAttachment(mimeType, size) {
+  if (!ALLOWED_ATTACHMENT_MIME_TYPES.includes(mimeType)) {
+    return "Unsupported file type";
+  }
+  if (size > getMaxSizeForMimeType(mimeType)) {
+    return "File exceeds the maximum allowed size";
+  }
+  return null;
+}
+async function uploadAttachmentFile(apiClient, attachment, onProgress) {
+  onProgress(10, "uploading");
+  const { fileId, uploadUrl } = await apiClient.requestUploadUrl(
+    attachment.fileName,
+    attachment.mimeType
+  );
+  onProgress(40, "uploading");
+  const fileResponse = await fetch(attachment.uri);
+  const blob = await fileResponse.blob();
+  const uploadResponse = await fetch(uploadUrl, {
+    method: "PUT",
+    body: blob,
+    headers: {
+      "Content-Type": attachment.mimeType
+    }
+  });
+  if (!uploadResponse.ok) {
+    throw new Error("Upload failed");
+  }
+  onProgress(75, "confirming");
+  await apiClient.confirmUpload(fileId);
+  return {
+    ...attachment,
+    status: "confirmed",
+    progress: 100,
+    confirmedFileId: fileId
+  };
+}
+function createPendingAttachment(input) {
+  const validationError = validateAttachment(input.mimeType, input.size);
+  return {
+    id: `${input.fileName}-${Date.now()}`,
+    fileName: input.fileName,
+    mimeType: input.mimeType,
+    uri: input.uri,
+    size: input.size,
+    status: validationError ? "error" : "pending",
+    progress: 0,
+    error: validationError ?? void 0
+  };
+}
+function canAddMoreAttachments(currentCount) {
+  return currentCount < MAX_ATTACHMENTS_PER_MESSAGE;
+}
+
+// src/lib/format.ts
+var MONTH_LABELS = {
+  en: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+  fr: ["Jan", "F\xE9v", "Mar", "Avr", "Mai", "Juin", "Juil", "Ao\xFB", "Sep", "Oct", "Nov", "D\xE9c"]
+};
+function resolveLocale(locale) {
+  return locale === "en" ? "en" : "fr";
+}
+function formatMessageTimestamp(value, locale) {
+  const date = typeof value === "string" ? new Date(value) : value;
+  const monthLabels = MONTH_LABELS[resolveLocale(locale)];
+  const month = monthLabels[date.getMonth()];
+  const day = date.getDate();
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${month} ${day} \xB7 ${hours}:${minutes}`;
+}
+function formatRelativeTimestamp(value, options) {
+  const date = typeof value === "string" ? new Date(value) : value;
+  const now = Date.now();
+  const diffMs = now - date.getTime();
+  const diffMinutes = Math.floor(diffMs / 6e4);
+  const nowLabel = options?.nowLabel ?? "now";
+  if (diffMinutes < 1) {
+    return nowLabel;
+  }
+  if (diffMinutes < 60) {
+    return `${diffMinutes}min`;
+  }
+  const diffHours = Math.floor(diffMinutes / 60);
+  if (diffHours < 24) {
+    return `${diffHours}h`;
+  }
+  const monthLabels = MONTH_LABELS[resolveLocale(options?.locale)];
+  const month = monthLabels[date.getMonth()];
+  const day = date.getDate();
+  return `${month} ${day}`;
+}
+
+// src/lib/message-mapper.ts
+function mapMessageToChatMessage(message, translations, locale, assignedAgentName, assignedAgentAvatarUrl) {
+  const sender = message.senderType === "end_user" ? "user" : message.senderType === "agent" ? "agent" : "system";
+  const agentName = sender === "agent" ? getAgentDisplayName(assignedAgentName, translations) : void 0;
+  const agentInitials = sender === "agent" ? getAgentInitials(assignedAgentName, "SA") : void 0;
+  const agentAvatarUrl = sender === "agent" ? assignedAgentAvatarUrl ?? null : null;
+  return {
+    id: String(message.id),
+    sender,
+    text: message.content,
+    timestamp: formatMessageTimestamp(message.createdAt, locale),
+    agentName,
+    agentInitials,
+    agentAvatarUrl,
+    attachments: message.attachments?.map((attachment) => ({
+      fileId: attachment.fileId,
+      fileName: attachment.fileName,
+      mimeType: attachment.mimeType,
+      size: attachment.size
+    })),
+    metadata: message.metadata ?? null
+  };
+}
+function createWelcomeMessage(translations) {
+  return {
+    id: "welcome",
+    sender: "agent",
+    agentInitials: "AB",
+    text: translations.welcomeMessage,
+    timestamp: ""
+  };
+}
+
+// src/lib/message-pagination.ts
+async function fetchMessagesPage(apiClient, conversationId, pageSize, pageParam) {
+  if (pageParam === "latest") {
+    const probe = await apiClient.getMessages(conversationId, 1, 0);
+    const offset = Math.max(0, probe.total - pageSize);
+    const page2 = await apiClient.getMessages(conversationId, pageSize, offset);
+    return {
+      ...page2,
+      data: [...page2.data].reverse()
+    };
+  }
+  const page = await apiClient.getMessages(conversationId, pageSize, pageParam);
+  return {
+    ...page,
+    data: [...page.data].reverse()
+  };
+}
+function getOlderMessagesPageParam(lastPage) {
+  const oldestLoadedOffset = lastPage.offset;
+  if (oldestLoadedOffset <= 0) {
+    return void 0;
+  }
+  return Math.max(0, oldestLoadedOffset - lastPage.limit);
+}
+
+// src/lib/realtime-mappers.ts
+function toIsoString(value) {
+  if (!value) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return typeof value === "string" ? value : value.toISOString();
+}
+function mapRealtimeStatus(status) {
+  if (status === "closed") {
+    return "closed";
+  }
+  if (status === "pending_closure") {
+    return "pending_closure";
+  }
+  if (status === "snoozed") {
+    return "snoozed";
+  }
+  if (status === "pending") {
+    return "pending";
+  }
+  return "open";
+}
+function mapRealtimeConversationPayload(conversation) {
+  return {
+    id: conversation.id,
+    channelType: conversation.channelType,
+    status: mapRealtimeStatus(conversation.status),
+    lastMessageText: conversation.lastMessageText,
+    assignedAgentName: conversation.assignedAgentName ?? null,
+    createdAt: toIsoString(conversation.createdAt),
+    updatedAt: toIsoString(conversation.lastMessageAt ?? conversation.updatedAt)
+  };
+}
+function normalizeRealtimeMessage(message) {
+  return {
+    ...message,
+    id: Number(message.id),
+    conversationId: Number(message.conversationId),
+    endUserId: Number(message.endUserId),
+    createdAt: typeof message.createdAt === "string" ? message.createdAt : new Date(message.createdAt).toISOString()
+  };
+}
+
+// src/lib/voice-recording.ts
+var VOICE_WAVEFORM_BAR_COUNT = 32;
+var VOICE_METERING_IDLE_LEVEL = 0.14;
+var VOICE_METERING_SMOOTHING = 0.38;
+function normalizeMeteringLevel(metering) {
+  const clampedDb = Math.max(-58, Math.min(0, metering));
+  const linear = (clampedDb + 58) / 58;
+  const curved = Math.pow(linear, 0.72);
+  return Math.max(VOICE_METERING_IDLE_LEVEL, Math.min(1, curved));
+}
+function smoothMeteringSample(previous, next, alpha = VOICE_METERING_SMOOTHING) {
+  return previous + (next - previous) * alpha;
+}
+function createIdleMeteringLevels(barCount = VOICE_WAVEFORM_BAR_COUNT) {
+  return Array.from({ length: barCount }, () => VOICE_METERING_IDLE_LEVEL);
+}
+function shiftMeteringLevel(levels, newLevel) {
+  if (levels.length === 0) {
+    return createIdleMeteringLevels();
+  }
+  if (levels.length === 1) {
+    return [levels[0], newLevel];
+  }
+  return [...levels.slice(1), newLevel];
+}
+function applyLiveBarVariation(level, index) {
+  const wobble = 0.82 + 0.18 * Math.sin(index * 0.85 + level * 4.2);
+  return Math.max(VOICE_METERING_IDLE_LEVEL, Math.min(1, level * wobble));
+}
+function createPlaybackBarHeights(count, seed) {
+  const heights = [];
+  for (let index = 0; index < count; index += 1) {
+    const wave = Math.sin((index + seed) * 0.65) * 0.35 + 0.55;
+    heights.push(Math.max(0.2, Math.min(1, wave)));
+  }
+  return heights;
+}
+function blendLiveWaveformLevels(levels) {
+  if (levels.length <= 2) {
+    return levels;
+  }
+  return levels.map((level, index) => {
+    const previous = levels[index - 1] ?? level;
+    const next = levels[index + 1] ?? level;
+    const blended = level * 0.55 + previous * 0.225 + next * 0.225;
+    return Math.max(VOICE_METERING_IDLE_LEVEL, Math.min(1, blended));
+  });
+}
+
+// src/lib/voice-upload.ts
+async function uploadVoiceRecording(apiClient, uri, fileName, onProgress) {
+  onProgress?.(10);
+  const { fileId, uploadUrl } = await apiClient.requestUploadUrl(
+    fileName,
+    VOICE_MESSAGE_MIME_TYPE,
+    VOICE_MESSAGE_STORAGE_PROVIDER
+  );
+  onProgress?.(40);
+  const fileResponse = await fetch(uri);
+  const blob = await fileResponse.blob();
+  const uploadResponse = await fetch(uploadUrl, {
+    method: "PUT",
+    body: blob,
+    headers: {
+      "Content-Type": VOICE_MESSAGE_MIME_TYPE
+    }
+  });
+  if (!uploadResponse.ok) {
+    throw new Error("Voice upload failed");
+  }
+  onProgress?.(75);
+  await apiClient.confirmUpload(fileId);
+  onProgress?.(100);
+  return fileId;
+}
+async function uploadVoiceBlob(apiClient, blob, fileName, mimeType = VOICE_MESSAGE_MIME_TYPE, onProgress) {
+  onProgress?.(10);
+  const { fileId, uploadUrl } = await apiClient.requestUploadUrl(
+    fileName,
+    mimeType,
+    VOICE_MESSAGE_STORAGE_PROVIDER
+  );
+  onProgress?.(40);
+  const uploadResponse = await fetch(uploadUrl, {
+    method: "PUT",
+    body: blob,
+    headers: {
+      "Content-Type": mimeType
+    }
+  });
+  if (!uploadResponse.ok) {
+    throw new Error("Voice upload failed");
+  }
+  onProgress?.(75);
+  await apiClient.confirmUpload(fileId);
+  onProgress?.(100);
+  return fileId;
+}
+function createVoiceMessageFileName(extension = "m4a") {
+  return `voice-${Date.now()}.${extension}`;
+}
+
+exports.ALLOWED_ATTACHMENT_MIME_TYPES = ALLOWED_ATTACHMENT_MIME_TYPES;
+exports.CLIENT_TOKEN_HEADER = CLIENT_TOKEN_HEADER;
+exports.Jokkoo = Jokkoo;
+exports.JokkooApiClient = JokkooApiClient;
+exports.JokkooApiError = JokkooApiError;
+exports.JokkooConfigError = JokkooConfigError;
+exports.JokkooRealtimeClient = JokkooRealtimeClient;
+exports.MAX_ATTACHMENTS_PER_MESSAGE = MAX_ATTACHMENTS_PER_MESSAGE;
+exports.MAX_AUDIO_SIZE_BYTES = MAX_AUDIO_SIZE_BYTES;
+exports.MAX_DOCUMENT_SIZE_BYTES = MAX_DOCUMENT_SIZE_BYTES;
+exports.MAX_IMAGE_SIZE_BYTES = MAX_IMAGE_SIZE_BYTES;
+exports.MAX_VIDEO_SIZE_BYTES = MAX_VIDEO_SIZE_BYTES;
+exports.MESSAGE_CONTENT_MAX_LENGTH = MESSAGE_CONTENT_MAX_LENGTH;
+exports.MESSAGE_CONTENT_MIN_LENGTH = MESSAGE_CONTENT_MIN_LENGTH;
+exports.NEW_CONVERSATION_ID = NEW_CONVERSATION_ID;
+exports.REALTIME_EVENTS = REALTIME_EVENTS;
+exports.REALTIME_NAMESPACE = REALTIME_NAMESPACE;
+exports.TokenManager = TokenManager;
+exports.USER_TOKEN_HEADER = USER_TOKEN_HEADER;
+exports.VOICE_MESSAGE_MIME_TYPE = VOICE_MESSAGE_MIME_TYPE;
+exports.VOICE_MESSAGE_STORAGE_PROVIDER = VOICE_MESSAGE_STORAGE_PROVIDER;
+exports.applyLiveBarVariation = applyLiveBarVariation;
+exports.blendLiveWaveformLevels = blendLiveWaveformLevels;
+exports.canAddMoreAttachments = canAddMoreAttachments;
+exports.canPreviewInApp = canPreviewInApp;
+exports.canReplyToClosedConversation = canReplyToClosedConversation;
+exports.conversationNeedsRating = conversationNeedsRating;
+exports.createDebugLogger = createDebugLogger;
+exports.createIdleMeteringLevels = createIdleMeteringLevels;
+exports.createPendingAttachment = createPendingAttachment;
+exports.createPlaybackBarHeights = createPlaybackBarHeights;
+exports.createVoiceMessageFileName = createVoiceMessageFileName;
+exports.createWelcomeMessage = createWelcomeMessage;
+exports.en = en;
+exports.fetchMessagesPage = fetchMessagesPage;
+exports.formatAttachmentSize = formatAttachmentSize;
+exports.formatAudioDuration = formatAudioDuration;
+exports.formatMessageTimestamp = formatMessageTimestamp;
+exports.formatRelativeTimestamp = formatRelativeTimestamp;
+exports.fr = fr;
+exports.getAgentDisplayName = getAgentDisplayName;
+exports.getAgentInitials = getAgentInitials;
+exports.getConversationDisplayName = getConversationDisplayName;
+exports.getInitialsFromName = getInitialsFromName;
+exports.getOlderMessagesPageParam = getOlderMessagesPageParam;
+exports.getSatisfactionSurveyMessage = getSatisfactionSurveyMessage;
+exports.getTranslations = getTranslations;
+exports.isAudioMimeType = isAudioMimeType;
+exports.isDocumentMimeType = isDocumentMimeType;
+exports.isImageMimeType = isImageMimeType;
+exports.isPassiveActivityMessage = isPassiveActivityMessage;
+exports.isSatisfactionRequestMessage = isSatisfactionRequestMessage;
+exports.isTicketActivityMessage = isTicketActivityMessage;
+exports.isVideoMimeType = isVideoMimeType;
+exports.isVoiceMessageMetadata = isVoiceMessageMetadata;
+exports.isWithinReopenGracePeriod = isWithinReopenGracePeriod;
+exports.mapApiAttachmentToChatAttachment = mapApiAttachmentToChatAttachment;
+exports.mapMessageToChatMessage = mapMessageToChatMessage;
+exports.mapRealtimeConversationPayload = mapRealtimeConversationPayload;
+exports.normalizeMeteringLevel = normalizeMeteringLevel;
+exports.normalizeRealtimeMessage = normalizeRealtimeMessage;
+exports.redactToken = redactToken;
+exports.shiftMeteringLevel = shiftMeteringLevel;
+exports.shouldCountMessageAsUnread = shouldCountMessageAsUnread;
+exports.smoothMeteringSample = smoothMeteringSample;
+exports.uploadAttachmentFile = uploadAttachmentFile;
+exports.uploadVoiceBlob = uploadVoiceBlob;
+exports.uploadVoiceRecording = uploadVoiceRecording;
+exports.validateConfig = validateConfig;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map