@pisell/pisellos 0.0.401 → 0.0.403

package/dist/modules/Product/index.d.ts

@@ -49,5 +49,5 @@ export declare class Product extends BaseModule implements Module {
     getCategories(): ProductCategory[];
     setOtherParams(key: string, value: any): void;
     getOtherParams(): any;
-    getProductType(): "duration" | "session" | "normal";
+    getProductType(): "normal" | "duration" | "session";
 }

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

@@ -22,4 +22,6 @@ export declare class SummaryModule extends BaseModule implements Module, ISummar
      */
     getProtocol(protocolId: string): Promise<any>;
     storeChange(): void;
+    private getTaxforUtils;
+    private getSurchargeforUtils;
 }

package/dist/modules/Summary/index.js

@@ -16,7 +16,8 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { BaseModule } from "../BaseModule";
-import { calculatePriceDetails } from "./utils";
+import { ScheduleModule } from "../Schedule";
+import { calculatePriceDetails, getSurcharge, getTax } from "./utils";
 export var SummaryModule = /*#__PURE__*/function (_BaseModule) {
   _inherits(SummaryModule, _BaseModule);
   var _super = _createSuper(SummaryModule);
@@ -165,6 +166,43 @@ export var SummaryModule = /*#__PURE__*/function (_BaseModule) {
         });
       }
     }
+  }, {
+    key: "getTaxforUtils",
+    value: function getTaxforUtils(items, shopInfo, subtotal) {
+      return getTax({
+        service: items,
+        bookingDetail: null,
+        bookingId: undefined
+      }, {
+        computed: {
+          productExpectAmount: subtotal.toNumber(),
+          shopDiscount: 0
+        },
+        isEdit: false,
+        tax_rate: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.tax_rate,
+        is_price_include_tax: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.is_price_include_tax
+      });
+    }
+  }, {
+    key: "getSurchargeforUtils",
+    value: function getSurchargeforUtils(items) {
+      var surchargeList = this.store.surchargeList;
+      var surchargeAmount = getSurcharge({
+        service: items,
+        addons: [],
+        bookingDetail: null,
+        bookingId: undefined
+      }, {
+        isEdit: false,
+        isInScheduleByDate: ScheduleModule.isInScheduleByDate,
+        surcharge_list: surchargeList,
+        scheduleById: {}
+      });
+      return {
+        surchargeList: surchargeList,
+        surchargeAmount: surchargeAmount
+      };
+    }
   }]);
   return SummaryModule;
 }(BaseModule);

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

@@ -7,6 +7,49 @@ export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[], i
  * @param item
  */
 export declare const getBundleDiscountList: (bundle: any[]) => any[];
+/**
+ * 计算订单税费（折扣前/折扣后），并把单品税费信息回写到商品数据上（用于明细展示/后续计算）。
+ *
+ * - **折扣前税费**：`originTax`
+ * - **折扣后税费**：`tax`（会考虑 `computed.shopDiscount` 对每个商品的分摊影响）
+ * - **税率/是否含税**：优先取 `bookingDetail.tax_rate` / `bookingDetail.is_price_include_tax`，取不到再回退到 `options.tax_rate` / `options.is_price_include_tax`
+ *
+ * **副作用（会修改入参商品对象）**：
+ * - 主商品：写入 `item.original_tax_fee` / `item.tax_fee`（四舍五入保留两位）
+ * - bundle 原价子商品：写入 `bundleItem.original_tax_fee` / `bundleItem.tax_fee`
+ * - 加时商品（`relation_details`）：写入 `atItem.tax_fee`
+ * - 税费舍入差值：追加到最后一个“含税商品”的 `tax_fee_rounding_remainder` / `original_tax_fee_rounding_remainder`
+ *
+ * @param params 入参集合（RORO）
+ * @param params.service 服务商品数组（主商品）。通常是购物车商品结构（可能包含 `bundle` / `relation_details`）
+ * @param params.addons 附加商品数组（可选）。结构同商品数组
+ * @param params.bookingDetail 订单详情（编辑/详情场景用于读取后端税率配置），可选
+ * @param params.bookingId 订单/预约 ID（编辑/详情场景识别用），可选
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。当前实现不强依赖该值（历史逻辑保留），但建议按真实状态传入
+ * @param options.computed 预计算结果（用于折扣分摊）
+ * @param options.computed.productExpectAmount 商品期望总金额（用于按比例分摊折扣）
+ * @param options.computed.shopDiscount 店铺折扣总额（用于按比例分摊到商品）
+ * @param options.tax_rate 管理端税率（百分比，如 5 表示 5%）。仅当 `bookingDetail.tax_rate` 不存在时生效
+ * @param options.is_price_include_tax 是否含税：`0` 不含税、`1` 含税。仅当 `bookingDetail.is_price_include_tax` 不存在时生效
+ * @returns 税费汇总（number，金额单位与商品价格一致，四舍五入保留两位）
+ * @returns.originTax 折扣前税费合计
+ * @returns.tax 折扣后税费合计
+ */
+export declare const getTax: ({ service, addons, bookingDetail, bookingId }: {
+    service?: any;
+    addons?: any;
+    bookingDetail?: any;
+    bookingId?: number | undefined;
+}, options: {
+    isEdit: boolean;
+    computed: Record<string, number>;
+    tax_rate?: number;
+    is_price_include_tax?: number;
+} & Record<string, any>) => {
+    originTax: number;
+    tax: number;
+};
 /**
  * 计算商品小计（不含其他费用）
  * @param items - 购物车商品数组
@@ -38,14 +81,52 @@ export declare const calculateDeposit: (items: CartItem[]) => {
     protocols: any[];
     hasDeposit: never;
 } | undefined;
+/**
+ * 计算订单附加费金额（订单级别合计）。
+ *
+ * - **详情未编辑**（`!options.isEdit && bookingId`）且存在后端详情时：直接返回 `bookingDetail.surcharge_fee`
+ * - **新增/编辑**时：对 `surcharge`（通常为 `getSurcharge` 的返回值）按 `item.value` 求和
+ *
+ * @param params 入参集合（RORO）
+ * @param params.bookingDetail 订单详情（详情未编辑时用于读取后端的 `surcharge_fee`），可选
+ * @param params.bookingId 订单/预约 ID（详情未编辑时生效），可选
+ * @param surcharge 附加费列表（通常来自 `getSurcharge`），元素结构至少包含 `value: number`
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。`false` 时会优先走后端金额直取逻辑（若存在）
+ * @returns 订单附加费金额（number，金额单位与商品价格一致）
+ */
 export declare const getSurchargeAmount: ({ bookingDetail, bookingId }: {
     bookingDetail?: any;
     bookingId?: number | undefined;
 }, surcharge: any[], options: any) => any;
 /**
  * 订单附加费各项信息
- * @param state
- * @param options 包含 ScheduleModule 和其他附加费计算所需参数
+ *
+ * - **详情未编辑**（`!options.isEdit && bookingId`）时：直接返回 `bookingDetail.surcharge`（后端计算结果）
+ * - **新增/编辑**时：按 `options.surcharge_list` 逐条配置计算本次订单的附加费
+ *
+ * 规则要点：
+ * - 匹配范围包含：主商品（`service`）、原价 bundle 子商品（`item.bundle`）、加时商品（`item.relation_details`）、以及 addons（`addons.value`）
+ * - 固定附加费 `fixed`：只加一次，再按商品数量分摊（向下取整保留两位），剩余小数会以 `surcharge_rounding_remainder` 形式抹平到最后一个商品
+ * - 百分比附加费 `percentage`：按每个商品（价格 * 数量）分别计算再累加
+ * - 当 `open_product === 0`：不回写到商品，只在订单级别累加；否则会把单品附加费回写到商品
+ *
+ * **副作用（可能修改入参商品对象）**：
+ * - 当 `open_product !== 0` 时：写入 `item.surcharge_fee`（单品单数量附加费，保留两位、向下取整）
+ * - 写入 `item.relation_surcharge_ids`（关联到的 surcharge 配置 id 列表）
+ * - 写入 `item.surcharge_rounding_remainder`（用于抹平固定附加费/总额舍入差）
+ *
+ * @param params 入参集合（RORO）
+ * @param params.service 服务商品数组（主商品）。元素可能包含 `bundle` / `relation_details`
+ * @param params.addons 附加商品容器。当前实现读取 `addons.value` 作为商品数组（所以通常传 `{ value: CartItem[] }`）
+ * @param params.bookingDetail 订单详情（详情未编辑时用于直接取后端的 surcharge 列表），可选
+ * @param params.bookingId 订单/预约 ID（详情未编辑时生效），可选
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。`false` 且存在 `bookingId` 时会走详情直取逻辑
+ * @param options.surcharge_list 附加费配置列表（后端下发）。缺失/为空则返回空数组
+ * @param options.isInScheduleByDate 判断日期是否落在某个 schedule 内的方法（通常来自 ScheduleModule）
+ * @param options.scheduleById schedule 映射表：`{ [scheduleId]: schedule }`（用于根据配置的 `available_schedule_ids` 做日程匹配）
+ * @returns 附加费列表（仅返回金额 > 0 的项）
  */
 export declare const getSurcharge: ({ service, addons, bookingDetail, bookingId }: {
     service: any;

package/dist/modules/Summary/utils.js

@@ -20,14 +20,6 @@ export var calculatePriceDetails = function calculatePriceDetails(shopInfo, item
   var subtotal = new Decimal(calculateSubtotal(items));
   var subOriginTotal = new Decimal(calculateOriginSubtotal(items));
   var totalTaxFee = new Decimal(calculateTaxFee(shopInfo, items));
-  // 税费
-  // const { tax, originTax } = getTax({ service: items, bookingDetail: null, bookingId: undefined }, {
-  //   computed: {
-  //     productExpectAmount: subtotal.toNumber(),
-  //     shopDiscount: 0,
-  //   },
-  //   isEdit: false,
-  // });
   // 订单附加费列表
   var surcharge = getSurcharge({
     service: items,
@@ -47,9 +39,23 @@ export var calculatePriceDetails = function calculatePriceDetails(shopInfo, item
   }, surcharge, {
     isEdit: false
   }));
-
-  // 计算总价
-  var total = shopInfo !== null && shopInfo !== void 0 && shopInfo.is_price_include_tax ? subtotal : subtotal.plus(totalTaxFee).plus(surchargeAmount);
+  // 税费
+  var _getTax = getTax({
+      service: items,
+      bookingDetail: null,
+      bookingId: undefined
+    }, {
+      computed: {
+        productExpectAmount: subtotal.toNumber(),
+        shopDiscount: 0
+      },
+      isEdit: false,
+      tax_rate: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.tax_rate,
+      is_price_include_tax: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.is_price_include_tax
+    }),
+    tax = _getTax.tax,
+    originTax = _getTax.originTax;
+  var total = shopInfo !== null && shopInfo !== void 0 && shopInfo.is_price_include_tax ? subtotal.plus(surchargeAmount) : subtotal.plus(totalTaxFee).plus(surchargeAmount);
 
   // 计算总价 不包含折扣卡商品券折扣信息价格
   var originTotal = shopInfo !== null && shopInfo !== void 0 && shopInfo.is_price_include_tax ? subOriginTotal : subOriginTotal.plus(totalTaxFee);
@@ -62,7 +68,7 @@ export var calculatePriceDetails = function calculatePriceDetails(shopInfo, item
     originTotal: originTotal.toFixed(2),
     taxTitle: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.tax_title,
     taxRate: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.tax_rate,
-    totalTaxFee: totalTaxFee.toFixed(2),
+    totalTaxFee: tax,
     isPriceIncludeTax: shopInfo === null || shopInfo === void 0 ? void 0 : shopInfo.is_price_include_tax,
     surcharge: surcharge,
     surchargeAmount: surchargeAmount.toFixed(2),
@@ -99,12 +105,35 @@ var getProductDiscountProductDiscountDifference = function getProductDiscountPro
 };
 
 /**
- * 税费
- * @param state
- * @param options 包含 isEdit、computed 和其他税费计算所需参数
- * @returns
+ * 计算订单税费（折扣前/折扣后），并把单品税费信息回写到商品数据上（用于明细展示/后续计算）。
+ *
+ * - **折扣前税费**：`originTax`
+ * - **折扣后税费**：`tax`（会考虑 `computed.shopDiscount` 对每个商品的分摊影响）
+ * - **税率/是否含税**：优先取 `bookingDetail.tax_rate` / `bookingDetail.is_price_include_tax`，取不到再回退到 `options.tax_rate` / `options.is_price_include_tax`
+ *
+ * **副作用（会修改入参商品对象）**：
+ * - 主商品：写入 `item.original_tax_fee` / `item.tax_fee`（四舍五入保留两位）
+ * - bundle 原价子商品：写入 `bundleItem.original_tax_fee` / `bundleItem.tax_fee`
+ * - 加时商品（`relation_details`）：写入 `atItem.tax_fee`
+ * - 税费舍入差值：追加到最后一个“含税商品”的 `tax_fee_rounding_remainder` / `original_tax_fee_rounding_remainder`
+ *
+ * @param params 入参集合（RORO）
+ * @param params.service 服务商品数组（主商品）。通常是购物车商品结构（可能包含 `bundle` / `relation_details`）
+ * @param params.addons 附加商品数组（可选）。结构同商品数组
+ * @param params.bookingDetail 订单详情（编辑/详情场景用于读取后端税率配置），可选
+ * @param params.bookingId 订单/预约 ID（编辑/详情场景识别用），可选
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。当前实现不强依赖该值（历史逻辑保留），但建议按真实状态传入
+ * @param options.computed 预计算结果（用于折扣分摊）
+ * @param options.computed.productExpectAmount 商品期望总金额（用于按比例分摊折扣）
+ * @param options.computed.shopDiscount 店铺折扣总额（用于按比例分摊到商品）
+ * @param options.tax_rate 管理端税率（百分比，如 5 表示 5%）。仅当 `bookingDetail.tax_rate` 不存在时生效
+ * @param options.is_price_include_tax 是否含税：`0` 不含税、`1` 含税。仅当 `bookingDetail.is_price_include_tax` 不存在时生效
+ * @returns 税费汇总（number，金额单位与商品价格一致，四舍五入保留两位）
+ * @returns.originTax 折扣前税费合计
+ * @returns.tax 折扣后税费合计
  */
-var getTax = function getTax(_ref, options) {
+export var getTax = function getTax(_ref, options) {
   var service = _ref.service,
     addons = _ref.addons,
     bookingDetail = _ref.bookingDetail,
@@ -115,11 +144,10 @@ var getTax = function getTax(_ref, options) {
     is_price_include_tax = options.is_price_include_tax;
 
   // 详情时未编辑的状态下, 取后端的值
-  if (!isEdit) {
-    return {
-      tax: Number(bookingDetail === null || bookingDetail === void 0 ? void 0 : bookingDetail.tax_fee) || 0
-    };
-  }
+  // if (!isEdit) {
+  //   return { tax: Number(bookingDetail?.tax_fee) || 0 };
+  // }
+
   var totalOriginTax = new Decimal(0);
   var totalTax = new Decimal(0);
   if (service || addons) {
@@ -191,7 +219,6 @@ var processItemsTax = function processItemsTax(items, _ref2, options) {
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _item$_extend$other;
       var item = _step.value;
       var quantity = new Decimal(item.num || 1);
       var unitPrice = new Decimal(item.total || 0);
@@ -301,8 +328,8 @@ var processItemsTax = function processItemsTax(items, _ref2, options) {
       var bundlePreciseTax = new Decimal(0);
       var bundleRoundedOriginTax = new Decimal(0);
       var bundleRoundedTax = new Decimal(0);
-      if (Array.isArray((_item$_extend$other = item._extend.other) === null || _item$_extend$other === void 0 ? void 0 : _item$_extend$other.bundle)) {
-        var _iterator3 = _createForOfIteratorHelper(item._extend.other.bundle),
+      if (Array.isArray(item === null || item === void 0 ? void 0 : item.bundle)) {
+        var _iterator3 = _createForOfIteratorHelper(item === null || item === void 0 ? void 0 : item.bundle),
           _step3;
         try {
           for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
@@ -375,7 +402,6 @@ var processItemsTax = function processItemsTax(items, _ref2, options) {
           _iterator3.f();
         }
       }
-
       // 主商品的原始税费和折后税费（精确值）
       var originalTaxFeePrecise = originalTaxPerItemPrecise.plus(bundlePreciseOriginTax);
       var taxFeePrecise = maxDiscountedTaxPerItemPrecise.plus(bundlePreciseTax);
@@ -419,7 +445,7 @@ var processItemsTax = function processItemsTax(items, _ref2, options) {
     }
     if (taxRemainder !== 0) {
       if (lastTaxableItem.type === 'main') {
-        lastTaxableItem.item._extend.tax_fee_rounding_remainder = taxRemainder;
+        lastTaxableItem.item.tax_fee_rounding_remainder = taxRemainder;
       } else {
         lastTaxableItem.item.tax_fee_rounding_remainder = taxRemainder;
       }
@@ -582,7 +608,20 @@ export var calculateDeposit = function calculateDeposit(items) {
   return undefined;
 };
 
-// 订单附加费
+/**
+ * 计算订单附加费金额（订单级别合计）。
+ *
+ * - **详情未编辑**（`!options.isEdit && bookingId`）且存在后端详情时：直接返回 `bookingDetail.surcharge_fee`
+ * - **新增/编辑**时：对 `surcharge`（通常为 `getSurcharge` 的返回值）按 `item.value` 求和
+ *
+ * @param params 入参集合（RORO）
+ * @param params.bookingDetail 订单详情（详情未编辑时用于读取后端的 `surcharge_fee`），可选
+ * @param params.bookingId 订单/预约 ID（详情未编辑时生效），可选
+ * @param surcharge 附加费列表（通常来自 `getSurcharge`），元素结构至少包含 `value: number`
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。`false` 时会优先走后端金额直取逻辑（若存在）
+ * @returns 订单附加费金额（number，金额单位与商品价格一致）
+ */
 export var getSurchargeAmount = function getSurchargeAmount(_ref6, surcharge, options) {
   var bookingDetail = _ref6.bookingDetail,
     bookingId = _ref6.bookingId;
@@ -745,8 +784,32 @@ var isProductMatchSurchargeCondition = function isProductMatchSurchargeCondition
 
 /**
  * 订单附加费各项信息
- * @param state
- * @param options 包含 ScheduleModule 和其他附加费计算所需参数
+ *
+ * - **详情未编辑**（`!options.isEdit && bookingId`）时：直接返回 `bookingDetail.surcharge`（后端计算结果）
+ * - **新增/编辑**时：按 `options.surcharge_list` 逐条配置计算本次订单的附加费
+ *
+ * 规则要点：
+ * - 匹配范围包含：主商品（`service`）、原价 bundle 子商品（`item.bundle`）、加时商品（`item.relation_details`）、以及 addons（`addons.value`）
+ * - 固定附加费 `fixed`：只加一次，再按商品数量分摊（向下取整保留两位），剩余小数会以 `surcharge_rounding_remainder` 形式抹平到最后一个商品
+ * - 百分比附加费 `percentage`：按每个商品（价格 * 数量）分别计算再累加
+ * - 当 `open_product === 0`：不回写到商品，只在订单级别累加；否则会把单品附加费回写到商品
+ *
+ * **副作用（可能修改入参商品对象）**：
+ * - 当 `open_product !== 0` 时：写入 `item.surcharge_fee`（单品单数量附加费，保留两位、向下取整）
+ * - 写入 `item.relation_surcharge_ids`（关联到的 surcharge 配置 id 列表）
+ * - 写入 `item.surcharge_rounding_remainder`（用于抹平固定附加费/总额舍入差）
+ *
+ * @param params 入参集合（RORO）
+ * @param params.service 服务商品数组（主商品）。元素可能包含 `bundle` / `relation_details`
+ * @param params.addons 附加商品容器。当前实现读取 `addons.value` 作为商品数组（所以通常传 `{ value: CartItem[] }`）
+ * @param params.bookingDetail 订单详情（详情未编辑时用于直接取后端的 surcharge 列表），可选
+ * @param params.bookingId 订单/预约 ID（详情未编辑时生效），可选
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。`false` 且存在 `bookingId` 时会走详情直取逻辑
+ * @param options.surcharge_list 附加费配置列表（后端下发）。缺失/为空则返回空数组
+ * @param options.isInScheduleByDate 判断日期是否落在某个 schedule 内的方法（通常来自 ScheduleModule）
+ * @param options.scheduleById schedule 映射表：`{ [scheduleId]: schedule }`（用于根据配置的 `available_schedule_ids` 做日程匹配）
+ * @returns 附加费列表（仅返回金额 > 0 的项）
  */
 export var getSurcharge = function getSurcharge(_ref10, options) {
   var service = _ref10.service,
@@ -988,7 +1051,6 @@ export var getSurcharge = function getSurcharge(_ref10, options) {
             var fixedSurcharge = new Decimal(1).div(productCount).times(fixed).times(100).floor().div(100).toFixed(2);
             var quantity = _item2.isMain ? _item2.quantity : _item2.quantity * _item2.mainQuantity;
             fixedTotal = fixedTotal.plus(new Decimal(fixedSurcharge).times(quantity).toNumber());
-
             // 如果是最后一个商品 判断fixed - fixedTotal 是否有剩余小数 如果有的话，追加抹平字段
             if (isLast && fixedTotal.gt(0)) {
               var remaining = new Decimal(fixed).minus(fixedTotal).toNumber();

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

@@ -49,5 +49,5 @@ export declare class Product extends BaseModule implements Module {
     getCategories(): ProductCategory[];
     setOtherParams(key: string, value: any): void;
     getOtherParams(): any;
-    getProductType(): "duration" | "session" | "normal";
+    getProductType(): "normal" | "duration" | "session";
 }

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

@@ -22,4 +22,6 @@ export declare class SummaryModule extends BaseModule implements Module, ISummar
      */
     getProtocol(protocolId: string): Promise<any>;
     storeChange(): void;
+    private getTaxforUtils;
+    private getSurchargeforUtils;
 }

package/lib/modules/Summary/index.js

@@ -23,6 +23,7 @@ __export(Summary_exports, {
 });
 module.exports = __toCommonJS(Summary_exports);
 var import_BaseModule = require("../BaseModule");
+var import_Schedule = require("../Schedule");
 var import_utils = require("./utils");
 var SummaryModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
@@ -87,6 +88,25 @@ var SummaryModule = class extends import_BaseModule.BaseModule {
       });
     }
   }
+  getTaxforUtils(items, shopInfo, subtotal) {
+    return (0, import_utils.getTax)({ service: items, bookingDetail: null, bookingId: void 0 }, {
+      computed: {
+        productExpectAmount: subtotal.toNumber(),
+        shopDiscount: 0
+      },
+      isEdit: false,
+      tax_rate: shopInfo == null ? void 0 : shopInfo.tax_rate,
+      is_price_include_tax: shopInfo == null ? void 0 : shopInfo.is_price_include_tax
+    });
+  }
+  getSurchargeforUtils(items) {
+    const surchargeList = this.store.surchargeList;
+    const surchargeAmount = (0, import_utils.getSurcharge)({ service: items, addons: [], bookingDetail: null, bookingId: void 0 }, { isEdit: false, isInScheduleByDate: import_Schedule.ScheduleModule.isInScheduleByDate, surcharge_list: surchargeList, scheduleById: {} });
+    return {
+      surchargeList,
+      surchargeAmount
+    };
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -7,6 +7,49 @@ export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[], i
  * @param item
  */
 export declare const getBundleDiscountList: (bundle: any[]) => any[];
+/**
+ * 计算订单税费（折扣前/折扣后），并把单品税费信息回写到商品数据上（用于明细展示/后续计算）。
+ *
+ * - **折扣前税费**：`originTax`
+ * - **折扣后税费**：`tax`（会考虑 `computed.shopDiscount` 对每个商品的分摊影响）
+ * - **税率/是否含税**：优先取 `bookingDetail.tax_rate` / `bookingDetail.is_price_include_tax`，取不到再回退到 `options.tax_rate` / `options.is_price_include_tax`
+ *
+ * **副作用（会修改入参商品对象）**：
+ * - 主商品：写入 `item.original_tax_fee` / `item.tax_fee`（四舍五入保留两位）
+ * - bundle 原价子商品：写入 `bundleItem.original_tax_fee` / `bundleItem.tax_fee`
+ * - 加时商品（`relation_details`）：写入 `atItem.tax_fee`
+ * - 税费舍入差值：追加到最后一个“含税商品”的 `tax_fee_rounding_remainder` / `original_tax_fee_rounding_remainder`
+ *
+ * @param params 入参集合（RORO）
+ * @param params.service 服务商品数组（主商品）。通常是购物车商品结构（可能包含 `bundle` / `relation_details`）
+ * @param params.addons 附加商品数组（可选）。结构同商品数组
+ * @param params.bookingDetail 订单详情（编辑/详情场景用于读取后端税率配置），可选
+ * @param params.bookingId 订单/预约 ID（编辑/详情场景识别用），可选
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。当前实现不强依赖该值（历史逻辑保留），但建议按真实状态传入
+ * @param options.computed 预计算结果（用于折扣分摊）
+ * @param options.computed.productExpectAmount 商品期望总金额（用于按比例分摊折扣）
+ * @param options.computed.shopDiscount 店铺折扣总额（用于按比例分摊到商品）
+ * @param options.tax_rate 管理端税率（百分比，如 5 表示 5%）。仅当 `bookingDetail.tax_rate` 不存在时生效
+ * @param options.is_price_include_tax 是否含税：`0` 不含税、`1` 含税。仅当 `bookingDetail.is_price_include_tax` 不存在时生效
+ * @returns 税费汇总（number，金额单位与商品价格一致，四舍五入保留两位）
+ * @returns.originTax 折扣前税费合计
+ * @returns.tax 折扣后税费合计
+ */
+export declare const getTax: ({ service, addons, bookingDetail, bookingId }: {
+    service?: any;
+    addons?: any;
+    bookingDetail?: any;
+    bookingId?: number | undefined;
+}, options: {
+    isEdit: boolean;
+    computed: Record<string, number>;
+    tax_rate?: number;
+    is_price_include_tax?: number;
+} & Record<string, any>) => {
+    originTax: number;
+    tax: number;
+};
 /**
  * 计算商品小计（不含其他费用）
  * @param items - 购物车商品数组
@@ -38,14 +81,52 @@ export declare const calculateDeposit: (items: CartItem[]) => {
     protocols: any[];
     hasDeposit: never;
 } | undefined;
+/**
+ * 计算订单附加费金额（订单级别合计）。
+ *
+ * - **详情未编辑**（`!options.isEdit && bookingId`）且存在后端详情时：直接返回 `bookingDetail.surcharge_fee`
+ * - **新增/编辑**时：对 `surcharge`（通常为 `getSurcharge` 的返回值）按 `item.value` 求和
+ *
+ * @param params 入参集合（RORO）
+ * @param params.bookingDetail 订单详情（详情未编辑时用于读取后端的 `surcharge_fee`），可选
+ * @param params.bookingId 订单/预约 ID（详情未编辑时生效），可选
+ * @param surcharge 附加费列表（通常来自 `getSurcharge`），元素结构至少包含 `value: number`
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。`false` 时会优先走后端金额直取逻辑（若存在）
+ * @returns 订单附加费金额（number，金额单位与商品价格一致）
+ */
 export declare const getSurchargeAmount: ({ bookingDetail, bookingId }: {
     bookingDetail?: any;
     bookingId?: number | undefined;
 }, surcharge: any[], options: any) => any;
 /**
  * 订单附加费各项信息
- * @param state
- * @param options 包含 ScheduleModule 和其他附加费计算所需参数
+ *
+ * - **详情未编辑**（`!options.isEdit && bookingId`）时：直接返回 `bookingDetail.surcharge`（后端计算结果）
+ * - **新增/编辑**时：按 `options.surcharge_list` 逐条配置计算本次订单的附加费
+ *
+ * 规则要点：
+ * - 匹配范围包含：主商品（`service`）、原价 bundle 子商品（`item.bundle`）、加时商品（`item.relation_details`）、以及 addons（`addons.value`）
+ * - 固定附加费 `fixed`：只加一次，再按商品数量分摊（向下取整保留两位），剩余小数会以 `surcharge_rounding_remainder` 形式抹平到最后一个商品
+ * - 百分比附加费 `percentage`：按每个商品（价格 * 数量）分别计算再累加
+ * - 当 `open_product === 0`：不回写到商品，只在订单级别累加；否则会把单品附加费回写到商品
+ *
+ * **副作用（可能修改入参商品对象）**：
+ * - 当 `open_product !== 0` 时：写入 `item.surcharge_fee`（单品单数量附加费，保留两位、向下取整）
+ * - 写入 `item.relation_surcharge_ids`（关联到的 surcharge 配置 id 列表）
+ * - 写入 `item.surcharge_rounding_remainder`（用于抹平固定附加费/总额舍入差）
+ *
+ * @param params 入参集合（RORO）
+ * @param params.service 服务商品数组（主商品）。元素可能包含 `bundle` / `relation_details`
+ * @param params.addons 附加商品容器。当前实现读取 `addons.value` 作为商品数组（所以通常传 `{ value: CartItem[] }`）
+ * @param params.bookingDetail 订单详情（详情未编辑时用于直接取后端的 surcharge 列表），可选
+ * @param params.bookingId 订单/预约 ID（详情未编辑时生效），可选
+ * @param options 计算选项
+ * @param options.isEdit 是否处于“编辑中”。`false` 且存在 `bookingId` 时会走详情直取逻辑
+ * @param options.surcharge_list 附加费配置列表（后端下发）。缺失/为空则返回空数组
+ * @param options.isInScheduleByDate 判断日期是否落在某个 schedule 内的方法（通常来自 ScheduleModule）
+ * @param options.scheduleById schedule 映射表：`{ [scheduleId]: schedule }`（用于根据配置的 `available_schedule_ids` 做日程匹配）
+ * @returns 附加费列表（仅返回金额 > 0 的项）
  */
 export declare const getSurcharge: ({ service, addons, bookingDetail, bookingId }: {
     service: any;

package/lib/modules/Summary/utils.js

@@ -36,7 +36,8 @@ __export(utils_exports, {
   calculateTaxFee: () => calculateTaxFee,
   getBundleDiscountList: () => getBundleDiscountList,
   getSurcharge: () => getSurcharge,
-  getSurchargeAmount: () => getSurchargeAmount
+  getSurchargeAmount: () => getSurchargeAmount,
+  getTax: () => getTax
 });
 module.exports = __toCommonJS(utils_exports);
 var import_decimal = __toESM(require("decimal.js"));
@@ -46,7 +47,16 @@ var calculatePriceDetails = (shopInfo, items, isInScheduleByDate, surchargeList)
   const totalTaxFee = new import_decimal.default(calculateTaxFee(shopInfo, items));
   const surcharge = getSurcharge({ service: items, addons: [], bookingDetail: null, bookingId: void 0 }, { isEdit: false, isInScheduleByDate, surcharge_list: surchargeList, scheduleById: {} });
   const surchargeAmount = new import_decimal.default(getSurchargeAmount({ bookingDetail: null, bookingId: void 0 }, surcharge, { isEdit: false }));
-  const total = (shopInfo == null ? void 0 : shopInfo.is_price_include_tax) ? subtotal : subtotal.plus(totalTaxFee).plus(surchargeAmount);
+  const { tax, originTax } = getTax({ service: items, bookingDetail: null, bookingId: void 0 }, {
+    computed: {
+      productExpectAmount: subtotal.toNumber(),
+      shopDiscount: 0
+    },
+    isEdit: false,
+    tax_rate: shopInfo == null ? void 0 : shopInfo.tax_rate,
+    is_price_include_tax: shopInfo == null ? void 0 : shopInfo.is_price_include_tax
+  });
+  const total = (shopInfo == null ? void 0 : shopInfo.is_price_include_tax) ? subtotal.plus(surchargeAmount) : subtotal.plus(totalTaxFee).plus(surchargeAmount);
   const originTotal = (shopInfo == null ? void 0 : shopInfo.is_price_include_tax) ? subOriginTotal : subOriginTotal.plus(totalTaxFee);
   const deposit = calculateDeposit(items);
   return {
@@ -55,7 +65,7 @@ var calculatePriceDetails = (shopInfo, items, isInScheduleByDate, surchargeList)
     originTotal: originTotal.toFixed(2),
     taxTitle: shopInfo == null ? void 0 : shopInfo.tax_title,
     taxRate: shopInfo == null ? void 0 : shopInfo.tax_rate,
-    totalTaxFee: totalTaxFee.toFixed(2),
+    totalTaxFee: tax,
     isPriceIncludeTax: shopInfo == null ? void 0 : shopInfo.is_price_include_tax,
     surcharge,
     surchargeAmount: surchargeAmount.toFixed(2),
@@ -83,6 +93,221 @@ var getProductDiscountProductDiscountDifference = (item) => {
     return pre + (cur.metadata.product_discount_difference || 0);
   }, 0);
 };
+var getTax = ({ service, addons, bookingDetail, bookingId }, options) => {
+  const { isEdit, computed, tax_rate, is_price_include_tax } = options;
+  let totalOriginTax = new import_decimal.default(0);
+  let totalTax = new import_decimal.default(0);
+  if (service || addons) {
+    if (service == null ? void 0 : service.length) {
+      const serviceResult = processItemsTax(service, { bookingDetail, bookingId }, {
+        tax_rate,
+        is_price_include_tax,
+        computed
+      });
+      totalOriginTax = totalOriginTax.plus(serviceResult.originTax);
+      totalTax = totalTax.plus(serviceResult.tax);
+    }
+    if (addons == null ? void 0 : addons.length) {
+      const addonsResult = processItemsTax(addons, { bookingDetail, bookingId }, {
+        tax_rate,
+        is_price_include_tax,
+        computed
+      });
+      totalOriginTax = totalOriginTax.plus(addonsResult.originTax);
+      totalTax = totalTax.plus(addonsResult.tax);
+    }
+  }
+  return {
+    originTax: totalOriginTax.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber(),
+    tax: totalTax.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber()
+  };
+};
+var processItemsTax = (items, { bookingDetail, bookingId }, options) => {
+  const { tax_rate, is_price_include_tax, computed } = options;
+  const { shopDiscount, productExpectAmount } = computed;
+  let preciseOriginTax = new import_decimal.default(0);
+  let preciseTax = new import_decimal.default(0);
+  let roundedOriginTax = new import_decimal.default(0);
+  let roundedTax = new import_decimal.default(0);
+  let lastTaxableItem = null;
+  for (let item of items) {
+    const quantity = new import_decimal.default(item.num || 1);
+    const unitPrice = new import_decimal.default(item.total || 0);
+    const mainProductPrice = new import_decimal.default(getMainProductTotal(item) || 0);
+    let originalTaxPerItemPrecise = getProductItemTax(
+      {
+        ...item,
+        total: mainProductPrice.add((item == null ? void 0 : item.surcharge_fee) || 0).toNumber(),
+        quantity: 1
+      },
+      { bookingDetail, bookingId },
+      { tax_rate, is_price_include_tax }
+    );
+    let itemDiscount = new import_decimal.default(0);
+    if (productExpectAmount > 0) {
+      itemDiscount = unitPrice.dividedBy(productExpectAmount).times(shopDiscount);
+    }
+    let mainItemDiscount = new import_decimal.default(0);
+    if (unitPrice.greaterThan(0)) {
+      mainItemDiscount = mainProductPrice.dividedBy(productExpectAmount).times(shopDiscount);
+    }
+    const mainItemDiscountedUnitPrice = mainProductPrice.minus(mainItemDiscount).add((item == null ? void 0 : item.surcharge_fee) || 0);
+    const maxDiscountedTaxPerItemPrecise = getProductItemTax(
+      {
+        ...item,
+        total: mainItemDiscountedUnitPrice.toNumber(),
+        price: item.total,
+        quantity: 1
+      },
+      { bookingDetail, bookingId },
+      { tax_rate, is_price_include_tax }
+    );
+    const maxDiscountedTaxPerItemRounded = maxDiscountedTaxPerItemPrecise.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
+    item.main_product_attached_bundle_tax_fee = maxDiscountedTaxPerItemRounded.toNumber();
+    if (maxDiscountedTaxPerItemPrecise.gt(0)) {
+      lastTaxableItem = { type: "main", item };
+    }
+    let addTimePreciseTax = new import_decimal.default(0);
+    let addTimeRoundedTax = new import_decimal.default(0);
+    if (Array.isArray(item.relation_details)) {
+      for (let atItem of item.relation_details) {
+        const _originTotal = new import_decimal.default(
+          atItem.selling_price || atItem.price || 0
+        );
+        let _discountedTotal = _originTotal;
+        if (productExpectAmount > 0) {
+          _discountedTotal = _originTotal.minus(
+            _originTotal.dividedBy(productExpectAmount).times(shopDiscount)
+          );
+        }
+        const addTimeTaxPerItemPrecise = getProductItemTax(
+          {
+            ...atItem,
+            total: _discountedTotal.add((atItem == null ? void 0 : atItem.surcharge_fee) || 0).toNumber(),
+            quantity: atItem.product_quantity || atItem.num || 1
+          },
+          { bookingDetail, bookingId },
+          { tax_rate, is_price_include_tax }
+        );
+        const addTimeTaxPerItemRounded = addTimeTaxPerItemPrecise.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
+        atItem.tax_fee = addTimeTaxPerItemRounded.toNumber();
+        addTimePreciseTax = addTimePreciseTax.plus(addTimeTaxPerItemPrecise);
+        addTimeRoundedTax = addTimeRoundedTax.plus(addTimeTaxPerItemRounded);
+        if (addTimeTaxPerItemPrecise.gt(0)) {
+          lastTaxableItem = { type: "addTime", item: atItem };
+        }
+      }
+    }
+    let bundlePreciseOriginTax = new import_decimal.default(0);
+    let bundlePreciseTax = new import_decimal.default(0);
+    let bundleRoundedOriginTax = new import_decimal.default(0);
+    let bundleRoundedTax = new import_decimal.default(0);
+    if (Array.isArray(item == null ? void 0 : item.bundle)) {
+      for (let bundleItem of item == null ? void 0 : item.bundle) {
+        if (getBundleItemIsOriginalPrice(bundleItem)) {
+          const bundleQuantity = new import_decimal.default(bundleItem.quantity || 1);
+          const bundleUnitPrice = new import_decimal.default(
+            bundleItem.bundle_selling_price ?? bundleItem.price ?? 0
+          );
+          const bundleOriginalTaxPerItemPrecise = getProductItemTax(
+            {
+              ...bundleItem,
+              total: bundleUnitPrice.add((bundleItem == null ? void 0 : bundleItem.surcharge_fee) || 0).toNumber(),
+              quantity: 1
+            },
+            { bookingDetail, bookingId },
+            { tax_rate, is_price_include_tax }
+          );
+          let bundleItemDiscount = new import_decimal.default(0);
+          if (productExpectAmount > 0) {
+            bundleItemDiscount = bundleUnitPrice.dividedBy(productExpectAmount).times(shopDiscount);
+          }
+          const bundleDiscountedUnitPrice = bundleUnitPrice.minus(bundleItemDiscount).add((bundleItem == null ? void 0 : bundleItem.surcharge_fee) || 0);
+          const bundleDiscountedTaxPerItemPrecise = getProductItemTax(
+            {
+              ...bundleItem,
+              total: bundleDiscountedUnitPrice.toNumber(),
+              quantity: 1
+            },
+            { bookingDetail, bookingId },
+            { tax_rate, is_price_include_tax }
+          );
+          const bundleOriginalTaxPerItemRounded = bundleOriginalTaxPerItemPrecise.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
+          const bundleDiscountedTaxPerItemRounded = bundleDiscountedTaxPerItemPrecise.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
+          bundleItem.original_tax_fee = bundleOriginalTaxPerItemRounded.toNumber();
+          bundleItem.tax_fee = bundleDiscountedTaxPerItemRounded.toNumber();
+          bundlePreciseOriginTax = bundlePreciseOriginTax.plus(bundleOriginalTaxPerItemPrecise.times(bundleQuantity));
+          bundlePreciseTax = bundlePreciseTax.plus(bundleDiscountedTaxPerItemPrecise.times(bundleQuantity));
+          bundleRoundedOriginTax = bundleRoundedOriginTax.plus(bundleOriginalTaxPerItemRounded.times(bundleQuantity));
+          bundleRoundedTax = bundleRoundedTax.plus(bundleDiscountedTaxPerItemRounded.times(bundleQuantity));
+          if (bundleDiscountedTaxPerItemPrecise.gt(0)) {
+            lastTaxableItem = { type: "bundle", item: bundleItem };
+          }
+        }
+      }
+    }
+    const originalTaxFeePrecise = originalTaxPerItemPrecise.plus(bundlePreciseOriginTax);
+    const taxFeePrecise = maxDiscountedTaxPerItemPrecise.plus(bundlePreciseTax);
+    const originalTaxFeeRounded = originalTaxPerItemPrecise.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).plus(bundleRoundedOriginTax);
+    const taxFeeRounded = maxDiscountedTaxPerItemRounded.plus(bundleRoundedTax);
+    item.original_tax_fee = originalTaxFeeRounded.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
+    item.tax_fee = taxFeeRounded.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
+    preciseOriginTax = preciseOriginTax.plus(originalTaxFeePrecise.times(quantity)).plus(addTimePreciseTax);
+    preciseTax = preciseTax.plus(taxFeePrecise.times(quantity)).plus(addTimePreciseTax);
+    roundedOriginTax = roundedOriginTax.plus(originalTaxFeeRounded.times(quantity)).plus(addTimeRoundedTax);
+    roundedTax = roundedTax.plus(taxFeeRounded.times(quantity)).plus(addTimeRoundedTax);
+  }
+  const expectedOriginTax = preciseOriginTax.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
+  const expectedTax = preciseTax.toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
+  const originTaxRemainder = expectedOriginTax.minus(roundedOriginTax).toNumber();
+  const taxRemainder = expectedTax.minus(roundedTax).toNumber();
+  if (lastTaxableItem) {
+    if (originTaxRemainder !== 0) {
+      if (lastTaxableItem.type === "main") {
+        lastTaxableItem.item.original_tax_fee_rounding_remainder = originTaxRemainder;
+      } else {
+        lastTaxableItem.item.original_tax_fee_rounding_remainder = originTaxRemainder;
+      }
+    }
+    if (taxRemainder !== 0) {
+      if (lastTaxableItem.type === "main") {
+        lastTaxableItem.item.tax_fee_rounding_remainder = taxRemainder;
+      } else {
+        lastTaxableItem.item.tax_fee_rounding_remainder = taxRemainder;
+      }
+    }
+  }
+  return { originTax: expectedOriginTax, tax: expectedTax };
+};
+var getProductItemTax = (item, state, options) => {
+  const { bookingDetail } = state;
+  const { tax_rate, is_price_include_tax } = options;
+  const productDiscountPrice = new import_decimal.default(item.total || 0);
+  const quantity = new import_decimal.default(item.num || 1);
+  if (productDiscountPrice.lte(0)) {
+    return new import_decimal.default(0);
+  }
+  const currentTaxRate = new import_decimal.default(
+    (bookingDetail == null ? void 0 : bookingDetail.tax_rate) ?? (tax_rate ? tax_rate / 100 : 0)
+  );
+  const currentIsPriceIncludeTax = (bookingDetail == null ? void 0 : bookingDetail.is_price_include_tax) ?? is_price_include_tax ?? 0;
+  let singleItemTax = new import_decimal.default(0);
+  if (item.is_charge_tax === 0 || !item.is_charge_tax) {
+    singleItemTax = new import_decimal.default(0);
+  } else {
+    if (currentIsPriceIncludeTax === 0) {
+      singleItemTax = productDiscountPrice.times(currentTaxRate);
+    } else {
+      const divisor = new import_decimal.default(1).plus(currentTaxRate);
+      if (divisor.lte(0)) {
+        singleItemTax = new import_decimal.default(0);
+      } else {
+        singleItemTax = productDiscountPrice.dividedBy(divisor).times(currentTaxRate);
+      }
+    }
+  }
+  return singleItemTax.times(quantity);
+};
 var calculateSubtotal = (items) => {
   if (!(items == null ? void 0 : items.length)) {
     return "0.00";
@@ -492,5 +717,6 @@ var getSurcharge = ({ service, addons, bookingDetail, bookingId }, options) => {
   calculateTaxFee,
   getBundleDiscountList,
   getSurcharge,
-  getSurchargeAmount
+  getSurchargeAmount,
+  getTax
 });

package/package.json

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