@altazion/commerce-sdk-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,861 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+class CommerceContext {
+  constructor(options) {
+    __publicField(this, "baseUrl");
+    __publicField(this, "siteUrl");
+    __publicField(this, "sitePk");
+    __publicField(this, "rjsId");
+    __publicField(this, "locale");
+    __publicField(this, "currency");
+    __publicField(this, "mode");
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.siteUrl = options.siteUrl;
+    this.sitePk = options.sitePk;
+    this.rjsId = options.rjsId;
+    this.locale = options.locale ?? "fr-FR";
+    this.currency = options.currency ?? "EUR";
+    this.mode = CommerceContext.detectMode();
+  }
+  static detectMode() {
+    if (typeof navigator !== "undefined" && navigator.userAgent.includes("Altazion Device Shell")) {
+      return "kiosk";
+    }
+    return "browser";
+  }
+}
+class AltazionApiError extends Error {
+  constructor(status, problem) {
+    super(problem.detail ?? problem.title ?? `HTTP ${status}`);
+    __publicField(this, "status");
+    __publicField(this, "problem");
+    this.name = "AltazionApiError";
+    this.status = status;
+    this.problem = problem;
+  }
+}
+class OfflineError extends Error {
+  constructor(message = "Le SDK est hors-ligne et aucun cache n'est disponible pour cette ressource") {
+    super(message);
+    this.name = "OfflineError";
+  }
+}
+class CacheError extends Error {
+  constructor(message, cause) {
+    super(message);
+    __publicField(this, "cause");
+    this.name = "CacheError";
+    this.cause = cause;
+  }
+}
+class QueueFlushError extends Error {
+  constructor(operationId, apiError) {
+    super(`Échec du rejeu de l'opération ${operationId} : ${apiError.message}`);
+    __publicField(this, "failedOperationId");
+    __publicField(this, "apiError");
+    this.name = "QueueFlushError";
+    this.failedOperationId = operationId;
+    this.apiError = apiError;
+  }
+}
+class CommerceHttpAdapter {
+  constructor(context) {
+    __publicField(this, "context");
+    this.context = context;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", body, headers = {}, maxRetries = 2 } = options;
+    const url = `${this.context.baseUrl}${path}`;
+    const requestHeaders = {
+      Accept: "application/json",
+      "Accept-Language": this.context.locale,
+      ...headers
+    };
+    if (body !== void 0) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    const init = {
+      method,
+      headers: requestHeaders,
+      credentials: "include",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    };
+    let lastNetworkError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, init);
+        return await this.handleResponse(response);
+      } catch (err) {
+        if (err instanceof AltazionApiError) throw err;
+        lastNetworkError = err;
+        if (attempt < maxRetries) {
+          await delay(150 * Math.pow(2, attempt));
+        }
+      }
+    }
+    throw lastNetworkError;
+  }
+  async handleResponse(response) {
+    if (response.ok) {
+      const contentType = response.headers.get("content-type") ?? "";
+      if (response.status === 204 || !contentType.includes("application/json")) {
+        return void 0;
+      }
+      return response.json();
+    }
+    let problem = { status: response.status };
+    try {
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json") || contentType.includes("application/problem+json")) {
+        problem = await response.json();
+        problem.status ?? (problem.status = response.status);
+      }
+    } catch {
+    }
+    throw new AltazionApiError(response.status, problem);
+  }
+  /** Effectue un GET et retourne T */
+  get(path, headers) {
+    return this.request(path, { method: "GET", headers });
+  }
+  /** Effectue un POST avec un body JSON et retourne T */
+  post(path, body, headers) {
+    return this.request(path, { method: "POST", body, headers });
+  }
+  /** Effectue un PUT avec un body JSON et retourne T */
+  put(path, body, headers) {
+    return this.request(path, { method: "PUT", body, headers });
+  }
+  /** Effectue un PATCH avec un body JSON et retourne T */
+  patch(path, body, headers) {
+    return this.request(path, { method: "PATCH", body, headers });
+  }
+  /** Effectue un DELETE et retourne T */
+  delete(path, headers) {
+    return this.request(path, { method: "DELETE", headers });
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class ConnectivityManager {
+  constructor() {
+    __publicField(this, "status");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "handleOnline", () => {
+      this.status = "online";
+      this.emit("online");
+    });
+    __publicField(this, "handleOffline", () => {
+      this.status = "offline";
+      this.emit("offline");
+    });
+    this.status = this.readOnlineStatus();
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", this.handleOnline);
+      window.addEventListener("offline", this.handleOffline);
+    }
+  }
+  get isOnline() {
+    return this.status === "online";
+  }
+  get isOffline() {
+    return this.status === "offline";
+  }
+  /**
+   * Abonne un listener aux changements de connectivité.
+   * Retourne une fonction de désabonnement.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Libère les event listeners sur window. */
+  dispose() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this.handleOnline);
+      window.removeEventListener("offline", this.handleOffline);
+    }
+    this.listeners.clear();
+  }
+  readOnlineStatus() {
+    if (typeof navigator === "undefined" || navigator.onLine === void 0) {
+      return "online";
+    }
+    return navigator.onLine ? "online" : "offline";
+  }
+  emit(status) {
+    for (const listener of this.listeners) {
+      try {
+        listener(status);
+      } catch {
+      }
+    }
+  }
+}
+class WorkerBridge {
+  constructor() {
+    __publicField(this, "port", null);
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "requestCounter", 0);
+    __publicField(this, "fallback", /* @__PURE__ */ new Map());
+    __publicField(this, "usingFallback");
+    __publicField(this, "handleMessage", (event) => {
+      const { id, result, error } = event.data;
+      const pending = this.pending.get(id);
+      if (!pending) return;
+      this.pending.delete(id);
+      if (error !== void 0) {
+        pending.reject(new CacheError(error));
+      } else {
+        pending.resolve(result);
+      }
+    });
+    this.usingFallback = !this.tryStartWorker();
+  }
+  tryStartWorker() {
+    if (typeof SharedWorker === "undefined") return false;
+    try {
+      const worker = new SharedWorker(
+        new URL(
+          /* @vite-ignore */
+          "/assets/cache.worker-BX4nA-m-.js",
+          typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href
+        ),
+        { type: "module", name: "altazion-cache-worker" }
+      );
+      this.port = worker.port;
+      this.port.addEventListener("message", this.handleMessage);
+      this.port.start();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  nextId() {
+    return String(++this.requestCounter);
+  }
+  send(message) {
+    return new Promise((resolve, reject) => {
+      if (!this.port) {
+        reject(new CacheError("Worker non initialisé"));
+        return;
+      }
+      const id = this.nextId();
+      this.pending.set(id, { resolve, reject });
+      this.port.postMessage({ ...message, id });
+    });
+  }
+  async get(key) {
+    if (this.usingFallback) {
+      const entry = this.fallback.get(key);
+      if (!entry || Date.now() > entry.expiresAt) return null;
+      return entry.data;
+    }
+    return this.send({ type: "GET", key });
+  }
+  async set(key, data, ttlMs) {
+    if (this.usingFallback) {
+      this.fallback.set(key, { data, expiresAt: Date.now() + ttlMs });
+      return;
+    }
+    await this.send({ type: "SET", key, data, ttl: ttlMs });
+  }
+  async invalidate(pattern) {
+    if (this.usingFallback) {
+      const regex = new RegExp(pattern);
+      for (const key of this.fallback.keys()) {
+        if (regex.test(key)) this.fallback.delete(key);
+      }
+      return;
+    }
+    await this.send({ type: "INVALIDATE", pattern });
+  }
+  async clearAll() {
+    if (this.usingFallback) {
+      this.fallback.clear();
+      return;
+    }
+    await this.send({ type: "CLEAR_ALL" });
+  }
+  dispose() {
+    var _a;
+    (_a = this.port) == null ? void 0 : _a.removeEventListener("message", this.handleMessage);
+    this.pending.clear();
+  }
+}
+const DEFAULT_TTL = {
+  "network-first": 3e4,
+  // 30 secondes (session, panier)
+  "cache-first": 5 * 6e4,
+  // 5 minutes (recherche)
+  "stale-while-revalidate": 60 * 6e4
+  // 1 heure (catalogue)
+};
+class CacheStrategy {
+  constructor(bridge, http) {
+    this.bridge = bridge;
+    this.http = http;
+  }
+  /**
+   * Exécute la requête selon la stratégie choisie.
+   *
+   * @param key        Clé de cache (généralement le path + params)
+   * @param fetcher    Fonction qui effectue la requête HTTP
+   * @param strategy   Stratégie à appliquer
+   * @param ttlMs      TTL du cache (override la valeur par défaut)
+   */
+  async execute(key, fetcher, strategy, ttlMs) {
+    switch (strategy) {
+      case "network-only":
+        return fetcher();
+      case "network-first":
+        return this.networkFirst(key, fetcher, ttlMs ?? DEFAULT_TTL["network-first"]);
+      case "cache-first":
+        return this.cacheFirst(key, fetcher, ttlMs ?? DEFAULT_TTL["cache-first"]);
+      case "stale-while-revalidate":
+        return this.staleWhileRevalidate(key, fetcher, ttlMs ?? DEFAULT_TTL["stale-while-revalidate"]);
+    }
+  }
+  async networkFirst(key, fetcher, ttlMs) {
+    try {
+      const data = await fetcher();
+      await this.bridge.set(key, data, ttlMs);
+      return data;
+    } catch (err) {
+      if (err instanceof TypeError) {
+        const cached = await this.bridge.get(key);
+        if (cached !== null) return cached;
+      }
+      throw err;
+    }
+  }
+  async cacheFirst(key, fetcher, ttlMs) {
+    const cached = await this.bridge.get(key);
+    if (cached !== null) return cached;
+    const data = await fetcher();
+    await this.bridge.set(key, data, ttlMs);
+    return data;
+  }
+  async staleWhileRevalidate(key, fetcher, ttlMs) {
+    const cached = await this.bridge.get(key);
+    fetcher().then((data2) => this.bridge.set(key, data2, ttlMs)).catch(() => {
+    });
+    if (cached !== null) {
+      return cached;
+    }
+    const data = await fetcher();
+    await this.bridge.set(key, data, ttlMs);
+    return data;
+  }
+}
+const DB_NAME = "altazion-queue";
+const DB_VERSION = 1;
+const STORE_NAME = "operations";
+class OfflineQueue {
+  constructor() {
+    __publicField(this, "db", null);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "counter", 0);
+  }
+  /** Abonne un listener aux événements de file. Retourne une fonction de désabonnement. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  get pendingCount() {
+    return this.openDb().then(
+      (db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, "readonly");
+        const req = tx.objectStore(STORE_NAME).count();
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+      })
+    );
+  }
+  async enqueue(method, path, body, headers) {
+    const operation = {
+      id: `${Date.now()}-${++this.counter}`,
+      enqueuedAt: Date.now(),
+      method,
+      path,
+      body,
+      headers,
+      attempts: 0
+    };
+    const db = await this.openDb();
+    await this.put(db, operation);
+    this.emit({ type: "enqueued", operation });
+    return operation;
+  }
+  /**
+   * Rejoue toutes les opérations en attente dans l'ordre d'enfilage.
+   * S'arrête sur un conflit (4xx) et émet un événement `conflict`.
+   */
+  async flush(http) {
+    const operations = await this.getAll();
+    if (operations.length === 0) return;
+    for (const op of operations) {
+      try {
+        op.attempts++;
+        await http.request(op.path, {
+          method: op.method,
+          body: op.body,
+          headers: op.headers
+        });
+        await this.remove(op.id);
+      } catch (err) {
+        if (err instanceof AltazionApiError && err.status >= 400 && err.status < 500) {
+          const flushError = new QueueFlushError(op.id, err);
+          this.emit({ type: "conflict", operation: op, error: flushError });
+          return;
+        }
+        await this.put(await this.openDb(), op);
+        return;
+      }
+    }
+    this.emit({ type: "flushed" });
+    const remaining = await this.pendingCount;
+    if (remaining === 0) {
+      this.emit({ type: "emptied" });
+    }
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  openDb() {
+    return new Promise((resolve, reject) => {
+      if (this.db) {
+        resolve(this.db);
+        return;
+      }
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onupgradeneeded = (event) => {
+        const database = event.target.result;
+        if (!database.objectStoreNames.contains(STORE_NAME)) {
+          database.createObjectStore(STORE_NAME, { keyPath: "id" });
+        }
+      };
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        resolve(this.db);
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  put(db, operation) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      const req = tx.objectStore(STORE_NAME).put(operation);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  remove(id) {
+    return this.openDb().then(
+      (db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, "readwrite");
+        const req = tx.objectStore(STORE_NAME).delete(id);
+        req.onsuccess = () => resolve();
+        req.onerror = () => reject(req.error);
+      })
+    );
+  }
+  getAll() {
+    return this.openDb().then(
+      (db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, "readonly");
+        const req = tx.objectStore(STORE_NAME).getAll();
+        req.onsuccess = () => {
+          const ops = req.result.sort(
+            (a, b) => a.enqueuedAt - b.enqueuedAt
+          );
+          resolve(ops);
+        };
+        req.onerror = () => reject(req.error);
+      })
+    );
+  }
+}
+class BrowserSessionManager {
+  constructor(http, context) {
+    __publicField(this, "http");
+    __publicField(this, "context");
+    this.http = http;
+    this.context = context;
+  }
+  async initialize() {
+    try {
+      const existing = await this.http.get("/commerce/api/sessions/raw");
+      return existing;
+    } catch (err) {
+      if (err instanceof AltazionApiError && err.status === 404) {
+        return this.createSession();
+      }
+      throw err;
+    }
+  }
+  async onSessionExpired() {
+    await this.createSession();
+  }
+  async createSession() {
+    const body = this.buildCreationRequest();
+    return this.http.post("/commerce/api/sessions/create", body);
+  }
+  buildCreationRequest() {
+    if (this.context.sitePk !== void 0 && this.context.rjsId !== void 0) {
+      return { sitePk: this.context.sitePk, rjsId: this.context.rjsId };
+    }
+    if (this.context.siteUrl !== void 0) {
+      return { siteUrl: this.context.siteUrl };
+    }
+    const currentUrl = typeof window !== "undefined" ? window.location.href : void 0;
+    return { siteUrl: currentUrl };
+  }
+}
+class KioskSessionManager {
+  async initialize() {
+    return null;
+  }
+  async onSessionExpired() {
+  }
+}
+class SessionManagerFactory {
+  static create(http, context) {
+    if (context.mode === "kiosk") {
+      return new KioskSessionManager();
+    }
+    return new BrowserSessionManager(http, context);
+  }
+}
+class SessionModule {
+  constructor(http, cache) {
+    this.http = http;
+    this.cache = cache;
+  }
+  /** Récupère les informations de la session en cours */
+  getSession() {
+    return this.cache.execute(
+      "session:raw",
+      () => this.http.get("/commerce/api/sessions/raw"),
+      "network-first"
+    );
+  }
+  /** Associe un magasin à la session */
+  async associateStore(storeGuid) {
+    const result = await this.http.post(
+      `/commerce/api/sessions/associate/store/${storeGuid}`
+    );
+    await this.cache.execute("session:raw", () => Promise.resolve(result), "network-first");
+    return result;
+  }
+}
+class CartModule {
+  constructor(http, cache, queue, connectivity) {
+    this.http = http;
+    this.cache = cache;
+    this.queue = queue;
+    this.connectivity = connectivity;
+  }
+  /** Récupère le panier en cours */
+  getCart() {
+    return this.cache.execute(
+      "cart:current",
+      () => this.http.get("/commerce/api/process/cart"),
+      "network-first"
+    );
+  }
+  /** Récupère le statut de validation du panier */
+  getValidationStatus() {
+    return this.http.get("/commerce/api/process/cart/status/check");
+  }
+  /** Ajoute un article au panier */
+  async addItem(reference, quantity, options) {
+    const body = { reference, quantity, ...options };
+    if (this.connectivity.isOffline) {
+      await this.queue.enqueue("POST", "/commerce/api/process/cart/items", body);
+      return this.cache.execute("cart:current", () => this.http.get("/commerce/api/process/cart"), "network-first");
+    }
+    const cart = await this.http.post("/commerce/api/process/cart/items", body);
+    await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    return cart;
+  }
+  /** Met à jour la quantité d'une ligne */
+  async updateItem(lineId, quantity) {
+    const body = { quantity };
+    if (this.connectivity.isOffline) {
+      await this.queue.enqueue("PUT", `/commerce/api/process/cart/items/${lineId}`, body);
+      return this.cache.execute("cart:current", () => this.http.get("/commerce/api/process/cart"), "network-first");
+    }
+    const cart = await this.http.put(`/commerce/api/process/cart/items/${lineId}`, body);
+    await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    return cart;
+  }
+  /** Supprime une ligne du panier */
+  async removeItem(lineId) {
+    if (this.connectivity.isOffline) {
+      await this.queue.enqueue("DELETE", `/commerce/api/process/cart/items/${lineId}`);
+      return this.cache.execute("cart:current", () => this.http.get("/commerce/api/process/cart"), "network-first");
+    }
+    const cart = await this.http.delete(`/commerce/api/process/cart/items/${lineId}`);
+    await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    return cart;
+  }
+  /** Applique un coupon */
+  async applyCoupon(code) {
+    const cart = await this.http.post("/commerce/api/process/cart/coupons", { code });
+    await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    return cart;
+  }
+  /** Retire un coupon */
+  async removeCoupon(code) {
+    const cart = await this.http.delete(`/commerce/api/process/cart/coupons/${encodeURIComponent(code)}`);
+    await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    return cart;
+  }
+}
+class CatalogModule {
+  constructor(http, cache) {
+    this.http = http;
+    this.cache = cache;
+  }
+  /** Récupère le détail d'un produit par sa référence */
+  getProduct(reference) {
+    return this.cache.execute(
+      `catalog:product:${reference}`,
+      () => this.http.get(`/commerce/api/pim/products/${encodeURIComponent(reference)}`),
+      "stale-while-revalidate"
+    );
+  }
+  /** Récupère une liste de produits par leurs références */
+  getProducts(references) {
+    const key = `catalog:products:${references.sort().join(",")}`;
+    return this.cache.execute(
+      key,
+      () => this.http.post("/commerce/api/pim/products/batch", { references }),
+      "stale-while-revalidate"
+    );
+  }
+  /** Récupère les produits d'une catégorie */
+  getCategory(categoryCode, pageIndex = 0, pageSize = 20) {
+    const key = `catalog:category:${categoryCode}:${pageIndex}:${pageSize}`;
+    return this.cache.execute(
+      key,
+      () => this.http.get(
+        `/commerce/api/pim/categories/${encodeURIComponent(categoryCode)}/products?pageIndex=${pageIndex}&pageSize=${pageSize}`
+      ),
+      "stale-while-revalidate"
+    );
+  }
+  /** Effectue une recherche full-text */
+  search(request) {
+    const key = `catalog:search:${JSON.stringify(request)}`;
+    return this.cache.execute(
+      key,
+      () => this.http.post("/commerce/api/pim/search", request),
+      "cache-first"
+    );
+  }
+  /** Récupère les suggestions de recherche (autocomplete) */
+  suggest(query) {
+    return this.cache.execute(
+      `catalog:suggest:${query}`,
+      () => this.http.get(`/commerce/api/pim/search/suggest?q=${encodeURIComponent(query)}`),
+      "cache-first",
+      2 * 6e4
+      // 2 minutes pour les suggestions
+    );
+  }
+}
+class ShippingModule {
+  constructor(http, cache) {
+    this.http = http;
+    this.cache = cache;
+  }
+  /** Récupère les groupes de modes de livraison disponibles pour le panier en cours */
+  getAvailableModes() {
+    return this.cache.execute(
+      "shipping:modes",
+      () => this.http.get("/commerce/api/process/cart/shipping/modes"),
+      "network-first"
+    );
+  }
+  /** Sélectionne un mode de livraison */
+  selectMode(shippingModeGuid) {
+    return this.http.post("/commerce/api/process/cart/shipping/mode", { shippingModeGuid });
+  }
+  /** Met à jour l'adresse de livraison */
+  setAddress(address) {
+    return this.http.put("/commerce/api/process/cart/address/shipping", address);
+  }
+  /** Recherche des points relais à proximité */
+  getRelayPoints(postalCode, countryCode = "FR", shippingModeGuid) {
+    const params = new URLSearchParams({ postalCode, countryCode });
+    if (shippingModeGuid) params.set("shippingModeGuid", shippingModeGuid);
+    const key = `shipping:relays:${postalCode}:${countryCode}:${shippingModeGuid ?? ""}`;
+    return this.cache.execute(
+      key,
+      () => this.http.get(`/commerce/api/process/shipping/relays?${params.toString()}`),
+      "cache-first",
+      10 * 6e4
+      // 10 minutes
+    );
+  }
+}
+class MarketingModule {
+  constructor(http, cache) {
+    this.http = http;
+    this.cache = cache;
+  }
+  /** Récupère un item marketing par son code */
+  getItem(code) {
+    return this.cache.execute(
+      `marketing:item:${code}`,
+      () => this.http.get(`/commerce/api/marketing/items/${encodeURIComponent(code)}`),
+      "stale-while-revalidate"
+    );
+  }
+  /** Récupère plusieurs items marketing par leurs codes */
+  getItems(codes) {
+    const key = `marketing:items:${codes.sort().join(",")}`;
+    return this.cache.execute(
+      key,
+      () => this.http.post("/commerce/api/marketing/items/batch", { codes }),
+      "stale-while-revalidate"
+    );
+  }
+}
+class StoresModule {
+  constructor(http, cache) {
+    this.http = http;
+    this.cache = cache;
+  }
+  /** Recherche des magasins par coordonnées géographiques */
+  findByLocation(latitude, longitude, radiusKm = 50) {
+    const key = `stores:geo:${latitude.toFixed(4)}:${longitude.toFixed(4)}:${radiusKm}`;
+    return this.cache.execute(
+      key,
+      () => this.http.get(
+        `/commerce/api/stores/locator?lat=${latitude}&lon=${longitude}&radius=${radiusKm}`
+      ),
+      "cache-first",
+      15 * 6e4
+      // 15 minutes
+    );
+  }
+  /** Recherche des magasins par code postal */
+  findByPostalCode(postalCode, countryCode = "FR") {
+    const key = `stores:postal:${postalCode}:${countryCode}`;
+    return this.cache.execute(
+      key,
+      () => this.http.get(
+        `/commerce/api/stores/locator?postalCode=${encodeURIComponent(postalCode)}&countryCode=${encodeURIComponent(countryCode)}`
+      ),
+      "cache-first",
+      15 * 6e4
+    );
+  }
+  /** Récupère le détail d'un magasin par son GUID */
+  getStore(storeGuid) {
+    return this.cache.execute(
+      `stores:detail:${storeGuid}`,
+      () => this.http.get(`/commerce/api/stores/${storeGuid}`),
+      "stale-while-revalidate"
+    );
+  }
+}
+class CommerceClient {
+  constructor(options) {
+    __publicField(this, "context");
+    __publicField(this, "connectivity");
+    __publicField(this, "session");
+    __publicField(this, "cart");
+    __publicField(this, "catalog");
+    __publicField(this, "shipping");
+    __publicField(this, "marketing");
+    __publicField(this, "stores");
+    __publicField(this, "http");
+    __publicField(this, "workerBridge");
+    __publicField(this, "cacheStrategy");
+    __publicField(this, "offlineQueue");
+    __publicField(this, "sessionManager");
+    __publicField(this, "unsubscribeOnline", null);
+    this.context = new CommerceContext(options);
+    this.http = new CommerceHttpAdapter(this.context);
+    this.connectivity = new ConnectivityManager();
+    this.workerBridge = new WorkerBridge();
+    this.cacheStrategy = new CacheStrategy(this.workerBridge, this.http);
+    this.offlineQueue = new OfflineQueue();
+    this.sessionManager = SessionManagerFactory.create(this.http, this.context);
+    this.session = new SessionModule(this.http, this.cacheStrategy);
+    this.cart = new CartModule(this.http, this.cacheStrategy, this.offlineQueue, this.connectivity);
+    this.catalog = new CatalogModule(this.http, this.cacheStrategy);
+    this.shipping = new ShippingModule(this.http, this.cacheStrategy);
+    this.marketing = new MarketingModule(this.http, this.cacheStrategy);
+    this.stores = new StoresModule(this.http, this.cacheStrategy);
+  }
+  /**
+   * Initialise le SDK :
+   * - Crée la session si nécessaire (mode browser uniquement)
+   * - Abonne le flush automatique de la file hors-ligne au retour en ligne
+   */
+  async initialize() {
+    this.unsubscribeOnline = this.connectivity.subscribe(async (status) => {
+      if (status === "online") {
+        await this.offlineQueue.flush(this.http);
+      }
+    });
+    return this.sessionManager.initialize();
+  }
+  /**
+   * Retourne vrai si le SDK est hors-ligne.
+   */
+  get isOffline() {
+    return this.connectivity.isOffline;
+  }
+  /**
+   * Retourne le nombre d'opérations en attente dans la file hors-ligne.
+   */
+  get pendingOperationsCount() {
+    return this.offlineQueue.pendingCount;
+  }
+  /**
+   * Abonne un listener aux événements de la file hors-ligne.
+   * Retourne une fonction de désabonnement.
+   */
+  onQueueEvent(listener) {
+    return this.offlineQueue.subscribe(listener);
+  }
+  /**
+   * Force le vidage du cache.
+   */
+  clearCache() {
+    return this.workerBridge.clearAll();
+  }
+  /**
+   * Libère les ressources (listeners, worker).
+   */
+  dispose() {
+    var _a;
+    (_a = this.unsubscribeOnline) == null ? void 0 : _a.call(this);
+    this.connectivity.dispose();
+    this.workerBridge.dispose();
+  }
+}
+exports.AltazionApiError = AltazionApiError;
+exports.CacheError = CacheError;
+exports.CommerceClient = CommerceClient;
+exports.CommerceContext = CommerceContext;
+exports.ConnectivityManager = ConnectivityManager;
+exports.OfflineError = OfflineError;
+exports.QueueFlushError = QueueFlushError;
+//# sourceMappingURL=index.cjs.map