@pisell/pisellos 3.0.57 → 3.0.58

package/lib/solution/Checkout/index.js

@@ -1,864 +0,0 @@
-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")
-});