@pisell/pisellos 0.0.10 → 0.0.13

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

@@ -17,7 +17,7 @@ export interface ProductData {
     /** 商品slug */
     slug: string;
     /** draft:草稿;published:已发布;pending:待发布;archived:已归档 */
-    status: 'draft' | 'published' | 'pending' | 'archived';
+    status: "draft" | "published" | "pending" | "archived";
     /** 库存数量 */
     stock_quantity: number;
     /** 销售数量 */
@@ -132,10 +132,26 @@ export interface ProductData {
     base_price: string;
     /** 规格列表 */
     variant: any[];
+    /** 媒体 */
     media: ProductMedia[];
+    /** 标签 */
     tags: ProductTag[];
+    /** 分类 */
     categories: ProductCategory[];
+    /** 套餐组 */
     bundle_groups: ProductBundleGroup[];
+    /** 商品资源 */
+    product_resource?: {
+        resources?: ProductResourceItem[];
+    };
+    /** 组合商品id，动态附加 */
+    product_variant_id?: number;
+    /** 套餐信息 */
+    bundle?: any[];
+    /** 商品选项组成 */
+    options?: any[];
+    /** 商品原信息 */
+    origin?: any;
 }
 /**
  * 商品媒体信息接口
@@ -387,3 +403,34 @@ export interface ProductBundleItem {
     /** 明细库存 */
     stock_quantity: string;
 }
+/**
+ * 商品资源
+ */
+export interface ProductResourceItem {
+    /** 资源是否启用：0: 禁用, 1: 启用 */
+    status: 0 | 1;
+    /** 资源id */
+    id: number;
+    /** 资源标题 */
+    title: string;
+    /** 资源编码 */
+    code: "resource";
+    /** 默认资源 */
+    default_resource?: number[];
+    /** 可选资源 */
+    optional_resource?: number[];
+    /** 资源类型id */
+    resource_type_id: number;
+    /** 选择类型 */
+    select_type?: {
+        type: "single";
+        min: 1;
+        max: 1;
+    };
+    /** 创建时间 */
+    created_at: string;
+    /** 更新时间 */
+    updated_at: string;
+    /** 可用资源列表 */
+    renderList?: any[];
+}

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

@@ -13,4 +13,5 @@ export declare class ProductList extends BaseModule implements Module {
     getProducts(): Promise<ProductData[]>;
     getProduct(id: number): Promise<Product | undefined>;
     addProduct(products: ProductData[]): Promise<void>;
+    selectProducts(products: ProductData[]): Promise<void>;
 }

package/lib/modules/ProductList/index.js

@@ -39,6 +39,7 @@ var ProductList = class extends import_BaseModule.BaseModule {
     this.store = options.store;
     this.store.productMap = /* @__PURE__ */ new Map();
     this.store.list = [];
+    this.store.selectProducts = [];
     this.storeChange();
   }
   async storeChange(path, value) {
@@ -65,6 +66,9 @@ var ProductList = class extends import_BaseModule.BaseModule {
   async addProduct(products) {
     this.store.list = [...this.store.list, ...products];
   }
+  async selectProducts(products) {
+    this.store.selectProducts = products;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -2,6 +2,7 @@ import { ProductData } from '../Product/types';
 export interface ProductListData {
     list: ProductData[];
     productMap: Map<string, any>;
+    selectProducts: ProductData[];
 }
 export declare enum ProductListHooks {
     onGetProducts = "productList:onGetProducts",

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

@@ -16,12 +16,16 @@ export interface ResourceTimeSlot {
  * 资源信息
  */
 export interface Resource {
-    id: string;
-    name: string;
+    id: string | number;
+    main_field: string;
+    form_id: string | number;
     type: string;
     capacity: number;
     timeSlots: ResourceTimeSlot[];
     metadata?: Record<string, any>;
+    startTime?: string;
+    endTime?: string;
+    resourceType?: string;
 }
 /**
  * 资源列表状态

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

@@ -0,0 +1,32 @@
+import { Module, PisellCore, ModuleOptions } from "../../types";
+import { BaseModule } from "../BaseModule";
+import { Rules, RulesModuleAPI, DiscountResult } from "./types";
+import { Discount } from "../Discount/types";
+export declare class RulesModule extends BaseModule implements Module, RulesModuleAPI {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    private hooks;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    setRulesList(rulesList: Rules[]): Promise<void>;
+    getRulesList(): Rules[];
+    isDiscountListAvailable({ oldDiscountList, newDiscountList, productList, }: {
+        oldDiscountList: Discount[];
+        newDiscountList: Discount[];
+        productList: any[];
+    }): {
+        isAvailable: boolean;
+        discountList: Discount[];
+        productList: any[];
+    };
+    calcDiscount({ discountList, productList, }: {
+        discountList: Discount[];
+        productList: any[];
+    }, options?: {
+        isSelected?: boolean;
+        discountId: number;
+    }): DiscountResult;
+    destroy(): Promise<void>;
+    clear(): Promise<void>;
+}

package/lib/modules/Rules/index.js

@@ -0,0 +1,283 @@
+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/Rules/index.ts
+var Rules_exports = {};
+__export(Rules_exports, {
+  RulesModule: () => RulesModule
+});
+module.exports = __toCommonJS(Rules_exports);
+var import_BaseModule = require("../BaseModule");
+var import_types = require("./types");
+var import_utils = require("../../solution/ShopDiscount/utils");
+var RulesModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "rules";
+    this.defaultVersion = "1.0.0";
+    this.hooks = {};
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.hooks = options == null ? void 0 : options.hooks;
+    this.store = options == null ? void 0 : options.store;
+  }
+  async setRulesList(rulesList) {
+    this.store.rulesList = rulesList;
+    await this.core.effects.emit(import_types.RulesHooks.OnRulesListChange, rulesList);
+  }
+  getRulesList() {
+    return this.store.rulesList;
+  }
+  // 判断discountList 是否可以对当前productList生效
+  isDiscountListAvailable({
+    oldDiscountList,
+    newDiscountList,
+    productList
+  }) {
+    if (!newDiscountList || newDiscountList.length === 0) {
+      return {
+        isAvailable: false,
+        discountList: oldDiscountList,
+        productList
+      };
+    }
+    const mergedDiscountList = (0, import_utils.uniqueById)([
+      ...oldDiscountList,
+      ...newDiscountList
+    ]);
+    const result = this.calcDiscount({
+      discountList: mergedDiscountList,
+      productList: [...productList]
+    });
+    let hasApplicableDiscount = false;
+    const newDiscountIds = newDiscountList.map((discount) => discount.id);
+    result.productList.forEach((product) => {
+      const { discount_list } = this.hooks.getProduct(product);
+      if (discount_list && discount_list.length > 0) {
+        const usedNewDiscount = discount_list.some(
+          (discount) => newDiscountIds.includes(discount.resource_id)
+        );
+        if (usedNewDiscount) {
+          hasApplicableDiscount = true;
+        }
+      }
+    });
+    return {
+      isAvailable: hasApplicableDiscount,
+      discountList: hasApplicableDiscount ? result.discountList : oldDiscountList,
+      productList: hasApplicableDiscount ? result.productList : productList
+    };
+  }
+  calcDiscount({
+    discountList,
+    productList
+  }, options) {
+    const editModeDiscount = [];
+    const addModeDiscount = [];
+    discountList.forEach((discount) => {
+      if (discount.isEditMode) {
+        editModeDiscount.push(discount);
+      } else {
+        addModeDiscount.push(discount);
+      }
+    });
+    const filteredDiscountList = addModeDiscount.filter((discount) => {
+      return !discount.isManualSelect;
+    });
+    const sortedDiscountList = [...filteredDiscountList].sort((a, b) => {
+      if (a.expire_time && b.expire_time) {
+        const timeA = new Date(a.expire_time).getTime();
+        const timeB = new Date(b.expire_time).getTime();
+        return timeA - timeB;
+      }
+      return a.expire_time ? -1 : b.expire_time ? 1 : 0;
+    });
+    const sortedProductList = [...productList].sort((a, b) => {
+      const aProduct = this.hooks.getProduct(a);
+      const bProduct = this.hooks.getProduct(b);
+      const priceA = parseFloat(aProduct.price || "0");
+      const priceB = parseFloat(bProduct.price || "0");
+      return priceB - priceA;
+    });
+    const usedDiscounts = /* @__PURE__ */ new Map();
+    const discountApplicability = /* @__PURE__ */ new Map();
+    const discountApplicableProducts = /* @__PURE__ */ new Map();
+    addModeDiscount.forEach((discount) => {
+      discountApplicability.set(discount.id, []);
+      discountApplicableProducts.set(discount.id, []);
+    });
+    const processedProductsMap = /* @__PURE__ */ new Map();
+    const appliedDiscountProducts = /* @__PURE__ */ new Map();
+    sortedProductList.forEach((originProduct) => {
+      const product = this.hooks.getProduct(originProduct);
+      addModeDiscount.forEach((discount) => {
+        var _a;
+        const limitedData = discount == null ? void 0 : discount.limited_relation_product_data;
+        if (limitedData.type === "product_all" || limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
+          (_a = discountApplicability.get(discount.id)) == null ? void 0 : _a.push(product.id);
+          const applicableProducts = discountApplicableProducts.get(discount.id) || [];
+          applicableProducts.push({
+            amount: product.price,
+            type: discount.tag,
+            resource_id: discount.id,
+            title: discount.format_title,
+            original_amount: product.origin_total
+          });
+          discountApplicableProducts.set(discount.id, applicableProducts);
+        }
+      });
+    });
+    sortedProductList.forEach((originProduct) => {
+      var _a;
+      const product = this.hooks.getProduct(originProduct);
+      if (product == null ? void 0 : product.booking_id) {
+        processedProductsMap.set(product._id, originProduct);
+        return;
+      }
+      const applicableDiscounts = sortedDiscountList.filter((discount) => {
+        if (usedDiscounts.get(discount.id))
+          return false;
+        const limitedData = discount.limited_relation_product_data;
+        if (limitedData.type === "product_all") {
+          return true;
+        } else if (limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
+          return true;
+        }
+        return false;
+      });
+      const selectedDiscount = applicableDiscounts[0];
+      let isManualDiscount = typeof product.isManualDiscount === "boolean" ? product.isManualDiscount : product.total != product.origin_total && !((_a = product.discount_list) == null ? void 0 : _a.length);
+      if ((options == null ? void 0 : options.discountId) && (options == null ? void 0 : options.discountId) === (selectedDiscount == null ? void 0 : selectedDiscount.id)) {
+        isManualDiscount = false;
+      }
+      if (applicableDiscounts.length === 0 || isManualDiscount) {
+        processedProductsMap.set(
+          product._id,
+          this.hooks.setProduct(originProduct, {
+            ...isManualDiscount ? {} : {
+              total: product.origin_total || product.total,
+              price: product.price
+            },
+            discount_list: []
+          })
+        );
+        return;
+      }
+      usedDiscounts.set(selectedDiscount.id, true);
+      const appliedProducts = appliedDiscountProducts.get(selectedDiscount.id) || [];
+      const discountDetail = {
+        amount: product.price,
+        type: selectedDiscount.tag,
+        resource_id: selectedDiscount.id,
+        title: selectedDiscount.format_title,
+        original_amount: product.origin_total,
+        product_id: selectedDiscount.product_id
+      };
+      appliedProducts.push(discountDetail);
+      appliedDiscountProducts.set(selectedDiscount.id, appliedProducts);
+      processedProductsMap.set(
+        product._id,
+        this.hooks.setProduct(originProduct, {
+          discount_list: [discountDetail],
+          price: 0,
+          total: (product.origin_total || product.total) - product.price,
+          origin_total: product.origin_total || product.total
+        })
+      );
+    });
+    const processedProductList = productList.map((originProduct) => {
+      const product = this.hooks.getProduct(originProduct);
+      return processedProductsMap.get(product._id) || this.hooks.setProduct(originProduct, {
+        discount_list: [],
+        total: product.total,
+        origin_total: product.origin_total,
+        price: product.price
+      });
+    });
+    const updatedDiscountList = addModeDiscount.map((discount) => {
+      const applicableProducts = discountApplicability.get(discount.id) || [];
+      const applicableProductDetails = discountApplicableProducts.get(discount.id) || [];
+      const appliedProductDetails = appliedDiscountProducts.get(discount.id) || [];
+      const isAvailable = applicableProducts.length > 0;
+      if (typeof discount.isSelected === "boolean" && discount.isSelected === false && discount.isManualSelect) {
+        return {
+          ...discount,
+          isUsed: false,
+          isSelected: false,
+          isAvailable,
+          // 正确设置可用性
+          applicableProductIds: applicableProducts,
+          // 添加可抵扣的商品详情
+          applicableProductDetails,
+          // 添加实际抵扣的商品详情（对于未选中的优惠券，为空数组）
+          appliedProductDetails: []
+        };
+      }
+      if (usedDiscounts.get(discount.id)) {
+        return {
+          ...discount,
+          isUsed: true,
+          isSelected: true,
+          // 标记为可用，因为它已被应用
+          isAvailable: true,
+          // 记录适用的商品IDs
+          applicableProductIds: applicableProducts,
+          // 添加可抵扣的商品详情
+          applicableProductDetails,
+          // 添加实际抵扣的商品详情
+          appliedProductDetails
+        };
+      }
+      let isSelected = typeof discount.isSelected === "boolean" ? discount.isSelected : void 0;
+      if (isAvailable && !discount.isManualSelect) {
+        isSelected = true;
+      } else if (!appliedProductDetails.length) {
+        isSelected = false;
+      }
+      return {
+        ...discount,
+        // 如果有适用的商品，标记为可用
+        isAvailable,
+        isSelected,
+        // 记录适用的商品IDs
+        applicableProductIds: applicableProducts,
+        // 添加可抵扣的商品详情
+        applicableProductDetails,
+        // 添加实际抵扣的商品详情（对于未使用的优惠券，为空数组）
+        appliedProductDetails: []
+      };
+    });
+    return {
+      productList: processedProductList,
+      discountList: [...editModeDiscount, ...updatedDiscountList]
+    };
+  }
+  async destroy() {
+    this.core.effects.offByModuleDestroy(this.name);
+    await this.core.effects.emit(import_types.RulesHooks.OnDestroy, {});
+    console.log("[Rules] 已销毁");
+  }
+  async clear() {
+    console.log("[Rules] clear");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RulesModule
+});

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

@@ -0,0 +1,46 @@
+import { Discount } from "../Discount/types";
+export declare enum RulesHooks {
+    OnRulesListChange = "rules:onRulesListChange",
+    OnDestroy = "rules:onDestroy"
+}
+export interface Rules {
+    id: string;
+    name: string;
+    description: string;
+    discount: number;
+}
+export interface RulesState {
+    rulesList: Rules[];
+}
+export interface DiscountResult {
+    productList: any[];
+    discountList: any[];
+}
+export interface RulesModuleAPI {
+    setRulesList: (rulesList: Rules[]) => Promise<void>;
+    clear: () => Promise<void>;
+    calcDiscount: (params: {
+        discountList: any[];
+        productList: any[];
+    }) => DiscountResult;
+}
+type ProductDetail = {
+    isManualDiscount?: boolean;
+    booking_id: any;
+    id: number;
+    price: number | string;
+    total: number;
+    discount_list: Discount[];
+    origin_total: number;
+    _id: string;
+};
+export interface RulesParamsHooks {
+    getProduct: (product: Record<string, any>) => ProductDetail;
+    setProduct: (product: Record<string, any>, values: {
+        total?: number;
+        discount_list: any[];
+        origin_total?: number;
+        price?: number;
+    }) => Record<string, any>;
+}
+export {};

package/lib/modules/Rules/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/Rules/types.ts
+var types_exports = {};
+__export(types_exports, {
+  RulesHooks: () => RulesHooks
+});
+module.exports = __toCommonJS(types_exports);
+var RulesHooks = /* @__PURE__ */ ((RulesHooks2) => {
+  RulesHooks2["OnRulesListChange"] = "rules:onRulesListChange";
+  RulesHooks2["OnDestroy"] = "rules:onDestroy";
+  return RulesHooks2;
+})(RulesHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RulesHooks
+});

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

@@ -0,0 +1,13 @@
+import { Module, PisellCore, ModuleOptions } from "../../types";
+import { BaseModule } from "../BaseModule";
+import { CartItem } from "../Cart/types";
+import { ISummaryState, ISummaryModuleAPI } from "./types";
+export declare class SummaryModule extends BaseModule implements Module, ISummaryModuleAPI {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private shopStore;
+    private store;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    getSummary(cartItems: CartItem[]): Promise<ISummaryState["summary"]>;
+}

package/lib/modules/Summary/index.js

@@ -0,0 +1,49 @@
+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/Summary/index.ts
+var Summary_exports = {};
+__export(Summary_exports, {
+  SummaryModule: () => SummaryModule
+});
+module.exports = __toCommonJS(Summary_exports);
+var import_BaseModule = require("../BaseModule");
+var import_utils = require("./utils");
+var SummaryModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "summary";
+    this.defaultVersion = "1.0.0";
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.store = options.store;
+    this.shopStore = this.core.getPlugin("shopStore");
+  }
+  async getSummary(cartItems) {
+    var _a, _b;
+    const shopInfo = ((_b = (_a = this.shopStore.get("core")) == null ? void 0 : _a.core) == null ? void 0 : _b.shop) || {};
+    const summary = (0, import_utils.calculatePriceDetails)(shopInfo, cartItems);
+    this.store.summary = summary;
+    return this.store.summary;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SummaryModule
+});

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

@@ -0,0 +1,13 @@
+import { CartItem } from "../Cart/types";
+export interface ISummaryState {
+    summary: {
+        subtotal: string | number;
+        total: string | number;
+        taxTitle?: string;
+        totalTaxFee?: string | number;
+        isPriceIncludeTax?: 0 | 1;
+    };
+}
+export interface ISummaryModuleAPI {
+    getSummary(cartItems: CartItem[]): Promise<ISummaryState["summary"]>;
+}

package/lib/modules/Summary/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/Summary/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/modules/Summary/utils.d.ts

@@ -0,0 +1,19 @@
+import Decimal from "decimal.js";
+import { CartItem } from "../Cart/types";
+import { ISummaryState } from "./types";
+export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[]) => ISummaryState["summary"];
+/**
+ * 计算商品小计（不含其他费用）
+ * @param items - 购物车商品数组
+ * @returns 商品总价字符串，保留2位小数
+ */
+export declare const calculateSubtotal: (items: CartItem[]) => string;
+/**
+ * @title: 单个商品的税费
+ * @description:
+ * 单个商品的税费 = 商品销售单价（折扣后） * 税率 * is_charge_tax /( 1+ 税率 * is_price_include_tax)
+ * $taxFee = $price * $taxRate * $isChargeTax / (1 + $taxRate * $isPriceIncludeTax);
+ * @return {*}
+ * @Author: xiangfeng.xue
+ */
+export declare const calculateTaxFee: (shopInfo: any, items: CartItem[]) => Decimal | "0.00";