@pisell/pisellos 0.0.233 → 0.0.235

package/lib/solution/Checkout/index.js

@@ -508,8 +508,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async getCheckoutSummaryAsync() {
     var _a, _b;
     const totalAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0.00";
-    const paidAmount = this.calculatePaidAmount();
-    const remainingAmount = this.calculateRemainingAmount();
+    const paidAmount = await this.calculatePaidAmountAsync();
+    const remainingAmount = await this.calculateRemainingAmountAsync();
     return {
       order: this.store.currentOrder,
       totalAmount,
@@ -866,45 +866,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         当前订单ID: currentOrderId,
         是否为真实ID: isCurrentOrderReal
       });
-      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-      if (updatedOrder) {
-        if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
-          console.warn("[Checkout] 检测到订单ID回退，保护真实订单ID:", {
-            当前真实ID: currentOrderId,
-            获取到的虚拟ID: updatedOrder.order_id
-          });
-          updatedOrder.order_id = currentOrderId;
-        }
-        this.store.currentOrder = updatedOrder;
-        console.log("[Checkout] 订单数据已同步:", {
-          支付项数量: updatedOrder.payment.length,
-          最终订单ID: updatedOrder.order_id,
-          是否为虚拟ID: this.isVirtualOrderId(updatedOrder.order_id)
-        });
-      }
-      const needsOrderSync = this.shouldSyncOrderForPayment(paymentItem.code, paymentItem.type);
-      console.log("[Checkout] 支付项同步检查:", {
-        paymentCode: paymentItem.code,
-        paymentType: paymentItem.type,
-        paymentAmount: paymentItem.amount,
-        expectedCashCode: import_types2.PaymentMethodType.Cash,
-        needsOrderSync,
-        isOrderSynced: this.store.isOrderSynced
-      });
-      if (needsOrderSync) {
-        console.log("[Checkout] 检测到非现金/自定义支付，开始同步订单到后端...", {
-          同步前订单ID: this.store.currentOrder.order_id,
-          是否为虚拟ID: this.isVirtualOrderId(this.store.currentOrder.order_id),
-          订单同步状态: this.store.isOrderSynced,
-          订单UUID: this.store.currentOrder.uuid
-        });
-        await this.syncOrderToBackend();
-        console.log("[Checkout] addPaymentItemAsync 中的同步完成:", {
-          同步后订单ID: this.store.currentOrder.order_id,
-          是否为虚拟ID: this.isVirtualOrderId(this.store.currentOrder.order_id),
-          订单同步状态: this.store.isOrderSynced
-        });
-      }
       await this.updateStateAmountToRemaining();
       await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
         orderUuid: this.store.currentOrder.uuid,
@@ -939,7 +900,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderUuid: this.store.currentOrder.uuid,
         paymentUuid
       });
-      const paymentItem = this.store.currentOrder.payment.find((p) => p.uuid === paymentUuid);
+      const currentPayments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        true
+        // 包括已撤销的支付项，因为我们需要验证是否存在
+      );
+      const paymentItem = currentPayments.find((p) => p.uuid === paymentUuid);
       if (!paymentItem) {
         throw (0, import_utils.createCheckoutError)(
           import_types.CheckoutErrorType.ValidationFailed,
@@ -1170,35 +1136,46 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     return this.store.currentCustomer || null;
   }
   /**
-   * 检查订单是否需要手动同步
+   * 检查订单是否需要手动同步（异步版本）
    * 
    * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
+   * 从 Payment 模块获取最新的支付项数据
    */
-  needsManualSync() {
-    var _a;
+  async needsManualSyncAsync() {
     try {
       if (!this.store.currentOrder || this.store.isOrderSynced) {
         return false;
       }
-      const remainingAmount = this.calculateRemainingAmount();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
       const remainingValue = parseFloat(remainingAmount);
       if (remainingValue > 0) {
         return false;
       }
-      const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.every(
+      const currentPayments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        false
+        // 不包括已撤销的支付项
+      );
+      const allPaymentsHaveVoucherId = currentPayments.length > 0 && currentPayments.every(
         (item) => item.status !== "voided" && item.voucher_id
       );
-      console.log("[Checkout] needsManualSync 检查结果:", {
+      console.log("[Checkout] needsManualSyncAsync 检查结果:", {
         orderUuid: this.store.currentOrder.uuid,
         isOrderSynced: this.store.isOrderSynced,
         remainingAmount,
-        hasPayments: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) > 0,
+        hasPayments: currentPayments.length > 0,
         allPaymentsHaveVoucherId,
-        needsManualSync: allPaymentsHaveVoucherId
+        needsManualSync: allPaymentsHaveVoucherId,
+        paymentItems: currentPayments.map((p) => ({
+          code: p.code,
+          amount: p.amount,
+          status: p.status,
+          hasVoucherId: !!p.voucher_id
+        }))
       });
       return allPaymentsHaveVoucherId;
     } catch (error) {
-      console.error("[Checkout] needsManualSync 检查失败:", error);
+      console.error("[Checkout] needsManualSyncAsync 检查失败:", error);
       return false;
     }
   }
@@ -1225,7 +1202,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderUuid,
         orderId: oldOrderId,
         totalAmount: this.store.currentOrder.total_amount,
-        remainingAmount: this.calculateRemainingAmount()
+        remainingAmount: await this.calculateRemainingAmountAsync()
       });
       const realOrderId = await this.syncOrderToBackendWithReturn(true);
       console.log("[Checkout] 手动同步订单完成:", {
@@ -1289,6 +1266,106 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     }
     return this.store.currentOrder.order_id;
   }
+  /**
+   * 获取当前订单是否已同步到后端
+   * 
+   * @returns 当前订单是否已同步状态，如果没有订单则返回false
+   */
+  isCurrentOrderSynced() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] 没有当前订单，同步状态为false");
+      return false;
+    }
+    const syncStatus = this.store.isOrderSynced;
+    console.log("[Checkout] 当前订单同步状态:", {
+      orderUuid: this.store.currentOrder.uuid,
+      orderId: this.store.currentOrder.order_id,
+      isOrderSynced: syncStatus
+    });
+    return syncStatus;
+  }
+  /**
+   * 取消当前本地订单
+   * 
+   * 只能取消未同步到后端的本地订单，如果订单已同步则不能取消
+   * 
+   * @param cancelReason 取消原因（可选）
+   * @returns 取消结果
+   */
+  async cancelCurrentOrderAsync(cancelReason) {
+    var _a, _b;
+    try {
+      console.log("[Checkout] 开始取消当前本地订单:", {
+        hasCurrentOrder: !!this.store.currentOrder,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        orderId: (_b = this.store.currentOrder) == null ? void 0 : _b.order_id,
+        isOrderSynced: this.store.isOrderSynced,
+        cancelReason
+      });
+      if (!this.store.currentOrder) {
+        console.log("[Checkout] 没有当前订单，无需取消");
+        return {
+          success: false,
+          message: "没有当前订单可取消"
+        };
+      }
+      const currentOrderUuid = this.store.currentOrder.uuid;
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isOrderSynced = this.store.isOrderSynced;
+      if (isOrderSynced) {
+        console.log("[Checkout] 订单已同步到后端，不能取消:", {
+          orderId: currentOrderId,
+          orderUuid: currentOrderUuid
+        });
+        return {
+          success: false,
+          message: "订单已同步到后端，无法取消",
+          orderId: currentOrderId
+        };
+      }
+      console.log("[Checkout] 订单尚未同步，可以取消");
+      try {
+        console.log("[Checkout] 删除本地订单数据");
+        await this.payment.deletePaymentOrderAsync(currentOrderUuid);
+        console.log("[Checkout] 本地订单数据删除成功");
+      } catch (error) {
+        console.warn("[Checkout] 删除本地订单数据失败，但继续执行:", error);
+      }
+      console.log("[Checkout] 清理订单相关状态");
+      this.store.currentOrder = void 0;
+      this.store.localOrderData = void 0;
+      this.store.stateAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      this.payment.wallet.clearAllCache();
+      console.log("[Checkout] 订单状态清理完成，currentOrder已释放");
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCancelled, {
+        orderUuid: currentOrderUuid,
+        orderId: currentOrderId,
+        cancelReason,
+        wasSynced: false,
+        // 只有未同步订单可以被取消
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 本地订单取消完成:", {
+        orderUuid: currentOrderUuid,
+        orderId: currentOrderId,
+        cancelReason
+      });
+      return {
+        success: true,
+        message: "本地订单已成功取消",
+        orderId: currentOrderId
+      };
+    } catch (error) {
+      console.error("[Checkout] 取消本地订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "未知错误";
+      return {
+        success: false,
+        message: `取消订单失败: ${errorMessage}`
+      };
+    }
+  }
   /**
    * 保存订单并稍后支付
    * 
@@ -1700,45 +1777,54 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     return total.toFixed(2);
   }
   /**
-   * 计算已支付金额
+   * 计算已支付金额（从 Payment 模块获取最新数据）
    */
-  calculatePaidAmount() {
+  async calculatePaidAmountAsync() {
     if (!this.store.currentOrder) {
-      console.log("[Checkout] calculatePaidAmount: 没有当前订单");
+      console.log("[Checkout] calculatePaidAmountAsync: 没有当前订单");
+      return "0.00";
+    }
+    try {
+      const payments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        false
+        // 不包括已撤销的支付项
+      );
+      console.log("[Checkout] calculatePaidAmountAsync: 支付项详情:", {
+        paymentCount: payments.length,
+        payments: payments.map((p) => ({
+          uuid: p.uuid,
+          amount: p.amount,
+          code: p.code,
+          status: p.status
+        }))
+      });
+      const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
+        const amount = parseFloat(payment.amount || "0");
+        console.log(`[Checkout] 计算支付项: ${payment.code} = ${amount}`);
+        return sum + amount;
+      }, 0);
+      const result = paidAmount.toFixed(2);
+      console.log("[Checkout] calculatePaidAmountAsync: 计算结果 =", result);
+      return result;
+    } catch (error) {
+      console.error("[Checkout] calculatePaidAmountAsync 失败:", error);
       return "0.00";
     }
-    const payments = this.store.currentOrder.payment || [];
-    console.log("[Checkout] calculatePaidAmount: 支付项详情:", {
-      paymentCount: payments.length,
-      payments: payments.map((p) => ({
-        uuid: p.uuid,
-        amount: p.amount,
-        code: p.code,
-        status: p.status
-      }))
-    });
-    const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
-      const amount = parseFloat(payment.amount || "0");
-      console.log(`[Checkout] 计算支付项: ${payment.code} = ${amount}`);
-      return sum + amount;
-    }, 0);
-    const result = paidAmount.toFixed(2);
-    console.log("[Checkout] calculatePaidAmount: 计算结果 =", result);
-    return result;
   }
   /**
-   * 计算剩余未支付金额
+   * 计算剩余未支付金额（从 Payment 模块获取最新数据）
    */
-  calculateRemainingAmount() {
+  async calculateRemainingAmountAsync() {
     if (!this.store.currentOrder) {
-      console.log("[Checkout] calculateRemainingAmount: 没有当前订单");
+      console.log("[Checkout] calculateRemainingAmountAsync: 没有当前订单");
       return "0.00";
     }
     const totalAmount = parseFloat(this.store.currentOrder.total_amount || "0");
-    const paidAmount = parseFloat(this.calculatePaidAmount());
+    const paidAmount = parseFloat(await this.calculatePaidAmountAsync());
     const remainingAmount = totalAmount - paidAmount;
     const result = Math.max(0, remainingAmount).toFixed(2);
-    console.log("[Checkout] calculateRemainingAmount: 计算详情:", {
+    console.log("[Checkout] calculateRemainingAmountAsync: 计算详情:", {
       orderUuid: this.store.currentOrder.uuid,
       totalAmount: totalAmount.toFixed(2),
       paidAmount: paidAmount.toFixed(2),
@@ -1753,7 +1839,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async updateStateAmountToRemaining() {
     var _a;
     try {
-      const remainingAmount = this.calculateRemainingAmount();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
       const currentStateAmount = this.store.stateAmount;
       console.log("[Checkout] updateStateAmountToRemaining: 状态检查:", {
         calculatedRemainingAmount: remainingAmount,
@@ -1789,16 +1875,15 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
    */
   async checkOrderPaymentCompletion() {
-    var _a, _b;
     try {
       if (!this.store.currentOrder) {
         return;
       }
-      const remainingAmount = this.calculateRemainingAmount();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
       const remainingValue = parseFloat(remainingAmount);
       if (remainingValue <= 0) {
         const totalAmount = this.store.currentOrder.total_amount;
-        const paidAmount = this.calculatePaidAmount();
+        const paidAmount = await this.calculatePaidAmountAsync();
         console.log("[Checkout] 检测到订单支付完成:", {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
@@ -1807,13 +1892,18 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           remainingAmount,
           isOrderSynced: this.store.isOrderSynced
         });
-        const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.every(
+        const currentPayments = await this.payment.getPaymentItemsAsync(
+          this.store.currentOrder.uuid,
+          false
+          // 不包括已撤销的支付项
+        );
+        const allPaymentsHaveVoucherId = currentPayments.length > 0 && currentPayments.every(
           (item) => item.status !== "voided" && item.voucher_id
         );
         console.log("[Checkout] 支付项voucher_id检查:", {
-          paymentCount: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) || 0,
+          paymentCount: currentPayments.length,
           allHaveVoucherId: allPaymentsHaveVoucherId,
-          paymentItems: (_b = this.store.currentOrder.payment) == null ? void 0 : _b.map((p) => ({
+          paymentItems: currentPayments.map((p) => ({
             uuid: p.uuid,
             code: p.code,
             amount: p.amount,
@@ -1821,13 +1911,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             status: p.status
           }))
         });
-        if (!this.store.isOrderSynced) {
-          if (allPaymentsHaveVoucherId) {
-            console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
-          } else {
-            console.log("[Checkout] 支付完成但订单未同步，开始同步订单到后端...");
-            await this.syncOrderToBackend();
-          }
+        if (allPaymentsHaveVoucherId) {
+          console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
+        } else {
+          console.log("[Checkout] 支付完成但订单未同步，开始同步订单到后端...");
+          await this.syncOrderToBackend();
         }
         await this.core.effects.emit(import_types.CheckoutHooks.OnOrderPaymentCompleted, {
           orderUuid: this.store.currentOrder.uuid,
@@ -2185,6 +2273,93 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       };
     }
   }
+  /**
+   * 发送客户支付链接邮件
+   * 
+   * 向指定邮箱发送订单支付提醒邮件
+   * 
+   * @param params 发送参数
+   * @returns 发送结果
+   */
+  async sendCustomerPayLinkAsync(params) {
+    try {
+      console.log("[Checkout] 开始发送客户支付链接邮件:", {
+        orderIds: params.order_ids,
+        emails: params.emails,
+        notifyAction: params.notify_action || "order_payment_reminder"
+      });
+      if (!params.order_ids || params.order_ids.length === 0) {
+        return {
+          success: false,
+          message: "订单ID列表不能为空"
+        };
+      }
+      if (!params.emails || params.emails.length === 0) {
+        return {
+          success: false,
+          message: "邮箱地址列表不能为空"
+        };
+      }
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      const invalidEmails = params.emails.filter((email) => !emailRegex.test(email));
+      if (invalidEmails.length > 0) {
+        return {
+          success: false,
+          message: `邮箱格式无效: ${invalidEmails.join(", ")}`
+        };
+      }
+      const requestBody = {
+        order_ids: params.order_ids,
+        notify_action: params.notify_action || "order_payment_reminder",
+        emails: params.emails
+      };
+      console.log("[Checkout] 发送支付链接邮件请求参数:", requestBody);
+      const response = await this.request.post("/order/batch-email", requestBody);
+      console.log("[Checkout] 支付链接邮件发送响应:", {
+        status: response.status,
+        message: response.message,
+        data: response.data,
+        response
+      });
+      if (response.status === true || response.status === 200) {
+        console.log("[Checkout] 支付链接邮件发送成功");
+        return {
+          success: true,
+          message: response.message || "支付链接邮件发送成功"
+        };
+      } else {
+        const errorMessage = response.message || "支付链接邮件发送失败";
+        console.error("[Checkout] 支付链接邮件发送失败:", errorMessage);
+        return {
+          success: false,
+          message: errorMessage
+        };
+      }
+    } catch (error) {
+      console.error("[Checkout] 发送客户支付链接邮件失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
+      return {
+        success: false,
+        message: `发送支付链接邮件失败: ${errorMessage}`
+      };
+    }
+  }
+  /**
+   * 金额舍入
+   * 
+   * @param amount 原始金额
+   * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
+   */
+  async roundAmountAsync(amount) {
+    var _a, _b;
+    const result = await this.payment.roundAmountAsync(
+      amount,
+      (_a = this.otherParams.order_rounding_setting) == null ? void 0 : _a.interval,
+      (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.type
+    );
+    console.log(`[Checkout] 金额舍入完成 - 原始: ${result.originalAmount}, 舍入后: ${result.roundedAmount}, 差额: ${result.roundingDifference}`);
+    return result;
+  }
   async destroy() {
     var _a, _b, _c, _d;
     this.payment.wallet.clearAllCache();

package/lib/solution/Checkout/types.d.ts

@@ -389,7 +389,9 @@ export declare enum CheckoutHooks {
     /** 订单备注变更 */
     OnOrderNoteChanged = "checkout:onOrderNoteChanged",
     /** 商店折扣变更 */
-    OnShopDiscountChanged = "checkout:onShopDiscountChanged"
+    OnShopDiscountChanged = "checkout:onShopDiscountChanged",
+    /** 订单取消 */
+    OnOrderCancelled = "checkout:onOrderCancelled"
 }
 /**
  * 结账状态数据
@@ -610,11 +612,12 @@ export interface CheckoutModuleAPI extends Module {
         orderUuid?: string;
     }>;
     /**
-     * 检查订单是否需要手动同步
+     * 检查订单是否需要手动同步（异步版本）
      *
      * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
+     * 从 Payment 模块获取最新的支付项数据
      */
-    needsManualSync(): boolean;
+    needsManualSyncAsync(): Promise<boolean>;
     /**
      * 更新订单备注
      *
@@ -633,6 +636,25 @@ export interface CheckoutModuleAPI extends Module {
      * @returns 当前订单的ID，如果没有订单则返回null
      */
     getCurrentOrderId(): string | null;
+    /**
+     * 获取当前订单是否已同步到后端
+     *
+     * @returns 当前订单是否已同步状态，如果没有订单则返回false
+     */
+    isCurrentOrderSynced(): boolean;
+    /**
+     * 取消当前本地订单
+     *
+     * 只能取消未同步到后端的本地订单，如果订单已同步则不能取消
+     *
+     * @param cancelReason 取消原因（可选）
+     * @returns 取消结果
+     */
+    cancelCurrentOrderAsync(cancelReason?: string): Promise<{
+        success: boolean;
+        message?: string;
+        orderId?: string;
+    }>;
     /**
      * 更新订单商店折扣
      *
@@ -675,6 +697,42 @@ export interface CheckoutModuleAPI extends Module {
         message?: string;
         orderId?: string | number;
     }>;
+    /**
+     * 发送客户支付链接邮件
+     *
+     * 向指定邮箱发送订单支付提醒邮件
+     *
+     * @param params 发送参数
+     * @returns 发送结果
+     */
+    sendCustomerPayLinkAsync(params: SendCustomerPayLinkParams): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * 金额舍入
+     *
+     * 根据系统配置的舍入设置对金额进行舍入处理
+     *
+     * @param amount 原始金额
+     * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
+     */
+    roundAmountAsync(amount: number): Promise<{
+        originalAmount: string;
+        roundedAmount: string;
+        roundingDifference: string;
+    }>;
+}
+/**
+ * 发送客户支付链接参数
+ */
+export interface SendCustomerPayLinkParams {
+    /** 订单ID列表 */
+    order_ids: string[];
+    /** 通知动作，固定为订单支付提醒 */
+    notify_action?: string;
+    /** 邮箱地址列表 */
+    emails: string[];
 }
 /**
  * 结账事件数据类型
@@ -748,4 +806,12 @@ export interface CheckoutEventData {
         newDiscount: number;
         timestamp: number;
     };
+    /** 订单取消事件 */
+    orderCancelled: {
+        orderUuid?: string;
+        orderId?: string;
+        cancelReason?: string;
+        wasSynced: boolean;
+        timestamp: number;
+    };
 }

package/lib/solution/Checkout/types.js

@@ -69,6 +69,7 @@ var CheckoutHooks = /* @__PURE__ */ ((CheckoutHooks2) => {
   CheckoutHooks2["OnOrderSynced"] = "checkout:onOrderSynced";
   CheckoutHooks2["OnOrderNoteChanged"] = "checkout:onOrderNoteChanged";
   CheckoutHooks2["OnShopDiscountChanged"] = "checkout:onShopDiscountChanged";
+  CheckoutHooks2["OnOrderCancelled"] = "checkout:onOrderCancelled";
   return CheckoutHooks2;
 })(CheckoutHooks || {});
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "0.0.233",
+  "version": "0.0.235",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",