@pisell/pisellos 0.0.10 → 0.0.13

package/lib/modules/Date/utils.js

@@ -0,0 +1,167 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Date/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  disableAllDates: () => disableAllDates,
+  disableDatesBeforeOneDay: () => disableDatesBeforeOneDay,
+  generateMonthDates: () => generateMonthDates,
+  handleAvailableDateByResource: () => handleAvailableDateByResource,
+  handleAvailableDatesByRules: () => handleAvailableDatesByRules
+});
+module.exports = __toCommonJS(utils_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var generateMonthDates = (startDate, endDate) => {
+  const start = (0, import_dayjs.default)(startDate).format("YYYY-MM-01");
+  const end = (0, import_dayjs.default)(endDate).format("YYYY-MM-DD");
+  const dates = [];
+  let currentDate = (0, import_dayjs.default)(start);
+  while ((0, import_dayjs.default)(currentDate).isBefore((0, import_dayjs.default)(end)) || (0, import_dayjs.default)(currentDate).isSame((0, import_dayjs.default)(end))) {
+    dates.push({
+      date: (0, import_dayjs.default)(currentDate).format("YYYY-MM-DD"),
+      week: (0, import_dayjs.default)(currentDate).format("ddd"),
+      weekNum: (0, import_dayjs.default)(currentDate).day(),
+      status: "available"
+    });
+    currentDate = (0, import_dayjs.default)(currentDate).add(1, "day");
+  }
+  return dates;
+};
+var disableAllDates = (dates) => {
+  return dates.map((date) => ({ ...date, status: "unavailable" }));
+};
+var disableDatesBeforeOneDay = (dates, oneDay) => {
+  const day = oneDay ? (0, import_dayjs.default)(oneDay).format("YYYY-MM-DD") : (0, import_dayjs.default)().format("YYYY-MM-DD");
+  return dates.map((date) => {
+    if ((0, import_dayjs.default)(date.date).isBefore(day)) {
+      return { ...date, status: "unavailable" };
+    } else {
+      return date;
+    }
+  });
+};
+var handleAvailableDateByResource = (resources, dates) => {
+  const dateMap = {};
+  resources.forEach((resource) => {
+    const { form_id, id, times, ...others } = resource;
+    times.forEach((time) => {
+      var _a;
+      const { start_at } = time;
+      const date = (0, import_dayjs.default)(start_at).format("YYYY-MM-DD");
+      if (!dateMap[date]) {
+        dateMap[date] = [{ form_id, id, ...others, times: [time] }];
+      } else {
+        const temp = (_a = dateMap[date].filter((item) => item.id === id)) == null ? void 0 : _a[0];
+        if (temp) {
+          temp.times.push(time);
+        } else {
+          dateMap[date].push({ form_id, id, ...others, times: [time] });
+        }
+      }
+    });
+  });
+  return dates.map((date) => {
+    const resource = dateMap[date.date];
+    if (resource) {
+      return { ...date, resource };
+    } else {
+      return { ...date, status: "unavailable", resource: [] };
+    }
+  });
+};
+var handleAvailableDatesByRules = (dates, rules) => {
+  let newDates = disableDatesBeforeOneDay(dates);
+  if (!(rules == null ? void 0 : rules.length)) {
+    return newDates;
+  }
+  let latestStartDate = "";
+  let earliestEndDate = "";
+  let resourceFormIds = [];
+  rules.forEach((rule) => {
+    var _a;
+    const { future_day, unit, unit_type } = (rule == null ? void 0 : rule.cut_off_time) || {};
+    if (future_day) {
+      const endDate = (0, import_dayjs.default)().add(future_day, "day");
+      if (!earliestEndDate || endDate.isBefore((0, import_dayjs.default)(earliestEndDate))) {
+        earliestEndDate = endDate.format("YYYY-MM-DD");
+      }
+    } else if (future_day === 0) {
+      const endDate = (0, import_dayjs.default)();
+      if (!earliestEndDate || endDate.isBefore((0, import_dayjs.default)(earliestEndDate))) {
+        earliestEndDate = endDate.format("YYYY-MM-DD");
+      }
+    }
+    if (unit && unit_type) {
+      const startDate = (0, import_dayjs.default)((0, import_dayjs.default)().add(unit, unit_type).format("YYYY-MM-DD"));
+      if (!latestStartDate || startDate.isAfter((0, import_dayjs.default)(latestStartDate))) {
+        latestStartDate = startDate.format("YYYY-MM-DD");
+      }
+    }
+    if ((_a = rule == null ? void 0 : rule.resourceFormIds) == null ? void 0 : _a.length) {
+      resourceFormIds = [.../* @__PURE__ */ new Set([...resourceFormIds, ...rule == null ? void 0 : rule.resourceFormIds])];
+    }
+  });
+  newDates = newDates.map((date) => {
+    var _a;
+    const disabledDate = { ...date, status: "unavailable" };
+    if (!((_a = date == null ? void 0 : date.resource) == null ? void 0 : _a.length)) {
+      return disabledDate;
+    }
+    if (latestStartDate || earliestEndDate) {
+      if (latestStartDate && (0, import_dayjs.default)(date.date).isBefore(latestStartDate)) {
+        return disabledDate;
+      }
+      if (earliestEndDate && (0, import_dayjs.default)(date.date).isAfter(earliestEndDate)) {
+        return disabledDate;
+      }
+    }
+    if (resourceFormIds == null ? void 0 : resourceFormIds.length) {
+      let hasReourceCount = 0;
+      resourceFormIds.forEach((formId) => {
+        var _a2;
+        if (((_a2 = date == null ? void 0 : date.resource) == null ? void 0 : _a2.find((item) => item.form_id === formId)) !== void 0) {
+          hasReourceCount++;
+        }
+      });
+      if (hasReourceCount < resourceFormIds.length) {
+        return disabledDate;
+      }
+    }
+    return date;
+  });
+  return newDates;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  disableAllDates,
+  disableDatesBeforeOneDay,
+  generateMonthDates,
+  handleAvailableDateByResource,
+  handleAvailableDatesByRules
+});

package/lib/modules/Discount/index.d.ts

@@ -0,0 +1,26 @@
+import { Module, PisellCore, ModuleOptions } from "../../types";
+import { BaseModule } from "../BaseModule";
+import { Discount, DiscountModuleAPI } from "./types";
+export declare class DiscountModule extends BaseModule implements Module, DiscountModuleAPI {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private request;
+    private window;
+    private store;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    setDiscountList(discountList: Discount[]): Promise<void>;
+    getDiscountList(): Discount[];
+    loadPrepareConfig(params: {
+        action?: "create";
+        with_good_pass: 0 | 1;
+        customer_id: number;
+    }): Promise<Discount[]>;
+    batchSearch(code: string): Promise<Discount[]>;
+    filterEnabledDiscountList(discountList: Discount[]): Discount[];
+    uniqueByProductId(discountList: Discount[]): Discount[];
+    filterDiscountListByProductIds(discountList: Discount[], productIds: number[]): Discount[];
+    calcDiscountApplicableProductTotalPrice(discount: Discount): number;
+    destroy(): Promise<void>;
+    clear(): Promise<void>;
+}

package/lib/modules/Discount/index.js

@@ -0,0 +1,118 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Discount/index.ts
+var Discount_exports = {};
+__export(Discount_exports, {
+  DiscountModule: () => DiscountModule
+});
+module.exports = __toCommonJS(Discount_exports);
+var import_utils = require("../../solution/ShopDiscount/utils");
+var import_BaseModule = require("../BaseModule");
+var import_types = require("./types");
+var DiscountModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "discount";
+    this.defaultVersion = "1.0.0";
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.store = options == null ? void 0 : options.store;
+    this.request = core.getPlugin("request");
+    this.window = core.getPlugin("window");
+    if (!this.request) {
+      throw new Error("discount模块需要 request 插件支持");
+    }
+    if (!this.window) {
+      throw new Error("discount模块需要 window 插件支持");
+    }
+  }
+  async setDiscountList(discountList) {
+    this.store.discountList = discountList;
+    await this.core.effects.emit(
+      import_types.DiscountHooks.OnDiscountListChange,
+      discountList
+    );
+  }
+  getDiscountList() {
+    return this.store.discountList;
+  }
+  async loadPrepareConfig(params) {
+    var _a;
+    const prepareConfig = await this.request.post(
+      `/order/prepare/config`,
+      params
+    );
+    const goodPassList = this.uniqueByProductId(
+      this.filterEnabledDiscountList(
+        ((_a = prepareConfig == null ? void 0 : prepareConfig.data) == null ? void 0 : _a.good_pass_list) || []
+      ) || []
+    ) || [];
+    return goodPassList;
+  }
+  async batchSearch(code) {
+    const result = await this.request.get(`/machinecode/batch-search`, {
+      code,
+      translate_flag: 1,
+      tag: "good_pass",
+      available: 1,
+      relation_product: 1
+    });
+    const resultDiscountList = this.uniqueByProductId(this.filterEnabledDiscountList((result == null ? void 0 : result.data) || []) || []) || [];
+    return resultDiscountList;
+  }
+  filterEnabledDiscountList(discountList) {
+    return discountList.filter(
+      (discount) => discount.limit_status === "enable" && Number((discount == null ? void 0 : discount.par_value) || 0) - Number((discount == null ? void 0 : discount.used_par_value) || 0) > 0
+    );
+  }
+  // 根据productIds去重
+  uniqueByProductId(discountList) {
+    return (0, import_utils.uniqueById)(discountList, "product_id");
+  }
+  filterDiscountListByProductIds(discountList, productIds) {
+    return discountList.filter((discount) => {
+      const applicableProductIds = discount.applicableProductIds || [];
+      return applicableProductIds.some((id) => productIds.includes(id));
+    });
+  }
+  calcDiscountApplicableProductTotalPrice(discount) {
+    if (discount.appliedProductDetails) {
+      return discount.appliedProductDetails.reduce((total, product) => {
+        const price = Number(product == null ? void 0 : product.amount) || 0;
+        return total + price;
+      }, 0);
+    }
+    return (discount == null ? void 0 : discount.savedAmount) || 0;
+  }
+  async destroy() {
+    this.store.discountList = [];
+    this.core.effects.offByModuleDestroy(this.name);
+    await this.core.effects.emit(import_types.DiscountHooks.OnDestroy, {});
+    console.log("[Discount] 已销毁");
+  }
+  async clear() {
+    this.store.discountList = [];
+    console.log("[Discount] clear");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DiscountModule
+});

package/lib/modules/Discount/types.d.ts

@@ -0,0 +1,66 @@
+export declare enum DiscountHooks {
+    OnDiscountListChange = "discount:onDiscountListChange",
+    OnDestroy = "discount:onDestroy"
+}
+interface Product {
+    id: number;
+    title: string;
+    is_charge_tax: number;
+    base_price: string;
+}
+interface Formattitle {
+    auto: string;
+    original: string;
+    en?: any;
+    'zh-CN'?: any;
+    'zh-HK'?: any;
+}
+interface Limitedrelationproductdata {
+    id: number;
+    type: 'product_all' | 'products' | 'product_collection';
+    product_ids: number[];
+    product_collection_id: number[];
+}
+interface ApplicableProductDetails {
+    amount: string;
+    type: string;
+    resource_id: number;
+    title: string;
+    original_amount: string;
+}
+export interface Discount {
+    id: number;
+    product_name: string;
+    encoded: string;
+    code: string;
+    tag: string;
+    expire_time?: string;
+    product_id: number;
+    relation_type: string;
+    par_value: string;
+    used_par_value: string;
+    limit_status: string;
+    limited_relation_product_data: Limitedrelationproductdata;
+    balance: string;
+    format_title: Formattitle;
+    product: Product;
+    resource_id?: number;
+    savedAmount?: number;
+    isEditMode?: boolean;
+    isManualSelect?: boolean;
+    isDisabled?: boolean;
+    isSelected?: boolean;
+    isAvailable?: boolean;
+    isUsed?: boolean;
+    applicableProductIds?: number[];
+    applicableProductDetails: ApplicableProductDetails[];
+    appliedProductDetails: ApplicableProductDetails[];
+}
+export interface DiscountState {
+    discountList: Discount[];
+}
+export interface DiscountModuleAPI {
+    setDiscountList: (discountList: Discount[]) => Promise<void>;
+    clear: () => Promise<void>;
+}
+export {};

package/lib/modules/Discount/types.js

@@ -0,0 +1,33 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Discount/types.ts
+var types_exports = {};
+__export(types_exports, {
+  DiscountHooks: () => DiscountHooks
+});
+module.exports = __toCommonJS(types_exports);
+var DiscountHooks = /* @__PURE__ */ ((DiscountHooks2) => {
+  DiscountHooks2["OnDiscountListChange"] = "discount:onDiscountListChange";
+  DiscountHooks2["OnDestroy"] = "discount:onDestroy";
+  return DiscountHooks2;
+})(DiscountHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DiscountHooks
+});

package/lib/modules/Order/index.d.ts

@@ -1,17 +1,21 @@
-import { Module, PisellCore, ModuleOptions } from '../../types';
-import { BaseModule } from '../BaseModule';
-import { Order, OrderItem, OrderModuleAPI, OrderStatus } from './types';
+import { Module, PisellCore, ModuleOptions } from "../../types";
+import { BaseModule } from "../BaseModule";
+import { OrderModuleAPI, CommitOrderParams } from "./types";
 export declare class OrderModule extends BaseModule implements Module, OrderModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
-    private state;
+    private store;
+    private request;
     constructor(name?: string, version?: string);
-    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
-    createOrder(items: OrderItem[]): Promise<Order>;
-    getOrder(orderId: string): Promise<Order>;
-    updateOrderStatus(orderId: string, status: OrderStatus): Promise<void>;
-    cancelOrder(orderId: string): Promise<void>;
-    getOrderHistory(): Promise<Order[]>;
-    getCurrentOrder(): Order | null;
-    calculateTotalAmount(items: OrderItem[]): number;
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    createOrder(params: CommitOrderParams["query"]): {
+        type: string;
+        platform: string;
+        sales_channel: string;
+        order_sales_channel: string;
+        bookings: any[];
+        shop_note: string;
+        schedule_date: string;
+    };
+    commitOrder(order: CommitOrderParams): Promise<void>;
 }

package/lib/modules/Order/index.js

@@ -23,70 +23,42 @@ __export(Order_exports, {
 });
 module.exports = __toCommonJS(Order_exports);
 var import_BaseModule = require("../BaseModule");
-var import_types = require("./types");
 var OrderModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
     this.defaultName = "order";
     this.defaultVersion = "1.0.0";
-    this.state = {
-      currentOrder: null,
-      orderHistory: []
-    };
   }
   async initialize(core, options) {
     this.core = core;
-    if (options == null ? void 0 : options.initialState) {
-      this.state = { ...this.state, ...options.initialState };
-    }
+    this.store = options.store;
+    this.request = this.core.getPlugin("request");
   }
-  async createOrder(items) {
+  createOrder(params) {
     const order = {
-      id: Date.now().toString(),
-      // 实际应该使用更可靠的 ID 生成方式
-      orderNumber: `ORD-${Date.now()}`,
-      status: "pending",
-      items,
-      totalAmount: this.calculateTotalAmount(items),
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
+      type: "appointment_booking",
+      platform: "H5",
+      sales_channel: "my_pisel",
+      order_sales_channel: "online_store",
+      bookings: [],
+      shop_note: "",
+      schedule_date: ""
     };
-    this.state.currentOrder = order;
-    await this.core.effects.emit(import_types.OrderHooks.OnOrderCreate, order);
-    return order;
-  }
-  async getOrder(orderId) {
-    const order = this.state.orderHistory.find((o) => o.id === orderId);
-    if (!order)
-      throw new Error("Order not found");
+    if (params.cartItems.length > 0) {
+      params.cartItems.forEach((item) => {
+        order.bookings.push(item._origin);
+      });
+      const firstCartItem = params.cartItems[0];
+      order.schedule_date = firstCartItem.start_date + " " + firstCartItem.start_time + ":00";
+    }
     return order;
   }
-  async updateOrderStatus(orderId, status) {
-    const order = this.state.orderHistory.find((o) => o.id === orderId);
-    if (!order)
-      return;
-    order.status = status;
-    order.updatedAt = /* @__PURE__ */ new Date();
-    await this.core.effects.emit(import_types.OrderHooks.OnOrderStatusChange, { orderId, status });
-    await this.core.effects.emit(import_types.OrderHooks.OnOrderUpdate, order);
-  }
-  async cancelOrder(orderId) {
-    const order = this.state.orderHistory.find((o) => o.id === orderId);
-    if (!order)
-      return;
-    order.status = "cancelled";
-    order.updatedAt = /* @__PURE__ */ new Date();
-    await this.core.effects.emit(import_types.OrderHooks.OnOrderCancel, order);
-    await this.core.effects.emit(import_types.OrderHooks.OnOrderUpdate, order);
-  }
-  async getOrderHistory() {
-    return this.state.orderHistory;
-  }
-  getCurrentOrder() {
-    return this.state.currentOrder;
-  }
-  calculateTotalAmount(items) {
-    return items.reduce((total, item) => total + item.price * item.quantity, 0);
+  async commitOrder(order) {
+    const { url, query } = order;
+    const fetchUrl = url || "/order/appointment";
+    const params = this.createOrder(query);
+    console.log(params);
+    return this.request.post(fetchUrl, params);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/modules/Order/types.d.ts

@@ -1,57 +1,34 @@
-import { Guest } from '../Guests/types';
-import { Resource } from '../Resource/types';
-import { TimeSlot } from '../Date/types';
+import { CartItem } from "../Cart/types";
 export declare enum OrderHooks {
     OnOrderCreate = "order:onOrderCreate",
     OnOrderUpdate = "order:onOrderUpdate",
     OnOrderCancel = "order:onOrderCancel",
     OnOrderStatusChange = "order:onOrderStatusChange"
 }
-/**
- * 订单状态
- */
-export type OrderStatus = 'pending' | 'paid' | 'confirmed' | 'completed' | 'cancelled' | 'refunded';
-/**
- * 订单项
- */
-export interface OrderItem {
-    id: string;
-    productId: string;
-    quantity: number;
-    price: number;
-    guest: Guest;
-    resource: Resource;
-    timeSlot: TimeSlot;
+export interface OrderState {
 }
 /**
  * 订单信息
  */
-export interface Order {
-    id: string;
-    orderNumber: string;
-    status: OrderStatus;
-    items: OrderItem[];
-    totalAmount: number;
-    createdAt: Date;
-    updatedAt: Date;
-    metadata?: Record<string, any>;
-}
-/**
- * 订单模块状态
- */
-export interface OrderState {
-    currentOrder: Order | null;
-    orderHistory: Order[];
+export interface CommitOrderParams {
+    url?: string;
+    query: {
+        cartItems: CartItem[];
+    };
 }
 /**
  * 订单模块 API
  */
 export interface OrderModuleAPI {
-    createOrder: (items: OrderItem[]) => Promise<Order>;
-    getOrder: (orderId: string) => Promise<Order>;
-    updateOrderStatus: (orderId: string, status: OrderStatus) => Promise<void>;
-    cancelOrder: (orderId: string) => Promise<void>;
-    getOrderHistory: () => Promise<Order[]>;
-    getCurrentOrder: () => Order | null;
-    calculateTotalAmount: (items: OrderItem[]) => number;
+    /**
+     * 创建订单
+     * @param params 订单信息
+     * @returns 订单信息
+     */
+    createOrder: (params: CommitOrderParams["query"]) => any;
+    /**
+     * 提交订单
+     * @param params 订单信息
+     */
+    commitOrder: (params: CommitOrderParams) => Promise<void>;
 }

package/lib/modules/Payment/index.d.ts

@@ -1,14 +1,12 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
 import { Payment, PaymentModuleAPI, PaymentMethod, PaymentStatus } from './types';
-import { Order } from '../Order/types';
 export declare class PaymentModule extends BaseModule implements Module, PaymentModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
     private state;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
-    initPayment(order: Order, method: PaymentMethod): Promise<Payment>;
     processPayment(paymentId: string): Promise<void>;
     getPayment(paymentId: string): Promise<Payment>;
     getPaymentHistory(): Promise<Payment[]>;

package/lib/modules/Payment/index.js

@@ -40,23 +40,12 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       this.state = { ...this.state, ...options.initialState };
     }
   }
-  async initPayment(order, method) {
-    const payment = {
-      id: Date.now().toString(),
-      // 实际应该使用更可靠的 ID 生成方式
-      orderId: order.id,
-      amount: order.totalAmount,
-      currency: "CNY",
-      // 默认货币
-      method,
-      status: "pending",
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    this.state.currentPayment = payment;
-    await this.core.effects.emit(import_types.PaymentHooks.OnPaymentInit, payment);
-    return payment;
-  }
+  // async initPayment(order: OrderModule, method: PaymentMethod) {
+  // const payment: Payment = {}
+  // this.state.currentPayment = payment
+  // await this.core.effects.emit(PaymentHooks.OnPaymentInit, payment)
+  // return payment
+  // }
   async processPayment(paymentId) {
     const payment = this.state.paymentHistory.find((p) => p.id === paymentId);
     if (!payment)

package/lib/modules/Payment/types.d.ts

@@ -1,4 +1,3 @@
-import { Order } from '../Order/types';
 export declare enum PaymentHooks {
     OnPaymentInit = "payment:onPaymentInit",
     OnPaymentSuccess = "payment:onPaymentSuccess",
@@ -39,7 +38,6 @@ export interface PaymentState {
  * 支付模块 API
  */
 export interface PaymentModuleAPI {
-    initPayment: (order: Order, method: PaymentMethod) => Promise<Payment>;
     processPayment: (paymentId: string) => Promise<void>;
     getPayment: (paymentId: string) => Promise<Payment>;
     getPaymentHistory: () => Promise<Payment[]>;