@communecter/cocolight-api-client 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.15",
+    "version": "1.0.17",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",

package/src/Api.js

@@ -13,7 +13,7 @@ export default class Api {
    *
    * @param {string} email - L'adresse email.
    * @param {string} password - Le mot de passe.
-   * @param {Object} options - Options pour l'ApiClient (baseURL, debug, etc.)
+   * @param {function|object} options - Options pour l'ApiClient (baseURL, debug, etc.) ou une instance d'ApiClient.
    * @returns {Promise<Api>}
    */
   static async userLogin(email, password, options) {
@@ -24,7 +24,7 @@ export default class Api {
   /**
    * Creates an instance of the UserApi class with the provided options.
    *
-   * @param {Object} options - Configuration options for initializing the UserApi instance.
+   * @param @param {function|object} options - Options for the ApiClient (baseURL, debug, etc.) or an instance of ApiClient.
    * @returns {UserApi} An instance of the UserApi class.
    * @throws {Error} Throws an error if the UserApi instance cannot be created.
    */

package/src/ApiClient.js

@@ -14,10 +14,28 @@ import endpointsJson from "./endpoints.module.js";
 import { ApiClientError, ApiResponseError, ApiValidationError, CircuitBreakerError } from "./error.js";
 import { MemoryStorageStrategy } from "./utils/TokenStorage.js";
 
+
 EJSON.addType("oid", value => {
   return new MongoID.ObjectID(value);
 });
 
+/**
+ * Client générique pour consommer une API REST avec validation AJV, gestion des tokens,
+ * circuit breaker, retry automatique, et support offline.
+ *
+ * @extends EventEmitter
+ *
+ * @fires ApiClient#retryAttempt
+ * @fires ApiClient#queuedOffline
+ * @fires ApiClient#circuitBreakerOpen
+ * @fires ApiClient#circuitBreakerReset
+ * @fires ApiClient#refreshSuccess
+ * @fires ApiClient#refreshFailed
+ * @fires ApiClient#sessionReset
+ * @fires ApiClient#validationError
+ * @fires ApiClient#offlineModeChanged
+ * @fires ApiClient#userLoggedIn
+ */
 export default class ApiClient extends EventEmitter {
   /**
    * @param {Object} options
@@ -61,6 +79,7 @@ export default class ApiClient extends EventEmitter {
     this._endpoints = endpoints;
     this._debug = debug;
     let _userId = null;
+    this._offlineClientManager = null;
 
     // Active la transformation des données en EJSON globalement
     this._fromJSONValue = fromJSONValue;
@@ -112,6 +131,10 @@ export default class ApiClient extends EventEmitter {
         retryCondition: (error) => {
           // Retry sur erreurs 5xx ou erreurs réseau
           return axiosRetry.isNetworkError(error) || axiosRetry.isRetryableError(error);
+        },
+        onRetry: (retryCount, error, requestConfig) => {
+          this._logger.warn(`[Retry] Tentative #${retryCount} pour ${requestConfig?.url}`);
+          this.emit("retryAttempt", { retryCount, url: requestConfig?.url });
         }
       });
       this._logger.info(`[ApiClient] Retry activé : ${maxRetries} max`);
@@ -127,6 +150,18 @@ export default class ApiClient extends EventEmitter {
     this._accessToken = null;
     this._refreshToken = null;
 
+    this._tokenStorage = tokenStorageStrategy || new MemoryStorageStrategy();
+
+    if (
+      typeof this._tokenStorage?.getAccessToken !== "function" ||
+      typeof this._tokenStorage?.setAccessToken !== "function" ||
+      typeof this._tokenStorage?.getRefreshToken !== "function" ||
+      typeof this._tokenStorage?.setRefreshToken !== "function" ||
+      typeof this._tokenStorage?.clear !== "function"
+    ) {
+      throw new Error("[ApiClient] La stratégie de stockage des tokens n’est pas valide. Elle doit implémenter les méthodes requises.");
+    }
+    
     // Applique un token initial s'il est fourni
     if(refreshToken){
       this.setRefreshToken(refreshToken);
@@ -136,8 +171,6 @@ export default class ApiClient extends EventEmitter {
       this.setToken(accessToken);
     }
 
-    this._tokenStorage = tokenStorageStrategy || new MemoryStorageStrategy();
-
     const initialAccessToken = this._tokenStorage.getAccessToken();
     if (initialAccessToken) {
       this.setToken(initialAccessToken);
@@ -190,7 +223,6 @@ export default class ApiClient extends EventEmitter {
       }
     );
 
-
   }
 
   /**
@@ -306,6 +338,7 @@ export default class ApiClient extends EventEmitter {
       return false;
     } catch (err) {
       // Si on a une erreur, on reset la session
+      this.emit("refreshFailed", { error: err.message });
       this.resetSession();
       this._logger.error(`[ApiClient] Refresh Error : ${err.message}`);
       return false;
@@ -324,6 +357,7 @@ export default class ApiClient extends EventEmitter {
       this._breakerOpen = false;
       this._breakerErrorCount = 0;
       this._logger.warn("[ApiClient] Circuit breaker réinitialisé");
+      this.emit("circuitBreakerReset");
       return true;
     }
     return false;
@@ -340,6 +374,7 @@ export default class ApiClient extends EventEmitter {
       this._breakerOpen = true;
       this._lastBreakerOpenTime = Date.now();
       this._logger.error("[ApiClient] Circuit breaker ACTIVÉ - L'API est considérée indisponible");
+      this.emit("circuitBreakerOpen", { timestamp: this._lastBreakerOpenTime });
     }
   }
 
@@ -563,10 +598,7 @@ export default class ApiClient extends EventEmitter {
    * @throws {ApiClientError} If the endpoint is not found, token is required but not provided, or validation fails.
    */
   async callEndpoint(constant, data = {}, transformResponseData = true, validateResponseSchema = true) {
-    if (!this._checkCircuitBreaker()) {
-      throw new CircuitBreakerError("Le circuit breaker est activé, impossible d'appeler l'API");
-    }
-  
+
     const endpoint = this._endpoints.find((ep) => ep.constant === constant);
     if (!endpoint) {
       throw new ApiClientError(`Endpoint introuvable : ${constant}`, 404);
@@ -652,7 +684,59 @@ export default class ApiClient extends EventEmitter {
       data = this._resolveSpecialValuesInPlace(cleanedData, resolvedParams);
     }
   
-    // === 3. Payload ===
+    // === 3. ENQUEUE SI OFFLINE (après validations, avant le breaker)
+    if (this._offlineClientManager?.isOffline()) {
+      if (typeof this._offlineClientManager._enqueueOfflineAction === "function") {
+        this._logger.warn(`[ApiClient] Mode dégradé : mise en file de ${constant}`);
+        await this._offlineClientManager._enqueueOfflineAction({
+          constant,
+          data,
+          options: { transformResponseData, validateResponseSchema }
+        });
+
+        this._logger.info(`[ApiClient] Requête ${constant} mise en file (offline mode)`);
+
+        this.emit("queuedOffline", {
+          constant,
+          reason: "offlineMode",
+          data
+        });
+
+        return { data: null, offline: true };
+      } else {
+        this._logger.warn("[ApiClient] Mode dégradé actif mais offlineManager non initialisé correctement");
+        throw new ApiClientError("Mode hors-ligne actif, mais gestionnaire offline non disponible.", 503);
+      }
+    }
+
+    // === 4. Circuit Breaker
+    if (!this._checkCircuitBreaker()) {
+      if (
+        this._offlineClientManager?.isOffline?.() === false && // pas déjà en mode offline
+        typeof this._offlineClientManager._enqueueOfflineAction === "function"
+      ) {
+        this._logger.warn(`[ApiClient] Circuit breaker actif → mise en file de ${constant}`);
+        await this._offlineClientManager._enqueueOfflineAction({
+          constant,
+          data,
+          options: { transformResponseData, validateResponseSchema }
+        });
+
+        this._logger.info(`[ApiClient] Requête ${constant} mise en file (circuit breaker)`);
+
+        this.emit("queuedOffline", {
+          constant,
+          reason: "circuitBreaker",
+          data
+        });
+
+        return { data: null, breaker: true };
+      }
+
+      throw new CircuitBreakerError("Le circuit breaker est activé, impossible d'appeler l'API");
+    }
+
+    // === 5. Payload ===
     let payload;
     if (realContentType === "application/json" || realContentType === "multipart/form-data") {
       payload = data;
@@ -1444,4 +1528,103 @@ export default class ApiClient extends EventEmitter {
     return this._endpoints.find(e => e.constant === constant)?.pathParams || null;
   }
 
+  /**
+   * Permet d'écouter facilement un ensemble d'événements importants émis par l'ApiClient.
+   *
+   * @param {Object} handlers - Un objet avec des fonctions à appeler selon l'événement.
+   * @param {Function} [handlers.retryAttempt] - Lors d'une tentative de retry axios.
+   * @param {Function} [handlers.queuedOffline] - Lorsqu'une requête est mise en file.
+   * @param {Function} [handlers.circuitBreakerOpen] - Quand le breaker s'ouvre.
+   * @param {Function} [handlers.circuitBreakerReset] - Quand le breaker se referme.
+   * @param {Function} [handlers.refreshSuccess] - Quand le token est rafraîchi.
+   * @param {Function} [handlers.refreshFailed] - Quand le refresh échoue.
+   * @param {Function} [handlers.sessionReset] - Quand la session est réinitialisée.
+   * @param {Function} [handlers.validationError] - Quand une validation échoue.
+   * @param {Function} [handlers.offlineModeChanged] - Quand le mode offline change.
+   * @param {Function} [handlers.userLoggedIn] - Quand un utilisateur se connecte.
+   */
+  onEvent(handlers = {}) {
+    const availableEvents = [
+      "retryAttempt",
+      "queuedOffline",
+      "circuitBreakerOpen",
+      "circuitBreakerReset",
+      "refreshSuccess",
+      "refreshFailed",
+      "sessionReset",
+      "validationError",
+      "offlineModeChanged",
+      "userLoggedIn"
+    ];
+
+    for (const eventName of availableEvents) {
+      if (typeof handlers[eventName] === "function") {
+        this.on(eventName, handlers[eventName]);
+      }
+    }
+  }
+
+  /**
+   * Retourne la liste des noms d'événements personnalisés déclarés dans les endpoints.
+   * Utile pour introspection ou documentation.
+   *
+   * @returns {string[]} Liste des événements émis dynamiquement via postActions.
+   */
+  getDeclaredEvents() {
+    const events = new Set();
+    for (const endpoint of this._endpoints) {
+      if (Array.isArray(endpoint.postActions)) {
+        for (const action of endpoint.postActions) {
+          if (action.type === "emitEvent" && action.event) {
+            events.add(action.event);
+          }
+        }
+      }
+    }
+    return Array.from(events);
+  }
+
 }
+/**
+ * @event ApiClient#retryAttempt
+ * @type {Object}
+ * @property {number} retryCount - Le numéro de tentative.
+ * @property {string} url - L'URL de la requête ayant échoué.
+
+ * @event ApiClient#queuedOffline
+ * @type {Object}
+ * @property {string} constant - Le nom de l'endpoint.
+ * @property {Object} data - Les données envoyées.
+ * @property {"offlineMode"|"circuitBreaker"} reason - La raison de la mise en file.
+
+ * @event ApiClient#circuitBreakerOpen
+ * @type {Object}
+ * @property {number} timestamp - Date (ms) à laquelle le breaker s'est ouvert.
+
+ * @event ApiClient#circuitBreakerReset
+ * @type {void}
+
+ * @event ApiClient#refreshSuccess
+ * @type {Object}
+ * @property {string} token - Le nouveau token d'accès.
+ * @property {string} [refreshToken] - Le nouveau refreshToken (optionnel).
+
+ * @event ApiClient#refreshFailed
+ * @type {Object}
+ * @property {string} error - Le message d’erreur de refresh.
+
+ * @event ApiClient#sessionReset
+ * @type {void}
+
+ * @event ApiClient#validationError
+ * @type {Object}
+ * @property {"pathParams"|"request"|"response"} stage - Étape de validation échouée.
+ * @property {Array<Object>} errors - Erreurs AJV brutes.
+
+ * @event ApiClient#offlineModeChanged
+ * @type {boolean} - true si le client est offline, false sinon.
+ * 
+ * @event ApiClient#userLoggedIn
+ * @param {Object} user - Les données utilisateur extraites de la réponse.
+ */
+ 

package/src/api/UserApi.js

@@ -8,10 +8,16 @@ import { Project } from "./Project.js";
 import { User } from "./User.js";
 
 export class UserApi {
-  constructor(options) {
-    // Injection de dépendance : ApiClient est créé à partir des options
-    this.client = new ApiClient(options);
-    // si l'option "tokenStorageStrategy" est définie, on l'utilise pour créer une instance de ApiClient
+
+  constructor(clientOrOptions) {
+    if (clientOrOptions instanceof ApiClient) {
+      this.client = clientOrOptions;
+    } else {
+      // Injection de dépendance : ApiClient est créé à partir des options
+      this.client = new ApiClient(clientOrOptions);
+      // si l'option "tokenStorageStrategy" est définie, on l'utilise pour créer une instance de ApiClient
+    }
+  
     this.loggedUser = null;
   }
 

package/src/index.js

@@ -2,6 +2,7 @@ import Api from "./Api.js";
 import ApiClient from "./ApiClient.js";
 import * as error from "./error.js";
 import { createDefaultTokenStorageStrategy } from "./utils/createDefaultTokenStorageStrategy.js";
+import OfflineClientManager from "./utils/OfflineClientManager.js";
 import { TokenStorageStrategy } from "./utils/TokenStorage.js";
 
-export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy } };
+export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy }, OfflineClientManager };

package/src/utils/FileOfflineStorageStrategy.node.js

@@ -0,0 +1,47 @@
+// src/utils/FileOfflineStorage.node.js
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import { OfflineQueueStorageStrategy } from "./OfflineQueueStorageStrategy.js";
+
+export class FileOfflineStorage extends OfflineQueueStorageStrategy {
+  constructor(filename = "offline-queue.json", dir = path.join(os.homedir(), ".config", "cocolight")) {
+    super();
+    this.dir = dir;
+    this.filePath = path.join(dir, filename);
+    this._ensureDirectoryExists();
+  }
+
+  _ensureDirectoryExists() {
+    if (!fs.existsSync(this.dir)) {
+      fs.mkdirSync(this.dir, { recursive: true });
+    }
+  }
+  _readFile() {
+    if (!fs.existsSync(this.filePath)) return [];
+    try {
+      const json = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+      return json;
+    } catch (e) {
+      console.error("Erreur lecture offline queue :", e);
+      return [];
+    }
+  }
+
+  _writeFile(queue) {
+    try {
+      fs.writeFileSync(this.filePath, JSON.stringify(queue, null, 2), "utf8");
+    } catch (e) {
+      console.warn("[OfflineQueue] Erreur d'écriture:", e);
+    }
+  }
+
+  async loadQueue() {
+    return this._readFile();
+  }
+
+  async saveQueue(queue) {
+    this._writeFile(queue);
+  }
+}

package/src/utils/OfflineClientManager.js

@@ -0,0 +1,220 @@
+// OfflineClientManager.js
+import ApiClient from "../ApiClient.js";
+import { createDefaultOfflineStrategy } from "./createDefaultOfflineStrategy.js";
+
+export class OfflineClientManager {
+  /**
+   * Initialise un gestionnaire de mode offline pour un ApiClient donné.
+   * 
+   * @param {ApiClient} apiClient - Instance du client principal.
+   */
+  constructor(apiClient) {
+    if(!apiClient || !(apiClient instanceof ApiClient)) {
+      throw new Error("[OfflineClientManager] apiClient doit être une instance de ApiClient");
+    }
+    this._clients = new Map();
+    this._client = apiClient;
+  }
+
+  /**
+   * Attache le gestionnaire offline à une instance ApiClient.
+   * Configure la file d'attente offline, le monitoring réseau, et le ping serveur.
+   *
+   * @param {ApiClient} apiClient - L'instance du client à enrichir.
+   * @param {Object} options
+   * @param {Object} [options.offlineStorageStrategy] - Stratégie de stockage offline.
+   * @param {boolean} [options.disableOfflineMonitoring] - Si true, désactive le monitoring réseau.
+   */
+  static async attachTo(apiClient, options = {}) {
+    apiClient._offlineClientManager = new OfflineClientManager(apiClient);
+    const strategy = await createDefaultOfflineStrategy(options?.offlineStorageStrategy || "auto");
+    await apiClient._offlineClientManager._initOfflineQueue(strategy);
+    if (!options?.disableOfflineMonitoring) {
+      apiClient._offlineClientManager.startOfflineMonitoring(options);
+    }
+  }
+
+  /**
+   * Retourne un ApiClient configuré avec les bons tokens/baseURL pour rejouer une action offline.
+   * Met en cache l'instance pour éviter les recréations.
+   *
+   * @param {Object} meta - Métadonnées contenant baseURL et tokens.
+   * @returns {Promise<ApiClient>}
+   */
+  async getClient(meta) {
+    const key = `${meta.baseURL}|${meta.accessToken}`;
+    if (this._clients.has(key)) return this._clients.get(key);
+
+    const client = new ApiClient({
+      baseURL: meta.baseURL,
+      accessToken: meta.accessToken,
+      refreshToken: meta.refreshToken,
+      debug: this._client._debug,
+    });
+
+    this._clients.set(key, client);
+    return client;
+  }
+
+  /**
+   * Rejoue une action unique depuis la file offline.
+   * 
+   * @param {Object} action - Objet contenant constant, data, options et meta.
+   * @returns {Promise<any>}
+   */
+  async replayAction(action) {
+    const client = await this.getClient(action.meta);
+    try {
+      
+      const result = await client.callEndpoint(
+        action.constant,
+        action.data,
+        action.options?.transformResponseData ?? true,
+        action.options?.validateResponseSchema ?? true
+      );
+      this._client._logger.info(`[OfflineReplay] Succès ${action.constant} sur ${action.meta.baseURL}`);
+      return result;
+    } catch (err) {
+      this._client._logger.error(`[OfflineReplay] Échec ${action.constant}`, err.message);
+      throw err;
+    }
+  }
+
+  /**
+   * Démarre la surveillance de l'état réseau.
+   * Basé sur navigator.onLine + un ping serveur régulier.
+   *
+   * @param {Object} [options]
+   * @param {number} [options.interval=30000] - Intervalle de vérification en ms.
+   * @param {boolean} [options.disableOfflineMonitoring=false] - Pour désactiver.
+   */
+  startOfflineMonitoring({ interval = 30000, disableOfflineMonitoring = false } = {}) {
+    if (disableOfflineMonitoring || this._monitoringStarted) return;
+  
+    this._monitoringStarted = true;
+    this._offlineMode = typeof window !== "undefined" && typeof navigator !== "undefined" && !navigator.onLine;
+  
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => this.setOfflineMode(false));
+      window.addEventListener("offline", () => this.setOfflineMode(true));
+    }
+  
+    this._pingInterval = setInterval(async () => {
+      const wasOffline = this._offlineMode;
+      try {
+        await this._client._client.head("/api/cocolight/infoserver", { timeout: 5000 }); // ✅ utilise la fonction injectée
+        if (wasOffline) this.setOfflineMode(false);
+       
+      // eslint-disable-next-line no-unused-vars
+      } catch (err) {
+        this._client._logger.error("[OfflineMonitor] ping() échoué → passage en offline");
+        this.setOfflineMode(true);
+      }
+    }, interval);
+  }
+
+  /**
+   * Change l'état offline et émet un événement si l'état change.
+   * Déclenche la relecture de la file si on revient online.
+   *
+   * @param {boolean} isOffline
+   */
+  setOfflineMode(isOffline) {
+    if (this._offlineMode === isOffline) return;
+    this._offlineMode = isOffline;
+    if (typeof this._emit === "function") {
+      this._client.emit("offlineModeChanged", isOffline);
+    }
+    this._client._logger.info(`[ApiClient] Mode offline : ${isOffline} (set depuis monitoring)`);
+
+    if (!isOffline && typeof this._replayOfflineQueue === "function") {
+      this._replayOfflineQueue();
+    }
+  }
+
+  /**
+   * Indique si le client est actuellement en mode offline.
+   *
+   * @returns {boolean}
+   */
+  isOffline() {
+    return !!this._offlineMode;
+  }
+
+  /**
+   * Met une action API dans la file offline.
+   *
+   * @param {Object} params
+   * @param {string} params.constant - Le nom de l'endpoint.
+   * @param {Object} params.data - Données à envoyer.
+   * @param {Object} [params.options] - Options de transformation/validation.
+   */
+  async _enqueueOfflineAction({ constant, data, options = {} }) {
+    const hasToken = this._client.getToken() || this._client.getRefreshToken();
+    const endpoint = this._client._endpoints.find(e => e.constant === constant);
+    const authPolicy = endpoint?.authPolicy || (endpoint?.auth === "none" ? "none" : "required");
+    if (authPolicy === "required" && !hasToken) {
+      this._client._logger.warn(`[Offline] Action ignorée : token requis mais absent (${constant})`);
+      return;
+    }
+
+    const action = {
+      constant,
+      data,
+      options,
+      meta: {
+        baseURL: this._client._baseURL,
+        accessToken: this._client.getToken(),
+        refreshToken: this._client.getRefreshToken(),
+        timestamp: Date.now()
+      }
+    };
+
+    this._offlineQueue.push(action);
+    await this._offlineQueueStorage.saveQueue(this._offlineQueue);
+    this._client._logger.info(`[Offline] Action mise en file : ${constant}`);
+  }
+
+  /**
+   * Rejoue toutes les actions offline.
+   * Ré-insère celles qui échouent dans la file.
+   */
+  async _replayOfflineQueue() {
+    const queueCopy = [...this._offlineQueue];
+    this._offlineQueue = [];
+    await this._offlineQueueStorage.saveQueue([]);
+
+    for (const action of queueCopy) {
+      const endpoint = this._client._endpoints.find(e => e.constant === action.constant);
+      const authPolicy = endpoint?.authPolicy || (endpoint?.auth === "none" ? "none" : "required");
+      const hasToken = action.meta.accessToken || action.meta.refreshToken;
+
+      if (authPolicy === "required" && !hasToken) {
+        this._client._logger.warn(`[Offline] Rejetée : token requis manquant (${action.constant})`);
+        continue;
+      }
+
+      try {
+        await this.replayAction(action);
+       
+      } catch (e) {
+        this._client._logger.error("[Offline] Relecture échouée :", e.message);
+        this._offlineQueue.push(action); // requeue si erreur
+      }
+    }
+
+    await this._offlineQueueStorage.saveQueue(this._offlineQueue);
+  }
+
+  /**
+   * Initialise la stratégie de stockage offline et charge la file d’attente.
+   *
+   * @param {OfflineQueueStorageStrategy} storageStrategy
+   */
+  async _initOfflineQueue(storageStrategy) {
+    this._offlineQueueStorage = storageStrategy;
+    this._offlineQueue = await storageStrategy.loadQueue();
+  }
+}
+
+export default OfflineClientManager;

package/src/utils/OfflineQueueStorageStrategy.js

@@ -0,0 +1,51 @@
+// OfflineQueueStorageStrategy.js
+
+export class OfflineQueueStorageStrategy {
+  async loadQueue() {
+    throw new Error("loadQueue() doit être implémenté");
+  }
+  
+  // eslint-disable-next-line no-unused-vars
+  async saveQueue(queue) {
+    throw new Error("saveQueue(queue) doit être implémenté");
+  }
+}
+  
+export class MemoryOfflineStorage extends OfflineQueueStorageStrategy {
+  constructor() {
+    super();
+    this._queue = [];
+  }
+  
+  async loadQueue() {
+    return this._queue;
+  }
+  
+  async saveQueue(queue) {
+    this._queue = [...queue];
+  }
+}
+  
+export class LocalStorageOfflineStorage extends OfflineQueueStorageStrategy {
+  constructor(key = "cocolight-api-offline-queue") {
+    super();
+    this.key = key;
+  }
+  
+  async loadQueue() {
+    try {
+      const raw = localStorage.getItem(this.key);
+      return raw ? JSON.parse(raw) : [];
+    } catch {
+      return [];
+    }
+  }
+  
+  async saveQueue(queue) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(queue));
+    } catch (e) {
+      console.warn("[Offline] Échec du stockage localStorage", e);
+    }
+  }
+}

package/src/utils/createDefaultOfflineStrategy.js

@@ -0,0 +1,29 @@
+import { LocalStorageOfflineStorage, MemoryOfflineStorage } from "./OfflineQueueStorageStrategy.js";
+
+export async function createDefaultOfflineStrategy(offlineStorageStrategy = "auto") {
+  if (offlineStorageStrategy === "memory") {
+    return new MemoryOfflineStorage();
+  }
+  if (offlineStorageStrategy === "localStorage") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return new LocalStorageOfflineStorage();
+    } else {
+      throw new Error("localStorage is not available in this environment.");
+    }
+  }
+  if (offlineStorageStrategy === "file") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      throw new Error("file storage is not available in this environment.");
+    }
+    const { FileOfflineStorage } = await import("./FileOfflineStorageStrategy.node.js");
+    return new FileOfflineStorage();
+  }
+  if (offlineStorageStrategy === "auto") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return new LocalStorageOfflineStorage();
+    } else {
+      const { FileOfflineStorage } = await import("./FileOfflineStorageStrategy.node.js");
+      return new FileOfflineStorage();
+    }
+  }
+}