@altazion/commerce-sdk-core 26.519.8051 → 26.601.8204

package/dist/index.cjs

@@ -416,19 +416,128 @@ class SessionModule {
     return result;
   }
 }
+const CART_SUMMARY_KEY = "cart:summary:current";
+const DEFAULT_SUMMARY_STALE_TTL_MS = 9e4;
+const DEFAULT_STORAGE_TTL_MS = 24 * 60 * 6e4;
+class CartSummaryStore {
+  constructor(bridge, options) {
+    __publicField(this, "summary", null);
+    __publicField(this, "staleTtlMs");
+    __publicField(this, "storageTtlMs");
+    this.bridge = bridge;
+    this.staleTtlMs = (options == null ? void 0 : options.staleTtlMs) ?? DEFAULT_SUMMARY_STALE_TTL_MS;
+    this.storageTtlMs = (options == null ? void 0 : options.storageTtlMs) ?? DEFAULT_STORAGE_TTL_MS;
+  }
+  peek() {
+    return this.summary;
+  }
+  async get() {
+    if (this.summary !== null) {
+      return this.summary;
+    }
+    this.summary = await this.bridge.get(CART_SUMMARY_KEY);
+    return this.summary;
+  }
+  isStale(summary) {
+    if (summary === null) {
+      return true;
+    }
+    return Date.now() >= Date.parse(summary.staleAt);
+  }
+  async setFromCart(cart) {
+    const now = Date.now();
+    const summary = buildCartSummarySnapshot(cart, now, this.staleTtlMs);
+    this.summary = summary;
+    await this.bridge.set(CART_SUMMARY_KEY, summary, this.storageTtlMs);
+    return summary;
+  }
+  async clear() {
+    this.summary = null;
+    await this.bridge.invalidate("^cart:summary:current$");
+  }
+}
+function buildCartSummarySnapshot(cart, now, staleTtlMs) {
+  const content = cart.content ?? [];
+  const topLevelLines = content.flatMap((entry) => getMainLines(entry));
+  return {
+    cartGuid: cart.guid,
+    sourceCartLastModifiedDate: cart.lastModifiedDate,
+    cachedAt: new Date(now).toISOString(),
+    staleAt: new Date(now + staleTtlMs).toISOString(),
+    totalAmountWithTax: cart.totalAmountWithTax,
+    totalQuantity: cart.totalQuantity,
+    mainReferencesCount: countDistinctReferences(topLevelLines),
+    mainQuantity: sumQuantities(topLevelLines),
+    contents: content.map((entry) => buildContentSummary(entry))
+  };
+}
+function buildContentSummary(content) {
+  const mainLines = getMainLines(content);
+  return {
+    contentType: content.contentType,
+    totalAmountWithTax: content.totalAmountWithTax,
+    mainReferencesCount: countDistinctReferences(mainLines),
+    mainLinesCount: mainLines.length,
+    mainQuantity: sumQuantities(mainLines)
+  };
+}
+function getMainLines(content) {
+  return (content.lines ?? []).filter((line) => !line.parentLineId);
+}
+function countDistinctReferences(lines) {
+  var _a;
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const key = ((_a = line.reference) == null ? void 0 : _a.trim()) || line.productGuid;
+    if (key) {
+      keys.add(key);
+    }
+  }
+  return keys.size;
+}
+function sumQuantities(lines) {
+  return lines.reduce((total, line) => total + line.quantity, 0);
+}
 class CartModule {
-  constructor(http, cache, connectivity) {
+  constructor(http, cache, connectivity, bridge) {
+    __publicField(this, "summaryStore");
     this.http = http;
     this.cache = cache;
     this.connectivity = connectivity;
+    this.summaryStore = new CartSummaryStore(bridge);
   }
   /** Récupère le panier en cours */
-  getCart() {
-    return this.cache.execute(
+  async getCart() {
+    const cart = await this.cache.execute(
       "cart:current",
       () => this.http.get("/commerce/api/process/cart"),
       "network-first"
     );
+    await this.summaryStore.setFromCart(cart);
+    return cart;
+  }
+  /** Retourne le dernier résumé panier disponible sans forcer un accès réseau */
+  peekSummary() {
+    return this.summaryStore.peek();
+  }
+  /** Retourne le résumé panier local et lance une revalidation lazy si nécessaire */
+  async getSummary() {
+    const summary = await this.summaryStore.get();
+    if (summary !== null) {
+      if (this.summaryStore.isStale(summary) && !this.connectivity.isOffline) {
+        void this.refreshSummary();
+      }
+      return summary;
+    }
+    if (this.connectivity.isOffline) {
+      return null;
+    }
+    return this.refreshSummary();
+  }
+  /** Force le rechargement du panier puis du résumé local */
+  async refreshSummary() {
+    const cart = await this.getCart();
+    return this.summaryStore.setFromCart(cart);
   }
   /** Récupère le statut de validation du panier */
   getValidationStatus() {
@@ -440,6 +549,7 @@ class CartModule {
     const body = { reference, quantity, ...options };
     const cart = await this.http.post("/commerce/api/process/cart/items", body);
     await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    await this.summaryStore.setFromCart(cart);
     return cart;
   }
   /** Met à jour la quantité d'une ligne */
@@ -448,6 +558,7 @@ class CartModule {
     const body = { quantity };
     const cart = await this.http.put(`/commerce/api/process/cart/items/${lineId}`, body);
     await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    await this.summaryStore.setFromCart(cart);
     return cart;
   }
   /** Supprime une ligne du panier */
@@ -455,6 +566,7 @@ class CartModule {
     this.ensureOnline();
     const cart = await this.http.delete(`/commerce/api/process/cart/items/${lineId}`);
     await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    await this.summaryStore.setFromCart(cart);
     return cart;
   }
   /** Applique un coupon */
@@ -462,6 +574,7 @@ class CartModule {
     this.ensureOnline();
     const cart = await this.http.post("/commerce/api/process/cart/coupons", { code });
     await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    await this.summaryStore.setFromCart(cart);
     return cart;
   }
   /** Retire un coupon */
@@ -469,6 +582,7 @@ class CartModule {
     this.ensureOnline();
     const cart = await this.http.delete(`/commerce/api/process/cart/coupons/${encodeURIComponent(code)}`);
     await this.cache.execute("cart:current", () => Promise.resolve(cart), "network-first");
+    await this.summaryStore.setFromCart(cart);
     return cart;
   }
   ensureOnline() {
@@ -627,6 +741,734 @@ class StoresModule {
     );
   }
 }
+class DeviceNotification {
+  constructor() {
+    __publicField(this, "kind");
+    __publicField(this, "associatedDevice");
+    __publicField(this, "jsonData");
+    __publicField(this, "rawData");
+  }
+  getData() {
+    return decodeNotificationData(this.rawData ?? this.jsonData);
+  }
+  getRecordData() {
+    return asRecord(this.getData());
+  }
+  getNormalizedPayload() {
+    const raw = this.getRecordData();
+    if (!raw) {
+      return null;
+    }
+    return normalizeDevicePayload(raw, this.associatedDevice);
+  }
+}
+class PeripheralBase {
+  constructor() {
+    __publicField(this, "name", "");
+    __publicField(this, "guid", "");
+    __publicField(this, "type", "");
+    __publicField(this, "state", null);
+  }
+  isAvailable() {
+    if (this.state == null) {
+      return true;
+    }
+    switch (this.state.toLowerCase()) {
+      case "available":
+      case "active":
+        return true;
+      default:
+        return false;
+    }
+  }
+  IsAvailable() {
+    return this.isAvailable();
+  }
+}
+class PeripheralBarCode extends PeripheralBase {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "globalListener");
+    __publicField(this, "successListener");
+    __publicField(this, "failureListener");
+  }
+  on(callback) {
+    this.globalListener = callback;
+  }
+  onSuccess(callback) {
+    this.successListener = callback;
+  }
+  onError(callback) {
+    this.failureListener = callback;
+  }
+  dispatchNotification(notification) {
+    var _a;
+    (_a = this.globalListener) == null ? void 0 : _a.call(this, notification);
+  }
+  dispatchSuccess(type, orderGuid, notification) {
+    var _a;
+    (_a = this.successListener) == null ? void 0 : _a.call(this, type, orderGuid, notification);
+  }
+  dispatchFailure(type, orderGuid, notification) {
+    var _a;
+    (_a = this.failureListener) == null ? void 0 : _a.call(this, type, orderGuid, notification);
+  }
+}
+class PeripheralTpe extends PeripheralBase {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "globalListener");
+    __publicField(this, "successListener");
+    __publicField(this, "failureListener");
+  }
+  on(callback) {
+    this.globalListener = callback;
+  }
+  onSuccess(callback) {
+    this.successListener = callback;
+  }
+  onFailure(callback) {
+    this.failureListener = callback;
+  }
+  onError(callback) {
+    this.failureListener = callback;
+  }
+  dispatchNotification(notification) {
+    var _a;
+    (_a = this.globalListener) == null ? void 0 : _a.call(this, notification);
+  }
+  dispatchSuccess(type, orderGuid, notification) {
+    var _a;
+    (_a = this.successListener) == null ? void 0 : _a.call(this, type, orderGuid, notification);
+  }
+  dispatchFailure(type, orderGuid, notification) {
+    var _a;
+    (_a = this.failureListener) == null ? void 0 : _a.call(this, type, orderGuid, notification);
+  }
+}
+class DeviceManager {
+  constructor() {
+    __publicField(this, "initialized", false);
+    __publicField(this, "globalListener");
+    __publicField(this, "peripherals", []);
+    __publicField(this, "host");
+    __publicField(this, "hostListener", (event) => {
+      const notification = this.normalizeNotification(event.data);
+      if (notification) {
+        this.notify(notification);
+      }
+    });
+    var _a;
+    this.host = this.resolveHost();
+    (_a = this.host) == null ? void 0 : _a.addEventListener("message", this.hostListener);
+  }
+  get isHostAvailable() {
+    return this.host !== null;
+  }
+  registerGlobalCallback(callback) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    this.globalListener = callback;
+  }
+  initialize(mockMode = false) {
+    var _a;
+    if (!mockMode && !this.isHostAvailable) {
+      return;
+    }
+    this.initialized = true;
+    this.peripherals = [];
+    if (mockMode) {
+      const mockTpe = new DeviceTpeMock((notification) => this.notify(notification));
+      mockTpe.guid = "86602b7f-3d17-4715-9b5f-7109f4fe92f4";
+      mockTpe.name = "MockTPE";
+      mockTpe.type = "TPE";
+      this.peripherals.push(mockTpe);
+      return;
+    }
+    (_a = this.host) == null ? void 0 : _a.postMessage({
+      kind: "DeviceManager.Init"
+    });
+  }
+  init(mockMode = false) {
+    this.initialize(mockMode);
+  }
+  dispose() {
+    var _a;
+    (_a = this.host) == null ? void 0 : _a.removeEventListener("message", this.hostListener);
+  }
+  findPeripheral(guid) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    for (const peripheral of this.peripherals) {
+      if (peripheral.guid === guid) {
+        return peripheral;
+      }
+    }
+    return null;
+  }
+  findPeripheralByType(type) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    return this.peripherals.filter((peripheral) => peripheral.type.toLowerCase() === type.toLowerCase());
+  }
+  findPeripheralsByType(type) {
+    return this.findPeripheralByType(type);
+  }
+  notify(notification) {
+    var _a, _b, _c;
+    if (notification.kind.trim().length === 0) {
+      return;
+    }
+    const kind = notification.kind.toLowerCase();
+    switch (kind) {
+      case "status_update": {
+        const device = notification.associatedDevice ? this.findPeripheral(notification.associatedDevice) : null;
+        const status = this.readStatus(notification);
+        if (device && status) {
+          device.state = status;
+        }
+        (_a = this.globalListener) == null ? void 0 : _a.call(this, notification);
+        break;
+      }
+      case "init": {
+        this.initialized = true;
+        this.peripherals = this.createPeripherals(resolveDeviceDescriptors(notification.getData()));
+        (_b = this.globalListener) == null ? void 0 : _b.call(this, notification);
+        return;
+      }
+      default:
+        (_c = this.globalListener) == null ? void 0 : _c.call(this, notification);
+        break;
+    }
+    if (kind.startsWith("tpe:") || kind.startsWith("barcode:")) {
+      this.dispatchPeripheralNotification(notification, kind);
+    }
+  }
+  changeShellState(newState) {
+    var _a;
+    (_a = this.host) == null ? void 0 : _a.postMessage({
+      kind: "shell.state-change",
+      data: {
+        desiredState: newState
+      }
+    });
+  }
+  sendAppStatusUpdate(currentApp, currentStatus, value = null) {
+    var _a;
+    (_a = this.host) == null ? void 0 : _a.postMessage({
+      kind: "app.status-update",
+      data: {
+        app: currentApp,
+        status: currentStatus,
+        value
+      }
+    });
+  }
+  resolveHost() {
+    var _a;
+    if (typeof window === "undefined") {
+      return null;
+    }
+    return ((_a = window.chrome) == null ? void 0 : _a.webview) ?? null;
+  }
+  normalizeNotification(data) {
+    if (data instanceof DeviceNotification) {
+      if (data.rawData === void 0 && data.jsonData !== void 0) {
+        data.rawData = data.jsonData;
+      }
+      return data;
+    }
+    const candidate = resolveNotificationRecord(data);
+    if (!candidate) {
+      return null;
+    }
+    const kind = normalizeNotificationKind(readStringValue(candidate, ["kind", "Kind", "eventKind", "notificationKind", "type", "Type"]));
+    if (!kind) {
+      return null;
+    }
+    const notification = new DeviceNotification();
+    const payload = resolveNotificationPayload(candidate);
+    notification.kind = kind;
+    notification.associatedDevice = readStringValue(candidate, [
+      "associatedDevice",
+      "AssociatedDevice",
+      "associatedDeviceGuid",
+      "AssociatedDeviceGuid",
+      "deviceGuid",
+      "DeviceGuid",
+      "deviceId",
+      "DeviceId",
+      "peripheralGuid",
+      "PeripheralGuid"
+    ]) ?? readAssociatedDeviceValue(payload) ?? void 0;
+    notification.rawData = payload;
+    notification.jsonData = encodeNotificationData(payload);
+    return notification;
+  }
+  createPeripherals(devices) {
+    const peripherals = [];
+    for (const device of devices) {
+      const peripheral = this.createPeripheral(device);
+      if (peripheral) {
+        peripherals.push(peripheral);
+      }
+    }
+    return peripherals;
+  }
+  createPeripheral(device) {
+    var _a;
+    const type = (_a = readStringValue(device, ["type", "kind", "deviceKind"])) == null ? void 0 : _a.toLowerCase();
+    let peripheral;
+    switch (type) {
+      case "tpe":
+        peripheral = new DeviceTpeShell(
+          (notification) => this.notify(notification),
+          (message) => {
+            var _a2;
+            return (_a2 = this.host) == null ? void 0 : _a2.postMessage(message);
+          }
+        );
+        break;
+      case "barcodescanner":
+      case "barcode":
+        peripheral = new DeviceBarCodeShell();
+        break;
+      default:
+        peripheral = new PeripheralBase();
+        break;
+    }
+    peripheral.guid = readStringValue(device, ["guid", "deviceGuid", "id"]) ?? "";
+    peripheral.name = readStringValue(device, ["name", "deviceName", "label"]) ?? "";
+    peripheral.type = readStringValue(device, ["type", "kind", "deviceKind"]) ?? "";
+    peripheral.state = readStringValue(device, ["state", "status"]) ?? null;
+    return peripheral;
+  }
+  readStatus(notification) {
+    var _a;
+    return ((_a = notification.getNormalizedPayload()) == null ? void 0 : _a.status) ?? null;
+  }
+  dispatchPeripheralNotification(notification, kind) {
+    var _a;
+    if (!notification.associatedDevice) {
+      return;
+    }
+    const device = this.findPeripheral(notification.associatedDevice);
+    if (!device) {
+      return;
+    }
+    const orderGuid = ((_a = notification.getNormalizedPayload()) == null ? void 0 : _a.orderGuid) ?? "";
+    if (device instanceof PeripheralTpe) {
+      switch (kind) {
+        case "tpe:payment-success":
+          device.dispatchSuccess("payment", orderGuid, notification);
+          break;
+        case "tpe:payment-failure":
+          device.dispatchFailure("payment", orderGuid, notification);
+          break;
+        case "tpe:refund-success":
+          device.dispatchSuccess("refund", orderGuid, notification);
+          break;
+        case "tpe:refund-failure":
+          device.dispatchFailure("refund", orderGuid, notification);
+          break;
+      }
+      device.dispatchNotification(notification);
+      return;
+    }
+    if (device instanceof PeripheralBarCode) {
+      switch (kind) {
+        case "barcode:scan":
+          device.dispatchSuccess("scan", orderGuid, notification);
+          break;
+        case "barcode:error":
+          device.dispatchFailure("scan", orderGuid, notification);
+          break;
+      }
+      device.dispatchNotification(notification);
+    }
+  }
+}
+function decodeNotificationData(value) {
+  const decoded = unwrapSerializedData(value);
+  return decoded == null ? null : decoded;
+}
+function unwrapSerializedData(value) {
+  let current = value;
+  for (let index = 0; index < 3; index += 1) {
+    if (current == null) {
+      return null;
+    }
+    if (typeof current !== "string") {
+      return current;
+    }
+    const trimmed = current.trim();
+    if (trimmed.length === 0) {
+      return null;
+    }
+    try {
+      current = JSON.parse(trimmed);
+      continue;
+    } catch {
+      return current;
+    }
+  }
+  return current;
+}
+function encodeNotificationData(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function resolveNotificationRecord(data) {
+  let current = asRecord(data);
+  for (let depth = 0; depth < 4 && current; depth += 1) {
+    if (readStringValue(current, ["kind", "Kind", "eventKind", "notificationKind", "type", "Type"])) {
+      return current;
+    }
+    const nested = firstRecord(current, ["message", "notification", "event", "payload", "data", "Data"]);
+    if (!nested) {
+      return null;
+    }
+    current = nested;
+  }
+  return null;
+}
+function resolveNotificationPayload(notification) {
+  for (const key of ["jsonData", "JsonData", "payload", "Payload", "json", "Json", "data", "Data"]) {
+    if (!(key in notification)) {
+      continue;
+    }
+    const value = notification[key];
+    if (typeof value === "string" || Array.isArray(value)) {
+      return value;
+    }
+    const nested = asRecord(value);
+    if (nested && !readStringValue(nested, ["kind", "Kind", "eventKind", "notificationKind", "type", "Type"])) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeNotificationKind(value) {
+  if (!value) {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase().replace(/\s+/g, "");
+  const unified = normalized.replace(/[.\/]+/g, ":").replace(/_/g, "-");
+  switch (unified) {
+    case "init":
+    case "devicemanager:init":
+    case "device-manager:init":
+      return "init";
+    case "status-update":
+    case "statusupdate":
+      return "status_update";
+    default:
+      if (unified.startsWith("tpe-")) {
+        return `tpe:${unified.slice("tpe-".length)}`;
+      }
+      if (unified.startsWith("barcode-")) {
+        return `barcode:${unified.slice("barcode-".length)}`;
+      }
+      return unified;
+  }
+}
+function firstRecord(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    const record = asRecord(value);
+    if (record) {
+      return record;
+    }
+  }
+  return null;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function readStringValue(source, keys) {
+  const record = source;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.length > 0) {
+        return trimmed;
+      }
+    }
+  }
+  return null;
+}
+function resolveDeviceDescriptors(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter((entry) => asRecord(entry) !== null);
+  }
+  const record = asRecord(payload);
+  if (!record) {
+    return [];
+  }
+  for (const key of ["devices", "Devices", "peripherals", "Peripherals", "data", "Data"]) {
+    const value = record[key];
+    if (Array.isArray(value)) {
+      return value.filter((entry) => asRecord(entry) !== null);
+    }
+    const nested = asRecord(value);
+    if (nested) {
+      const nestedDevices = resolveDeviceDescriptors(nested);
+      if (nestedDevices.length > 0) {
+        return nestedDevices;
+      }
+    }
+  }
+  return [];
+}
+function readAssociatedDeviceValue(payload) {
+  const record = asRecord(payload);
+  if (!record) {
+    return null;
+  }
+  const direct = readStringValue(record, [
+    "associatedDevice",
+    "AssociatedDevice",
+    "associatedDeviceGuid",
+    "AssociatedDeviceGuid",
+    "deviceGuid",
+    "DeviceGuid",
+    "deviceId",
+    "DeviceId",
+    "peripheralGuid",
+    "PeripheralGuid"
+  ]);
+  if (direct) {
+    return direct;
+  }
+  for (const key of ["data", "Data", "payload", "Payload"]) {
+    const nested = asRecord(record[key]);
+    if (!nested) {
+      continue;
+    }
+    const nestedDevice = readAssociatedDeviceValue(nested);
+    if (nestedDevice) {
+      return nestedDevice;
+    }
+  }
+  return null;
+}
+function normalizeDevicePayload(record, associatedDevice) {
+  return {
+    associatedDevice: associatedDevice ?? readAssociatedDeviceValue(record) ?? void 0,
+    status: readStringValueDeep(record, ["status", "Status", "state", "State"]) ?? void 0,
+    orderGuid: readStringValueDeep(record, ["orderGuid", "OrderGuid", "orderGUID", "orderId", "OrderId"]) ?? void 0,
+    orderNumber: readStringValueDeep(record, ["orderNumber", "OrderNumber", "reference", "Reference"]) ?? void 0,
+    mrgGuid: readStringValueDeep(record, ["mrgGuid", "MrgGuid", "mrgId", "MrgId"]) ?? void 0,
+    amount: readNumberValueDeep(record, ["amount", "Amount", "totalAmount", "TotalAmount"]) ?? void 0,
+    currency: readStringValueDeep(record, ["currency", "Currency", "currencyCode", "CurrencyCode"]) ?? void 0,
+    reasonCode: readStringValueDeep(record, ["reasonCode", "ReasonCode", "code", "Code"]) ?? void 0,
+    reasonMessage: readStringValueDeep(record, ["reasonMessage", "ReasonMessage", "message", "Message"]) ?? void 0,
+    transactionId: readStringValueDeep(record, ["transactionId", "TransactionId", "transactionNumber", "TransactionNumber"]) ?? void 0,
+    barcode: readStringValueDeep(record, ["barcode", "Barcode", "value", "Value", "scanValue", "ScanValue"]) ?? void 0,
+    symbology: readStringValueDeep(record, ["symbology", "Symbology", "barcodeType", "BarcodeType"]) ?? void 0,
+    raw: record
+  };
+}
+function readStringValueDeep(source, keys) {
+  const direct = readStringValue(source, keys);
+  if (direct) {
+    return direct;
+  }
+  for (const key of ["data", "Data", "payload", "Payload", "result", "Result"]) {
+    const nested = asRecord(source[key]);
+    if (!nested) {
+      continue;
+    }
+    const nestedValue = readStringValueDeep(nested, keys);
+    if (nestedValue) {
+      return nestedValue;
+    }
+  }
+  return null;
+}
+function readNumberValueDeep(source, keys) {
+  const direct = readNumberValue(source, keys);
+  if (direct !== null) {
+    return direct;
+  }
+  for (const key of ["data", "Data", "payload", "Payload", "result", "Result"]) {
+    const nested = asRecord(source[key]);
+    if (!nested) {
+      continue;
+    }
+    const nestedValue = readNumberValueDeep(nested, keys);
+    if (nestedValue !== null) {
+      return nestedValue;
+    }
+  }
+  return null;
+}
+function readNumberValue(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = Number(value.trim());
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return null;
+}
+class DeviceTpeMock extends PeripheralTpe {
+  constructor(emitNotification) {
+    super();
+    __publicField(this, "cancelled", false);
+    this.emitNotification = emitNotification;
+  }
+  makePayment(orderGuid, orderNumber, mrgGuid, amount, currency) {
+    this.cancelled = false;
+    this.schedule(200, () => this.createNotification("TPE:Progress", {
+      orderGuid,
+      orderNumber,
+      mrgGuid,
+      amount,
+      currency,
+      reasonCode: "START",
+      reasonMessage: "Veuillez suivre les instructions sur le terminal de paiement"
+    }));
+    this.schedule(2500, () => this.createNotification("TPE:Progress", {
+      orderGuid,
+      orderNumber,
+      mrgGuid,
+      amount,
+      currency,
+      reasonCode: "PINCODE",
+      reasonMessage: "Saisie du pin-code en attente"
+    }));
+    if (orderNumber.startsWith("F")) {
+      this.schedule(7500, () => this.createNotification("TPE:Payment-Failure", {
+        orderGuid,
+        orderNumber,
+        mrgGuid,
+        amount,
+        currency,
+        reasonCode: "FAKE",
+        reasonMessage: "Votre paiement n'a pas pu être traité"
+      }));
+      return;
+    }
+    this.schedule(7500, () => this.createNotification("TPE:Payment-Success", {
+      orderGuid,
+      orderNumber,
+      mrgGuid,
+      amount,
+      currency,
+      transactionId: "FakeTransactionNumber",
+      reasonCode: "FAKE",
+      reasonMessage: "Paiement terminé"
+    }));
+  }
+  makeRefund(orderGuid, orderNumber, mrgGuid, amount, currency) {
+    this.cancelled = false;
+    this.schedule(2500, () => this.createNotification("TPE:Refund-Failure", {
+      orderGuid,
+      orderNumber,
+      mrgGuid,
+      amount,
+      currency,
+      reasonCode: "FAKE",
+      reasonMessage: "Votre paiement n'a pas pu être remboursé : nous sommes en mode mock"
+    }));
+  }
+  cancelPendingPayment() {
+    this.cancelled = true;
+    this.schedule(2500, () => this.createNotification("TPE:Payment-Failure", {
+      reasonCode: "CANCEL",
+      reasonMessage: "Paiement annulé"
+    }));
+  }
+  schedule(delay2, factory) {
+    setTimeout(() => {
+      if (!this.cancelled) {
+        this.emitNotification(factory());
+      }
+    }, delay2);
+  }
+  createNotification(kind, payload) {
+    const notification = new DeviceNotification();
+    notification.kind = kind;
+    notification.associatedDevice = this.guid;
+    notification.jsonData = JSON.stringify(payload);
+    return notification;
+  }
+}
+class DeviceTpeShell extends PeripheralTpe {
+  constructor(emitNotification, postMessage) {
+    super();
+    this.emitNotification = emitNotification;
+    this.postMessage = postMessage;
+  }
+  setState(state) {
+    const notification = new DeviceNotification();
+    notification.kind = "STATUS_UPDATE";
+    notification.associatedDevice = this.guid;
+    notification.jsonData = JSON.stringify({ status: state });
+    this.emitNotification(notification);
+  }
+  makePayment(orderGuid, orderNumber, mrgGuid, amount, currency) {
+    this.postMessage({
+      deviceKind: "TPE",
+      deviceGuid: this.guid,
+      kind: "payment-request",
+      data: {
+        orderGuid,
+        orderNumber,
+        mrgGuid,
+        amount,
+        currency
+      }
+    });
+  }
+  makeRefund(orderGuid, orderNumber, mrgGuid, amount, currency) {
+    this.postMessage({
+      deviceKind: "TPE",
+      deviceGuid: this.guid,
+      kind: "refund-request",
+      data: {
+        orderGuid,
+        orderNumber,
+        mrgGuid,
+        amount,
+        currency
+      }
+    });
+  }
+  cancelPendingPayment() {
+    this.postMessage({
+      deviceKind: "TPE",
+      deviceGuid: this.guid,
+      kind: "payment-request-cancel",
+      data: {}
+    });
+  }
+}
+class DeviceBarCodeShell extends PeripheralBarCode {
+}
 class CommerceClient {
   constructor(options) {
     __publicField(this, "context");
@@ -637,6 +1479,7 @@ class CommerceClient {
     __publicField(this, "shipping");
     __publicField(this, "marketing");
     __publicField(this, "stores");
+    __publicField(this, "devices");
     __publicField(this, "http");
     __publicField(this, "workerBridge");
     __publicField(this, "cacheStrategy");
@@ -647,8 +1490,9 @@ class CommerceClient {
     this.workerBridge = new WorkerBridge();
     this.cacheStrategy = new CacheStrategy(this.workerBridge, this.http);
     this.sessionManager = SessionManagerFactory.create(this.http, this.context);
+    this.devices = new DeviceManager();
     this.session = new SessionModule(this.http, this.cacheStrategy);
-    this.cart = new CartModule(this.http, this.cacheStrategy, this.connectivity);
+    this.cart = new CartModule(this.http, this.cacheStrategy, this.connectivity, this.workerBridge);
     this.catalog = new CatalogModule(this.http, this.cacheStrategy);
     this.shipping = new ShippingModule(this.http, this.cacheStrategy);
     this.marketing = new MarketingModule(this.http, this.cacheStrategy);
@@ -679,6 +1523,7 @@ class CommerceClient {
   dispose() {
     this.connectivity.dispose();
     this.workerBridge.dispose();
+    this.devices.dispose();
   }
 }
 exports.AltazionApiError = AltazionApiError;
@@ -686,5 +1531,10 @@ exports.CacheError = CacheError;
 exports.CommerceClient = CommerceClient;
 exports.CommerceContext = CommerceContext;
 exports.ConnectivityManager = ConnectivityManager;
+exports.DeviceManager = DeviceManager;
+exports.DeviceNotification = DeviceNotification;
 exports.OfflineError = OfflineError;
+exports.PeripheralBarCode = PeripheralBarCode;
+exports.PeripheralBase = PeripheralBase;
+exports.PeripheralTpe = PeripheralTpe;
 //# sourceMappingURL=index.cjs.map