@pisell/pisellos 3.0.56 → 3.0.57

package/lib/solution/Checkout/index.js

@@ -0,0 +1,864 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/Checkout/index.ts
+var Checkout_exports = {};
+__export(Checkout_exports, {
+  CheckoutImpl: () => CheckoutImpl
+});
+module.exports = __toCommonJS(Checkout_exports);
+var import_BaseModule = require("../../modules/BaseModule");
+var import_Order = require("../../modules/Order");
+var import_Payment = require("../../modules/Payment");
+var import_types = require("./types");
+var import_types2 = require("../../modules/Payment/types");
+var import_utils = require("./utils");
+__reExport(Checkout_exports, require("./types"), module.exports);
+var CheckoutImpl = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name || "checkout", version || "1.0.0");
+    this.defaultName = "checkout";
+    this.defaultVersion = "1.0.0";
+    this.isSolution = true;
+    this.otherParams = {};
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.otherParams = options.otherParams || {};
+    this.request = core.getPlugin("request");
+    if (!this.request) {
+      throw new Error("Checkout 解决方案需要 request 插件支持");
+    }
+    this.store = {
+      order: new import_Order.OrderModule(),
+      payment: new import_Payment.PaymentModule(),
+      status: import_types.CheckoutStatus.Initializing,
+      step: import_types.CheckoutStep.OrderConfirmation,
+      cartItems: [],
+      paymentMethods: []
+    };
+    await this.initializeSubModules(core, options);
+    await this.preloadPaymentMethods();
+    await this.setStatus(import_types.CheckoutStatus.Ready);
+    console.log("[Checkout] 初始化完成");
+    await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutInitialized, {
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 初始化子模块
+   */
+  async initializeSubModules(core, options) {
+    var _a, _b;
+    core.registerModule(this.store.order, {
+      store: ((_a = options.store) == null ? void 0 : _a.order) || {},
+      otherParams: { ...this.otherParams, parentModule: this.name }
+    });
+    core.registerModule(this.store.payment, {
+      store: ((_b = options.store) == null ? void 0 : _b.payment) || {},
+      otherParams: { ...this.otherParams, parentModule: this.name }
+    });
+    this.setupPaymentEventListeners();
+  }
+  /**
+   * 设置支付模块事件监听
+   */
+  setupPaymentEventListeners() {
+    this.core.effects.on("payment:onPaymentSyncSuccess", async (data) => {
+      var _a;
+      if (((_a = this.store.currentOrder) == null ? void 0 : _a.uuid) === data.orderUuid) {
+        await this.handlePaymentSuccess(data);
+      }
+    });
+    this.core.effects.on("payment:onPaymentSyncError", async (data) => {
+      var _a;
+      if (((_a = this.store.currentOrder) == null ? void 0 : _a.uuid) === data.orderUuid) {
+        await this.handlePaymentError(data);
+      }
+    });
+  }
+  /**
+   * 初始化结账流程
+   */
+  async initializeCheckoutAsync(params) {
+    try {
+      await this.setStatus(import_types.CheckoutStatus.Initializing);
+      const validation = await this.validateCheckoutParams(params);
+      if (!validation.valid) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `参数验证失败: ${validation.errors.join(", ")}`
+        );
+      }
+      this.store.cartItems = params.cartItems;
+      await this.setStatus(import_types.CheckoutStatus.Ready);
+      await this.setStep(import_types.CheckoutStep.OrderConfirmation);
+      console.log("[Checkout] 结账流程初始化完成");
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      throw error;
+    }
+  }
+  /**
+   * 创建本地订单 (前端模拟下单流程)
+   * 
+   * 此方法用于在前端模拟整个下单流程，创建一个本地的虚拟订单。
+   * 用户在购物车点击下单时，会把购物车参数传递给此方法，
+   * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
+   */
+  async createLocalOrderAsync(params) {
+    try {
+      await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const validation = await this.validateLocalOrderData(params.orderData);
+      if (!validation.valid) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `订单数据验证失败: ${validation.errors.join(", ")}`
+        );
+      }
+      const localOrderId = this.generateLocalOrderId();
+      const amountInfo = this.extractAmountFromCartSummary(params.cartSummary);
+      this.store.localOrderData = params.orderData;
+      const paymentOrder = await this.store.payment.createPaymentOrderAsync({
+        order_id: localOrderId,
+        total_amount: amountInfo.totalAmount,
+        is_deposit: params.orderData.is_deposit || 0,
+        deposit_amount: amountInfo.depositAmount || "0.00",
+        order_info: {
+          original_order_data: params.orderData,
+          cart_summary: params.cartSummary,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          platform: params.orderData.platform.toLowerCase(),
+          type: params.orderData.type,
+          schedule_date: params.orderData.schedule_date,
+          shop_note: params.orderData.shop_note,
+          amount_breakdown: amountInfo
+        }
+      });
+      this.store.currentOrder = paymentOrder;
+      await this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      await this.setStep(import_types.CheckoutStep.PaymentMethod);
+      if (params.autoPayment) {
+        await this.setStep(import_types.CheckoutStep.PaymentProcessing);
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: paymentOrder,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 本地订单创建成功:", {
+        localOrderId,
+        uuid: paymentOrder.uuid,
+        totalAmount: amountInfo.totalAmount,
+        subTotal: amountInfo.subTotal,
+        taxAmount: amountInfo.taxAmount
+      });
+      return paymentOrder;
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
+        error: this.store.lastError,
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  /**
+   * 手动下单 (根据虚拟订单生成实际订单)
+   * 
+   * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
+   */
+  async placeOrderAsync(params = {}) {
+    var _a, _b;
+    try {
+      if (!this.store.localOrderData) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有找到本地订单数据，请先调用 createLocalOrderAsync 创建虚拟订单"
+        );
+      }
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有找到当前订单，请先创建虚拟订单"
+        );
+      }
+      console.log("[Checkout] 开始手动下单流程...");
+      await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const orderData = {
+        cartItems: this.store.cartItems,
+        type: this.store.localOrderData.type,
+        platform: (_a = this.store.localOrderData.platform) == null ? void 0 : _a.toLowerCase()
+      };
+      const orderResponse = await this.store.order.submitOrder({
+        url: params.url,
+        // 可选的自定义 URL
+        query: orderData
+      });
+      const realOrderId = ((_b = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _b.order_id) || (orderResponse == null ? void 0 : orderResponse.order_id);
+      if (!realOrderId) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.OrderCreationFailed,
+          "订单创建成功但未返回订单ID"
+        );
+      }
+      console.log("[Checkout] 真实订单创建成功:", realOrderId);
+      if (params.autoReplaceOrderId !== false) {
+        console.log("[Checkout] 自动替换虚拟订单ID为真实订单ID...");
+        const updatedOrder = await this.replaceLocalOrderIdAsync(realOrderId);
+        if (updatedOrder) {
+          console.log("[Checkout] 订单ID替换成功:", {
+            oldId: this.store.currentOrder.order_id,
+            newId: realOrderId
+          });
+        }
+      }
+      await this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: this.store.currentOrder,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 手动下单流程完成");
+      return {
+        success: true,
+        orderId: realOrderId
+      };
+    } catch (error) {
+      let errorMessage = "下单失败";
+      if (error && typeof error === "object" && "message" in error) {
+        errorMessage = error.message;
+      } else if (error instanceof Error) {
+        errorMessage = error.message;
+      }
+      console.error("[Checkout] 手动下单失败:", errorMessage);
+      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 创建订单
+   */
+  async createOrderAsync(params) {
+    var _a;
+    try {
+      await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const checkResult = this.store.order.checkBeforeSubmitOrder({
+        cartItems: params.cartItems,
+        type: "account"
+        // 默认使用 account 类型
+      });
+      if (!checkResult) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "购物车数据验证失败，请检查商品信息"
+        );
+      }
+      const orderResponse = await this.store.order.submitOrder({
+        query: {
+          cartItems: params.cartItems,
+          type: params.type || "appointment_booking",
+          platform: params.platform || "pc"
+        }
+      });
+      const paymentOrder = await this.store.payment.createPaymentOrderAsync({
+        order_id: ((_a = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _a.order_id) || `order_${Date.now()}`,
+        total_amount: this.calculateTotalAmount(params.cartItems),
+        order_info: orderResponse == null ? void 0 : orderResponse.data
+      });
+      this.store.currentOrder = paymentOrder;
+      await this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      await this.setStep(import_types.CheckoutStep.PaymentMethod);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: paymentOrder,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 订单创建成功:", paymentOrder.id);
+      return paymentOrder;
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
+        error: this.store.lastError,
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  /**
+   * 处理支付
+   */
+  async processPaymentAsync(params) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，请先创建订单"
+        );
+      }
+      await this.setStatus(import_types.CheckoutStatus.ProcessingPayment);
+      await this.setStep(import_types.CheckoutStep.PaymentProcessing);
+      const paymentMethod = this.store.paymentMethods.find(
+        (method) => method.code === params.paymentMethodCode
+      );
+      if (!paymentMethod) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `未找到支付方式: ${params.paymentMethodCode}`
+        );
+      }
+      const paymentItem = {
+        code: paymentMethod.code,
+        name: paymentMethod.name,
+        type: paymentMethod.type,
+        amount: String(params.amount),
+        id: paymentMethod.id
+      };
+      await this.store.payment.pushPaymentAsync(
+        this.store.currentOrder.uuid,
+        paymentItem
+      );
+      const result = await this.store.payment.submitPayAsync(
+        this.store.currentOrder.uuid
+      );
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: params.paymentMethodCode,
+        amount: String(params.amount),
+        timestamp: Date.now()
+      });
+      if (result.status === "success") {
+        await this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
+        await this.handlePaymentSuccess({
+          orderUuid: this.store.currentOrder.uuid,
+          timestamp: Date.now()
+        });
+      } else {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.PaymentFailed,
+          "支付处理失败，请重试"
+        );
+      }
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 完成结账
+   */
+  async completeCheckoutAsync() {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单"
+        );
+      }
+      const order = await this.store.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
+      if (!order || order.payment_status !== import_types2.PaymentStatus.Finished) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "订单支付未完成，无法完成结账"
+        );
+      }
+      await this.setStatus(import_types.CheckoutStatus.Completed);
+      await this.setStep(import_types.CheckoutStep.Complete);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCompleted, {
+        orderId: order.id,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 结账流程完成:", order.id);
+      return {
+        success: true,
+        orderId: String(order.id)
+      };
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      return { success: false };
+    }
+  }
+  /**
+   * 取消结账
+   */
+  async cancelCheckoutAsync() {
+    try {
+      if (this.store.currentOrder) {
+        await this.store.payment.deleteOrderAsync(this.store.currentOrder.uuid);
+        this.store.currentOrder = void 0;
+      }
+      await this.setStatus(import_types.CheckoutStatus.Cancelled);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCancelled, {
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 结账流程已取消");
+    } catch (error) {
+      console.error("[Checkout] 取消结账失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+    }
+  }
+  /**
+   * 获取结账状态
+   */
+  getCheckoutStatus() {
+    return {
+      status: this.store.status,
+      step: this.store.step,
+      progress: (0, import_utils.calculateProgress)(this.store.status, this.store.step),
+      message: this.getStatusMessage(),
+      error: this.store.lastError
+    };
+  }
+  /**
+   * 获取结账摘要
+   */
+  async getCheckoutSummaryAsync() {
+    var _a, _b, _c;
+    const totalAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0.00";
+    const paidAmount = this.calculatePaidAmount();
+    const remainingAmount = ((_b = this.store.currentOrder) == null ? void 0 : _b.expect_amount) || totalAmount;
+    return {
+      order: this.store.currentOrder,
+      totalAmount,
+      paidAmount,
+      remainingAmount,
+      paymentStatus: ((_c = this.store.currentOrder) == null ? void 0 : _c.payment_status) || import_types2.PaymentStatus.Processing,
+      availablePaymentMethods: this.store.paymentMethods
+    };
+  }
+  /**
+   * 获取可用支付方式
+   */
+  async getAvailablePaymentMethodsAsync() {
+    if (this.store.paymentMethods.length === 0) {
+      console.log("[Checkout] 支付方式缓存为空，重新加载...");
+      await this.preloadPaymentMethods();
+    }
+    return this.store.paymentMethods;
+  }
+  /**
+   * 刷新支付方式缓存
+   * 
+   * 强制重新从服务器获取支付方式列表，更新本地缓存
+   */
+  async refreshPaymentMethodsAsync() {
+    console.log("[Checkout] 强制刷新支付方式缓存...");
+    await this.preloadPaymentMethods();
+    return this.store.paymentMethods;
+  }
+  /**
+   * 获取当前订单基础信息
+   * 
+   * 返回当前订单的基础信息，包括订单状态、金额、支付状态等
+   */
+  getCurrentOrderInfo() {
+    var _a;
+    try {
+      const { currentOrder, status, step, cartItems, localOrderData } = this.store;
+      if (!currentOrder) {
+        console.log("[Checkout] 当前没有活跃订单");
+        return null;
+      }
+      const orderInfo = currentOrder.order_info || {};
+      const createdAt = orderInfo.created_at || (/* @__PURE__ */ new Date()).toISOString();
+      const orderType = (localOrderData == null ? void 0 : localOrderData.type) || orderInfo.type || "virtual";
+      const platform = ((_a = localOrderData == null ? void 0 : localOrderData.platform) == null ? void 0 : _a.toLowerCase()) || orderInfo.platform || "pc";
+      const result = {
+        uuid: currentOrder.uuid,
+        orderId: currentOrder.order_id,
+        status,
+        step,
+        totalAmount: currentOrder.total_amount,
+        remainingAmount: currentOrder.expect_amount,
+        paymentStatus: currentOrder.payment_status,
+        isDeposit: Boolean(currentOrder.is_deposit),
+        depositAmount: currentOrder.deposit_amount,
+        orderType,
+        platform,
+        createdAt,
+        itemCount: cartItems.length,
+        hasLocalOrderData: Boolean(localOrderData)
+      };
+      console.log("[Checkout] 获取当前订单基础信息:", {
+        uuid: result.uuid,
+        orderId: result.orderId,
+        status: result.status,
+        totalAmount: result.totalAmount,
+        remainingAmount: result.remainingAmount
+      });
+      return result;
+    } catch (error) {
+      console.error("[Checkout] 获取当前订单基础信息失败:", error);
+      return null;
+    }
+  }
+  /**
+   * 验证结账前置条件
+   */
+  async validateCheckoutAsync() {
+    const errors = [];
+    if (!this.store.cartItems || this.store.cartItems.length === 0) {
+      errors.push("购物车为空");
+    }
+    if (this.store.paymentMethods.length === 0) {
+      errors.push("无可用支付方式");
+    }
+    if (this.store.status === import_types.CheckoutStatus.Error) {
+      errors.push("结账流程存在错误");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * 重试失败的操作
+   */
+  async retryFailedOperationAsync() {
+    try {
+      if (this.store.status === import_types.CheckoutStatus.Error && this.store.lastError) {
+        switch (this.store.lastError.type) {
+          case import_types.CheckoutErrorType.OrderCreationFailed:
+            if (this.store.cartItems.length > 0) {
+              await this.createOrderAsync({
+                cartItems: this.store.cartItems
+              });
+            }
+            break;
+          case import_types.CheckoutErrorType.PaymentFailed:
+            if (this.store.currentOrder) {
+              await this.store.payment.runPaymentSyncQueue();
+            }
+            break;
+          default:
+            console.warn("[Checkout] 无法重试此类型的错误:", this.store.lastError.type);
+        }
+      }
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+    }
+  }
+  /**
+   * 设置当前步骤
+   */
+  setCurrentStep(step) {
+    const oldStep = this.store.step;
+    this.store.step = step;
+    this.core.effects.emit(import_types.CheckoutHooks.OnStepChanged, {
+      oldStep,
+      newStep: step,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 获取订单模块
+   */
+  getOrderModule() {
+    return this.store.order;
+  }
+  /**
+   * 获取支付模块
+   */
+  getPaymentModule() {
+    return this.store.payment;
+  }
+  /**
+   * 替换本地订单ID为真实订单ID
+   * 
+   * 当后端订单创建完成后，调用此方法将本地虚拟订单ID替换为真实订单ID
+   * 
+   * @param newOrderId 后端返回的真实订单ID
+   * @returns 更新后的订单对象，如果当前没有订单则返回null
+   */
+  async replaceLocalOrderIdAsync(newOrderId) {
+    try {
+      if (!this.store.currentOrder) {
+        console.warn("[Checkout] 没有当前订单，无法替换订单ID");
+        return null;
+      }
+      const updatedOrder = await this.store.payment.replaceOrderIdByUuidAsync(
+        this.store.currentOrder.uuid,
+        newOrderId
+      );
+      if (updatedOrder) {
+        this.store.currentOrder = updatedOrder;
+        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+          order: updatedOrder,
+          timestamp: Date.now()
+        });
+        console.log("[Checkout] 本地订单ID替换成功:", {
+          uuid: updatedOrder.uuid,
+          newOrderId: updatedOrder.id
+        });
+      }
+      return updatedOrder;
+    } catch (error) {
+      console.error("[Checkout] 替换订单ID失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      return null;
+    }
+  }
+  /**
+   * 设置状态
+   */
+  async setStatus(status) {
+    const oldStatus = this.store.status;
+    this.store.status = status;
+    await this.core.effects.emit(import_types.CheckoutHooks.OnStatusChanged, {
+      oldStatus,
+      newStatus: status,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 设置步骤
+   */
+  async setStep(step) {
+    const oldStep = this.store.step;
+    this.store.step = step;
+    await this.core.effects.emit(import_types.CheckoutHooks.OnStepChanged, {
+      oldStep,
+      newStep: step,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 处理错误
+   */
+  async handleError(error, type) {
+    const checkoutError = error instanceof Error && "type" in error ? error : (0, import_utils.createCheckoutError)(type, error.message, error);
+    this.store.lastError = checkoutError;
+    await this.setStatus(import_types.CheckoutStatus.Error);
+    await this.core.effects.emit(import_types.CheckoutHooks.OnError, {
+      error: checkoutError,
+      context: { status: this.store.status, step: this.store.step },
+      timestamp: Date.now()
+    });
+    console.error("[Checkout] 错误:", checkoutError);
+  }
+  /**
+   * 处理支付成功
+   */
+  async handlePaymentSuccess(data) {
+    var _a;
+    await this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
+    await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentSuccess, {
+      orderUuid: data.orderUuid,
+      paymentMethodCode: "",
+      amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
+      timestamp: data.timestamp
+    });
+    await this.completeCheckoutAsync();
+  }
+  /**
+   * 处理支付错误
+   */
+  async handlePaymentError(data) {
+    var _a;
+    const error = (0, import_utils.createCheckoutError)(
+      import_types.CheckoutErrorType.PaymentFailed,
+      data.error || "支付同步失败"
+    );
+    await this.handleError(error instanceof Error ? error : new Error(String(error)), import_types.CheckoutErrorType.PaymentFailed);
+    await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentFailed, {
+      orderUuid: data.orderUuid,
+      paymentMethodCode: "",
+      amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
+      timestamp: data.timestamp
+    });
+  }
+  /**
+   * 验证结账参数
+   */
+  async validateCheckoutParams(params) {
+    return (0, import_utils.validateCheckoutData)(params);
+  }
+  /**
+   * 验证本地订单数据
+   */
+  async validateLocalOrderData(orderData) {
+    const errors = [];
+    if (!orderData.type) {
+      errors.push("订单类型不能为空");
+    }
+    if (!orderData.platform) {
+      errors.push("平台信息不能为空");
+    }
+    if (!orderData.bookings || orderData.bookings.length === 0) {
+      errors.push("预订信息不能为空");
+    }
+    if (orderData.bookings) {
+      orderData.bookings.forEach((booking, index) => {
+        if (!booking.product || !booking.product.product_id) {
+          errors.push(`预订项 ${index + 1} 缺少商品信息`);
+        }
+        if (!booking.start_date) {
+          errors.push(`预订项 ${index + 1} 缺少开始日期`);
+        }
+        if (!booking.start_time) {
+          errors.push(`预订项 ${index + 1} 缺少开始时间`);
+        }
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * 生成本地订单ID
+   */
+  generateLocalOrderId() {
+    const timestamp = Date.now();
+    const random = Math.floor(Math.random() * 1e4).toString().padStart(4, "0");
+    return `local_order_${timestamp}_${random}`;
+  }
+  /**
+   * 从购物车小计数据中提取金额信息
+   */
+  extractAmountFromCartSummary(cartSummary) {
+    const result = {
+      totalAmount: "0.00",
+      subTotal: "0.00",
+      taxAmount: "0.00",
+      discountAmount: "0.00",
+      shopDiscountAmount: "0.00",
+      roundingAmount: "0.00"
+    };
+    cartSummary.forEach((item) => {
+      const value = Number(item.value).toFixed(2);
+      switch (item.key) {
+        case "expect_amount":
+          result.totalAmount = value;
+          break;
+        case "sub_total":
+          result.subTotal = value;
+          break;
+        case "tax":
+          result.taxAmount = value;
+          if (item.tax) {
+            result.taxDetails = item.tax;
+          }
+          break;
+        case "discount":
+          result.discountAmount = value;
+          break;
+        case "shop_discount":
+          result.shopDiscountAmount = value;
+          break;
+        case "custom_roundingAmount":
+          result.roundingAmount = value;
+          break;
+        default:
+          if (item.key.includes("deposit")) {
+            result.depositAmount = value;
+          }
+          break;
+      }
+    });
+    console.log("[Checkout] 从购物车小计提取金额信息:", {
+      totalAmount: result.totalAmount,
+      subTotal: result.subTotal,
+      taxAmount: result.taxAmount,
+      discountAmount: result.discountAmount,
+      shopDiscountAmount: result.shopDiscountAmount,
+      roundingAmount: result.roundingAmount
+    });
+    return result;
+  }
+  /**
+   * 预加载支付方式（在初始化时调用）
+   */
+  async preloadPaymentMethods() {
+    try {
+      console.log("[Checkout] 预加载支付方式...");
+      const methods = await this.store.payment.getPayMethodListAsync();
+      this.store.paymentMethods = methods;
+      console.log(`[Checkout] 预加载完成，共 ${methods.length} 种支付方式`);
+    } catch (error) {
+      console.error("[Checkout] 预加载支付方式失败:", error);
+      this.store.paymentMethods = [];
+    }
+  }
+  /**
+   * 计算总金额
+   */
+  calculateTotalAmount(cartItems) {
+    const total = cartItems.reduce((sum, item) => {
+      const price = parseFloat(String(item.price) || "0");
+      const quantity = item.quantity || 1;
+      return sum + price * quantity;
+    }, 0);
+    return total.toFixed(2);
+  }
+  /**
+   * 计算已支付金额
+   */
+  calculatePaidAmount() {
+    if (!this.store.currentOrder)
+      return "0.00";
+    const paidAmount = this.store.currentOrder.payment.reduce((sum, payment) => {
+      return sum + parseFloat(payment.amount);
+    }, 0);
+    return paidAmount.toFixed(2);
+  }
+  /**
+   * 获取状态消息
+   */
+  getStatusMessage() {
+    var _a;
+    switch (this.store.status) {
+      case import_types.CheckoutStatus.Initializing:
+        return "正在初始化结账流程...";
+      case import_types.CheckoutStatus.Ready:
+        return "准备就绪，可以开始结账";
+      case import_types.CheckoutStatus.CreatingOrder:
+        return "正在创建订单...";
+      case import_types.CheckoutStatus.OrderCreated:
+        return "订单创建成功，请选择支付方式";
+      case import_types.CheckoutStatus.ProcessingPayment:
+        return "正在处理支付...";
+      case import_types.CheckoutStatus.PaymentCompleted:
+        return "支付完成";
+      case import_types.CheckoutStatus.Completed:
+        return "结账完成";
+      case import_types.CheckoutStatus.Cancelled:
+        return "结账已取消";
+      case import_types.CheckoutStatus.Error:
+        return ((_a = this.store.lastError) == null ? void 0 : _a.message) || "发生未知错误";
+      default:
+        return "";
+    }
+  }
+  async destroy() {
+    var _a, _b, _c, _d;
+    this.core.effects.offByModuleDestroy(this.name);
+    await ((_b = (_a = this.store.order) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a));
+    await ((_d = (_c = this.store.payment) == null ? void 0 : _c.destroy) == null ? void 0 : _d.call(_c));
+    this.core.unregisterModule(this);
+    console.log("[Checkout] 已销毁");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckoutImpl,
+  ...require("./types")
+});