@pisell/pisellos 2.2.147 → 2.2.149

package/lib/modules/ScanOrderLogger/providers/feishu.js

@@ -0,0 +1,148 @@
+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/ScanOrderLogger/providers/feishu.ts
+var feishu_exports = {};
+__export(feishu_exports, {
+  feishuLoggerProvider: () => feishuLoggerProvider
+});
+module.exports = __toCommonJS(feishu_exports);
+var DEFAULT_THROTTLE_MS = 3e3;
+var pendingQueue = [];
+var flushTimer = null;
+var cachedProviderConfig;
+function safeStringify(value) {
+  if (value === void 0 || value === null)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    return `[unserializable: ${String(error)}]`;
+  }
+}
+function isWebhookUsable(webhook) {
+  if (!webhook)
+    return false;
+  if (webhook.includes("REPLACE_ME"))
+    return false;
+  return true;
+}
+function buildRecordSegments(record) {
+  const context = record.context || {};
+  return [
+    [{ tag: "text", text: `[${record.level}] ${record.timestamp} ${record.title}
+` }],
+    [{ tag: "text", text: `缓存标识: ${safeStringify(context.cacheId)}
+` }],
+    [{ tag: "text", text: `日志来源: ${safeStringify(context)}
+` }],
+    [{ tag: "text", text: `日志内容: ${safeStringify(record.payload)}
+` }],
+    [{ tag: "text", text: `扩展信息: ${safeStringify(record.extra)}
+` }],
+    [{ tag: "text", text: "------\n" }]
+  ];
+}
+function buildFeishuBody(records) {
+  const title = records.length === 1 ? records[0].title : `ScanOrder 日志批量 (${records.length} 条)`;
+  const content = [];
+  records.forEach((record) => {
+    buildRecordSegments(record).forEach((segment) => content.push(segment));
+  });
+  return JSON.stringify({
+    msg_type: "post",
+    content: JSON.stringify({
+      post: {
+        zh_cn: {
+          title,
+          content
+        }
+      }
+    })
+  });
+}
+async function postToFeishu(webhook, body) {
+  await fetch(webhook, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body
+  });
+}
+async function flushQueue() {
+  var _a;
+  flushTimer = null;
+  if (!pendingQueue.length)
+    return;
+  const records = pendingQueue.splice(0, pendingQueue.length);
+  const webhook = (_a = cachedProviderConfig == null ? void 0 : cachedProviderConfig.feishu) == null ? void 0 : _a.webhook;
+  if (!isWebhookUsable(webhook)) {
+    return;
+  }
+  if (typeof fetch !== "function") {
+    console.warn("[ScanOrderLogger] 当前环境不支持 fetch，跳过 Feishu 日志批量上报");
+    return;
+  }
+  try {
+    await postToFeishu(webhook, buildFeishuBody(records));
+  } catch (error) {
+    console.warn("[ScanOrderLogger] Feishu 批量上报失败", error);
+  }
+}
+var feishuLoggerProvider = {
+  async send(payload) {
+    var _a, _b, _c, _d;
+    cachedProviderConfig = payload.providerConfig;
+    const webhook = (_b = (_a = payload.providerConfig) == null ? void 0 : _a.feishu) == null ? void 0 : _b.webhook;
+    if (!webhook) {
+      console.warn("[ScanOrderLogger] Feishu webhook 未配置，跳过日志上报");
+      return;
+    }
+    if (!isWebhookUsable(webhook))
+      return;
+    if (typeof fetch !== "function") {
+      console.warn("[ScanOrderLogger] 当前环境不支持 fetch，跳过 Feishu 日志上报");
+      return;
+    }
+    const throttleMs = ((_d = (_c = payload.providerConfig) == null ? void 0 : _c.feishu) == null ? void 0 : _d.throttleMs) ?? DEFAULT_THROTTLE_MS;
+    if (throttleMs <= 0) {
+      try {
+        await postToFeishu(webhook, buildFeishuBody([payload.record]));
+      } catch (error) {
+        console.warn("[ScanOrderLogger] Feishu 日志上报失败", error);
+      }
+      return;
+    }
+    pendingQueue.push(payload.record);
+    if (!flushTimer) {
+      flushTimer = setTimeout(() => {
+        void flushQueue();
+      }, throttleMs);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  feishuLoggerProvider
+});

package/lib/modules/ScanOrderLogger/providers/grafana.d.ts

@@ -0,0 +1,2 @@
+import { ScanOrderLoggerProvider } from '../types';
+export declare const grafanaLoggerProvider: ScanOrderLoggerProvider;

package/lib/modules/ScanOrderLogger/providers/grafana.js

@@ -0,0 +1,52 @@
+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/ScanOrderLogger/providers/grafana.ts
+var grafana_exports = {};
+__export(grafana_exports, {
+  grafanaLoggerProvider: () => grafanaLoggerProvider
+});
+module.exports = __toCommonJS(grafana_exports);
+var grafanaLoggerProvider = {
+  async send(payload) {
+    var _a, _b, _c, _d;
+    const endpoint = (_b = (_a = payload.providerConfig) == null ? void 0 : _a.grafana) == null ? void 0 : _b.endpoint;
+    if (!endpoint) {
+      console.warn("[ScanOrderLogger] Grafana endpoint 未配置，跳过日志上报");
+      return;
+    }
+    if (typeof fetch !== "function") {
+      console.warn("[ScanOrderLogger] 当前环境不支持 fetch，跳过 Grafana 日志上报");
+      return;
+    }
+    await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...((_d = (_c = payload.providerConfig) == null ? void 0 : _c.grafana) == null ? void 0 : _d.headers) || {}
+      },
+      body: JSON.stringify({
+        record: payload.record
+      })
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  grafanaLoggerProvider
+});

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

@@ -0,0 +1,52 @@
+export type ScanOrderLogLevel = 'info' | 'warning' | 'error' | 'debug';
+export type ScanOrderLoggerProviderType = 'feishu' | 'grafana';
+export interface ScanOrderLoggerProviderFeishuConfig {
+    webhook?: string;
+    /**
+     * 节流窗口毫秒数，默认 3000ms
+     * - >0：首条日志进入队列并启动定时器，窗口结束后合并成一条 Feishu post 统一发送
+     * - <=0：关闭节流，保持每条日志立即单独发送
+     */
+    throttleMs?: number;
+}
+export interface ScanOrderLoggerProviderGrafanaConfig {
+    endpoint?: string;
+    headers?: Record<string, string>;
+}
+export interface ScanOrderLoggerProviderConfig {
+    feishu?: ScanOrderLoggerProviderFeishuConfig;
+    grafana?: ScanOrderLoggerProviderGrafanaConfig;
+}
+export interface ScanOrderLoggerContext {
+    cacheId?: string;
+    solutionName?: string;
+    moduleName?: string;
+    [key: string]: any;
+}
+export interface ScanOrderLogInput {
+    level?: ScanOrderLogLevel;
+    title: string;
+    payload?: Record<string, any>;
+    extra?: Record<string, any>;
+    timestamp?: string;
+}
+export interface ScanOrderLogRecord {
+    level: ScanOrderLogLevel;
+    title: string;
+    timestamp: string;
+    payload: Record<string, any>;
+    extra: Record<string, any>;
+    context: ScanOrderLoggerContext;
+}
+export interface ScanOrderLoggerDispatchPayload {
+    record: ScanOrderLogRecord;
+    providerConfig?: ScanOrderLoggerProviderConfig;
+}
+export interface ScanOrderLoggerProvider {
+    send: (payload: ScanOrderLoggerDispatchPayload) => Promise<void>;
+}
+export interface ScanOrderLoggerState {
+    provider: ScanOrderLoggerProviderType;
+    providerConfig: ScanOrderLoggerProviderConfig;
+    context: ScanOrderLoggerContext;
+}

package/lib/modules/ScanOrderLogger/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/ScanOrderLogger/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/modules/Schedule/getDateIsInSchedule.js

@@ -70,7 +70,7 @@ var isInStandardSchedule = (targetDate, targetDateString, targetTimeString, sche
   }
   const startDate = (0, import_dayjs.default)(schedule.start_time);
   const endDate = (0, import_dayjs.default)(schedule.end_time);
-  const isInBasicRange = targetDate.isSameOrAfter(startDate) && targetDate.isSameOrBefore(endDate);
+  const isInBasicRange = targetDate.isSameOrAfter(startDate) && targetDate.isBefore(endDate);
   if (schedule.repeat_type === "none") {
     return isInBasicRange;
   }
@@ -80,13 +80,13 @@ var isInTimeSlotsSchedule = (targetDate, targetDateString, targetTimeString, sch
   if (!schedule.start_time) {
     return false;
   }
-  const scheduleDate = schedule.start_time.split(" ")[0];
-  if (targetDateString !== scheduleDate) {
+  const scheduleStartDate = (0, import_dayjs.default)(schedule.start_time.split(" ")[0]);
+  if (!isDateInTimeSlotsSchedule(targetDate, schedule, scheduleStartDate)) {
     return false;
   }
   for (const timeSlot of schedule.time_slot) {
-    const slotStart = `${scheduleDate} ${timeSlot.start_time}:00`;
-    const slotEnd = `${scheduleDate} ${timeSlot.end_time}:00`;
+    const slotStart = `${targetDateString} ${timeSlot.start_time}:00`;
+    const slotEnd = `${targetDateString} ${timeSlot.end_time}:00`;
     const slotStartDate = (0, import_dayjs.default)(slotStart);
     const slotEndDate = (0, import_dayjs.default)(slotEnd);
     if (targetDate.isSameOrAfter(slotStartDate) && targetDate.isSameOrBefore(slotEndDate)) {

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

@@ -26,19 +26,10 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     getOtherProductsIds(): number[];
     storeChange(): void;
     /**
-     * 传入一个时间, 判断改时间是否在schedule 内
-     * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
-     * @returns
-     */
-    isInScheduleByDate({ date, schedule, }: {
-        date: string;
-        schedule: any;
-    }): boolean;
-    /**
-     * 传入一个时间, 判断改时间是否在schedule 内
-     * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
-     * @returns
-     */
+   * 传入一个时间, 判断改时间是否在schedule 内
+   * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
+   * @returns
+   */
     static isInScheduleByDate({ date, schedule, }: {
         date: string;
         schedule: any;

package/lib/modules/Schedule/index.js

@@ -161,21 +161,10 @@ var ScheduleModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 传入一个时间, 判断改时间是否在schedule 内
-   * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
-   * @returns
-   */
-  isInScheduleByDate({
-    date,
-    schedule
-  }) {
-    return ScheduleModule.isInScheduleByDate({ date, schedule });
-  }
-  /**
-   * 传入一个时间, 判断改时间是否在schedule 内
-   * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
-   * @returns
-   */
+  * 传入一个时间, 判断改时间是否在schedule 内
+  * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
+  * @returns
+  */
   static isInScheduleByDate({
     date,
     schedule

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

@@ -46,7 +46,7 @@ export declare const formatScheduleResult: (schedule: ScheduleItem) => {
 };
 export declare const calcScheduleDateRange: (schedule: ScheduleItem) => any[];
 export declare const calcCalendarDataBySchedules: (schedules: ScheduleItem[]) => unknown[];
-export declare const calcMinTimeMaxTimeBySchedules: (schedules: ScheduleItem[], scheduleAllMap?: ScheduleAllMap, selectDate?: string) => {};
+export declare const calcMinTimeMaxTimeBySchedules: (schedules: ScheduleItem[], scheduleAllMap?: ScheduleAllMap, selectDate?: string) => ScheduleAllMap;
 /**
  * @title: 格式化日程数据
  * @description:

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

@@ -13,6 +13,7 @@ export declare class SummaryModule extends BaseModule implements Module, ISummar
     private fatherModule;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    getSurchargeList(): Promise<void>;
     getSummary(cartItems: CartItem[]): Promise<ISummaryState['summary']>;
     /**
      * 获取协议
@@ -21,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

@@ -1,6 +1,8 @@
+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)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/Summary/index.ts
@@ -22,7 +32,9 @@ __export(Summary_exports, {
   SummaryModule: () => SummaryModule
 });
 module.exports = __toCommonJS(Summary_exports);
+var import_decimal = __toESM(require("decimal.js"));
 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) {
@@ -50,11 +62,30 @@ var SummaryModule = class extends import_BaseModule.BaseModule {
     if (!this.shopStore) {
       throw new Error("SummaryModule 需要 shopStore 插件支持");
     }
+    this.getSurchargeList();
+  }
+  async getSurchargeList() {
+    const surchargeList = await this.request.get("/order/custom-surcharge/available/v2", {
+      channel: "online-store",
+      is_assemble_product_data: 1,
+      is_assemble_schedule_data: 1,
+      with: ["relationSchedule"]
+    });
+    this.store.surchargeList = (surchargeList == null ? void 0 : surchargeList.data) || [];
   }
   async getSummary(cartItems) {
-    var _a, _b;
+    var _a, _b, _c;
     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);
+    const scheduleModule = this.core.getModule("appointmentBooking_schedule");
+    const needScheduleIds = this.store.surchargeList.map((item) => item.available_schedule_ids).flat();
+    const scheduleList = scheduleModule == null ? void 0 : scheduleModule.getScheduleListByIds(needScheduleIds);
+    const scheduleById = {};
+    if (Array.isArray(scheduleList)) {
+      for (let item of scheduleList) {
+        scheduleById[item.id] = item;
+      }
+    }
+    const summary = (0, import_utils.calculatePriceDetails)(shopInfo, cartItems, (_c = import_Schedule.ScheduleModule) == null ? void 0 : _c.isInScheduleByDate, this.store.surchargeList, scheduleById);
     this.store.summary = summary;
     return this.store.summary;
   }
@@ -76,6 +107,34 @@ 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,
+        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 scheduleModule = this.core.getModule("appointmentBooking_schedule");
+    const needScheduleIds = this.store.surchargeList.map((item) => item.available_schedule_ids).flat();
+    const scheduleList = scheduleModule == null ? void 0 : scheduleModule.getScheduleListByIds(needScheduleIds);
+    const scheduleById = {};
+    if (Array.isArray(scheduleList)) {
+      for (let item of scheduleList) {
+        scheduleById[item.id] = item;
+      }
+    }
+    const surchargeList = (0, import_utils.getSurcharge)({ service: items, addons: [], bookingDetail: null, bookingId: void 0 }, { isEdit: false, isInScheduleByDate: import_Schedule.ScheduleModule.isInScheduleByDate, surcharge_list: this.store.surchargeList, scheduleById });
+    const surchargeAmount = new import_decimal.default((0, import_utils.getSurchargeAmount)({ bookingDetail: null, bookingId: void 0 }, surchargeList, { isEdit: false }));
+    return {
+      surchargeList,
+      surchargeAmount: surchargeAmount.toFixed(2)
+    };
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1,5 +1,6 @@
 import { CartItem } from '../Cart/types';
 export interface ISummaryState {
+    surchargeList: any[];
     summary: {
         /** 商品总价 */
         subtotal: string | number;
@@ -13,6 +14,12 @@ export interface ISummaryState {
         totalTaxFee?: string | number;
         /** 商品价格是否包含费率 */
         isPriceIncludeTax?: 0 | 1;
+        /** 附加费金额 */
+        surchargeAmount?: string | number;
+        /** 附加费列表 */
+        surcharge?: any[];
+        /** 税率 */
+        taxRate?: string | number;
         /** 定金 */
         deposit?: {
             /** 定金总价 */

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

@@ -1,12 +1,57 @@
 import Decimal from 'decimal.js';
 import { CartItem } from '../Cart/types';
 import { ISummaryState } from './types';
-export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[]) => ISummaryState['summary'];
+export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[], isInScheduleByDate: any, surchargeList: any[], scheduleById: Record<string, any>) => ISummaryState['summary'];
 /**
  * 获取子商品折扣信息
  * @param item
  */
 export declare const getBundleDiscountList: (bundle: any[]) => any[];
+export declare const calcDiscountListDifference: (discountList: any[]) => number;
+export declare const getProductDiscountProductDiscountDifference: (item: CartItem) => number;
+/**
+ * 计算订单税费（折扣前/折扣后），并把单品税费信息回写到商品数据上（用于明细展示/后续计算）。
+ *
+ * - **折扣前税费**：`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 | string>;
+    tax_rate?: number;
+    is_price_include_tax?: number;
+} & Record<string, any>) => {
+    originTax: number;
+    tax: number;
+};
 /**
  * 计算商品小计（不含其他费用）
  * @param items - 购物车商品数组
@@ -38,3 +83,61 @@ 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) => number;
+/**
+ * 订单附加费各项信息
+ *
+ * - **详情未编辑**（`!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;
+    addons: any;
+    bookingDetail?: any;
+    bookingId?: number | undefined;
+}, options: {
+    isEdit: boolean;
+    isInScheduleByDate: any;
+    surcharge_list?: any[];
+    scheduleById?: Record<string, any>;
+} & Record<string, any>) => any;